sys/cam/ata/ata_pmp.c

   1 /*-
   2  * Copyright (c) 2009 Alexander Motin <mav@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31
  32 #ifdef _KERNEL
  33 #include <sys/systm.h>
  34 #include <sys/kernel.h>
  35 #include <sys/bio.h>
  36 #include <sys/sysctl.h>
  37 #include <sys/taskqueue.h>
  38 #include <sys/lock.h>
  39 #include <sys/mutex.h>
  40 #include <sys/conf.h>
  41 #include <sys/devicestat.h>
  42 #include <sys/eventhandler.h>
  43 #include <sys/malloc.h>
  44 #include <sys/cons.h>
  45 #include <geom/geom_disk.h>
  46 #endif /* _KERNEL */
  47
  48 #ifndef _KERNEL
  49 #include <stdio.h>
  50 #include <string.h>
  51 #endif /* _KERNEL */
  52
  53 #include <cam/cam.h>
  54 #include <cam/cam_ccb.h>
  55 #include <cam/cam_periph.h>
  56 #include <cam/cam_xpt_periph.h>
  57 #include <cam/cam_xpt_internal.h>
  58 #include <cam/cam_sim.h>
  59
  60 #include <cam/ata/ata_all.h>
  61
  62 #ifdef _KERNEL
  63
  64 typedef enum {
  65         PMP_STATE_NORMAL,
  66         PMP_STATE_PORTS,
  67         PMP_STATE_PRECONFIG,
  68         PMP_STATE_RESET,
  69         PMP_STATE_CONNECT,
  70         PMP_STATE_CHECK,
  71         PMP_STATE_CLEAR,
  72         PMP_STATE_CONFIG,
  73         PMP_STATE_SCAN
  74 } pmp_state;
  75
  76 typedef enum {
  77         PMP_FLAG_SCTX_INIT      = 0x200
  78 } pmp_flags;
  79
  80 typedef enum {
  81         PMP_CCB_PROBE           = 0x01,
  82 } pmp_ccb_state;
  83
  84 /* Offsets into our private area for storing information */
  85 #define ccb_state       ppriv_field0
  86 #define ccb_bp          ppriv_ptr1
  87
  88 struct pmp_softc {
  89         SLIST_ENTRY(pmp_softc)  links;
  90         pmp_state               state;
  91         pmp_flags               flags;
  92         uint32_t                pm_pid;
  93         uint32_t                pm_prv;
  94         int                     pm_ports;
  95         int                     pm_step;
  96         int                     pm_try;
  97         int                     found;
  98         int                     reset;
  99         int                     frozen;
 100         int                     restart;
 101         int                     events;
 102 #define PMP_EV_RESET    1
 103 #define PMP_EV_RESCAN   2
 104         u_int                   caps;
 105         struct task             sysctl_task;
 106         struct sysctl_ctx_list  sysctl_ctx;
 107         struct sysctl_oid       *sysctl_tree;
 108 };
 109
 110 static  periph_init_t   pmpinit;
 111 static  void            pmpasync(void *callback_arg, u_int32_t code,
 112                                 struct cam_path *path, void *arg);
 113 static  void            pmpsysctlinit(void *context, int pending);
 114 static  periph_ctor_t   pmpregister;
 115 static  periph_dtor_t   pmpcleanup;
 116 static  periph_start_t  pmpstart;
 117 static  periph_oninv_t  pmponinvalidate;
 118 static  void            pmpdone(struct cam_periph *periph,
 119                                union ccb *done_ccb);
 120
 121 #ifndef PMP_DEFAULT_TIMEOUT
 122 #define PMP_DEFAULT_TIMEOUT 30  /* Timeout in seconds */
 123 #endif
 124
 125 #ifndef PMP_DEFAULT_RETRY
 126 #define PMP_DEFAULT_RETRY       1
 127 #endif
 128
 129 static int pmp_retry_count = PMP_DEFAULT_RETRY;
 130 static int pmp_default_timeout = PMP_DEFAULT_TIMEOUT;
 131
 132 SYSCTL_NODE(_kern_cam, OID_AUTO, pmp, CTLFLAG_RD, 0,
 133             "CAM Direct Access Disk driver");
 134 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, retry_count, CTLFLAG_RW,
 135            &pmp_retry_count, 0, "Normal I/O retry count");
 136 TUNABLE_INT("kern.cam.pmp.retry_count", &pmp_retry_count);
 137 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, default_timeout, CTLFLAG_RW,
 138            &pmp_default_timeout, 0, "Normal I/O timeout (in seconds)");
 139 TUNABLE_INT("kern.cam.pmp.default_timeout", &pmp_default_timeout);
 140
 141 static struct periph_driver pmpdriver =
 142 {
 143         pmpinit, "pmp",
 144         TAILQ_HEAD_INITIALIZER(pmpdriver.units), /* generation */ 0,
 145         CAM_PERIPH_DRV_EARLY
 146 };
 147
 148 PERIPHDRIVER_DECLARE(pmp, pmpdriver);
 149
 150 MALLOC_DEFINE(M_ATPMP, "ata_pmp", "ata_pmp buffers");
 151
 152 static void
 153 pmpinit(void)
 154 {
 155         cam_status status;
 156
 157         /*
 158          * Install a global async callback.  This callback will
 159          * receive async callbacks like "new device found".
 160          */
 161         status = xpt_register_async(AC_FOUND_DEVICE, pmpasync, NULL, NULL);
 162
 163         if (status != CAM_REQ_CMP) {
 164                 printf("pmp: Failed to attach master async callback "
 165                        "due to status 0x%x!\n", status);
 166         }
 167 }
 168
 169 static void
 170 pmpfreeze(struct cam_periph *periph, int mask)
 171 {
 172         struct pmp_softc *softc = (struct pmp_softc *)periph->softc;
 173         struct cam_path *dpath;
 174         int i;
 175
 176         mask &= ~softc->frozen;
 177         for (i = 0; i < 15; i++) {
 178                 if ((mask & (1 << i)) == 0)
 179                         continue;
 180                 if (xpt_create_path(&dpath, periph,
 181                     xpt_path_path_id(periph->path),
 182                     i, 0) == CAM_REQ_CMP) {
 183                         softc->frozen |= (1 << i);
 184                         xpt_acquire_device(dpath->device);
 185                         cam_freeze_devq_arg(dpath,
 186                             RELSIM_RELEASE_RUNLEVEL, CAM_RL_BUS + 1);
 187                         xpt_free_path(dpath);
 188                 }
 189         }
 190 }
 191
 192 static void
 193 pmprelease(struct cam_periph *periph, int mask)
 194 {
 195         struct pmp_softc *softc = (struct pmp_softc *)periph->softc;
 196         struct cam_path *dpath;
 197         int i;
 198
 199         mask &= softc->frozen;
 200         for (i = 0; i < 15; i++) {
 201                 if ((mask & (1 << i)) == 0)
 202                         continue;
 203                 if (xpt_create_path(&dpath, periph,
 204                     xpt_path_path_id(periph->path),
 205                     i, 0) == CAM_REQ_CMP) {
 206                         softc->frozen &= ~(1 << i);
 207                         cam_release_devq(dpath,
 208                             RELSIM_RELEASE_RUNLEVEL, 0, CAM_RL_BUS + 1, FALSE);
 209                         xpt_release_device(dpath->device);
 210                         xpt_free_path(dpath);
 211                 }
 212         }
 213 }
 214
 215 static void
 216 pmponinvalidate(struct cam_periph *periph)
 217 {
 218         struct pmp_softc *softc;
 219         struct cam_path *dpath;
 220         int i;
 221
 222         softc = (struct pmp_softc *)periph->softc;
 223
 224         /*
 225          * De-register any async callbacks.
 226          */
 227         xpt_register_async(0, pmpasync, periph, periph->path);
 228
 229         for (i = 0; i < 15; i++) {
 230                 if (xpt_create_path(&dpath, periph,
 231                     xpt_path_path_id(periph->path),
 232                     i, 0) == CAM_REQ_CMP) {
 233                         xpt_async(AC_LOST_DEVICE, dpath, NULL);
 234                         xpt_free_path(dpath);
 235                 }
 236         }
 237         pmprelease(periph, -1);
 238         xpt_print(periph->path, "lost device\n");
 239 }
 240
 241 static void
 242 pmpcleanup(struct cam_periph *periph)
 243 {
 244         struct pmp_softc *softc;
 245
 246         softc = (struct pmp_softc *)periph->softc;
 247
 248         xpt_print(periph->path, "removing device entry\n");
 249         cam_periph_unlock(periph);
 250
 251         /*
 252          * If we can't free the sysctl tree, oh well...
 253          */
 254         if ((softc->flags & PMP_FLAG_SCTX_INIT) != 0
 255             && sysctl_ctx_free(&softc->sysctl_ctx) != 0) {
 256                 xpt_print(periph->path, "can't remove sysctl context\n");
 257         }
 258
 259         free(softc, M_DEVBUF);
 260         cam_periph_lock(periph);
 261 }
 262
 263 static void
 264 pmpasync(void *callback_arg, u_int32_t code,
 265         struct cam_path *path, void *arg)
 266 {
 267         struct cam_periph *periph;
 268         struct pmp_softc *softc;
 269
 270         periph = (struct cam_periph *)callback_arg;
 271         switch (code) {
 272         case AC_FOUND_DEVICE:
 273         {
 274                 struct ccb_getdev *cgd;
 275                 cam_status status;
 276
 277                 cgd = (struct ccb_getdev *)arg;
 278                 if (cgd == NULL)
 279                         break;
 280
 281                 if (cgd->protocol != PROTO_SATAPM)
 282                         break;
 283
 284                 /*
 285                  * Allocate a peripheral instance for
 286                  * this device and start the probe
 287                  * process.
 288                  */
 289                 status = cam_periph_alloc(pmpregister, pmponinvalidate,
 290                                           pmpcleanup, pmpstart,
 291                                           "pmp", CAM_PERIPH_BIO,
 292                                           cgd->ccb_h.path, pmpasync,
 293                                           AC_FOUND_DEVICE, cgd);
 294
 295                 if (status != CAM_REQ_CMP
 296                  && status != CAM_REQ_INPROG)
 297                         printf("pmpasync: Unable to attach to new device "
 298                                 "due to status 0x%x\n", status);
 299                 break;
 300         }
 301         case AC_SCSI_AEN:
 302         case AC_SENT_BDR:
 303         case AC_BUS_RESET:
 304                 softc = (struct pmp_softc *)periph->softc;
 305                 cam_periph_async(periph, code, path, arg);
 306                 if (code == AC_SCSI_AEN)
 307                         softc->events |= PMP_EV_RESCAN;
 308                 else
 309                         softc->events |= PMP_EV_RESET;
 310                 if (code == AC_SCSI_AEN && softc->state != PMP_STATE_NORMAL)
 311                         break;
 312                 xpt_hold_boot();
 313                 pmpfreeze(periph, softc->found);
 314                 if (code == AC_SENT_BDR || code == AC_BUS_RESET)
 315                         softc->found = 0; /* We have to reset everything. */
 316                 if (softc->state == PMP_STATE_NORMAL) {
 317                         softc->state = PMP_STATE_PRECONFIG;
 318                         cam_periph_acquire(periph);
 319                         xpt_schedule(periph, CAM_PRIORITY_DEV);
 320                 } else
 321                         softc->restart = 1;
 322                 break;
 323         default:
 324                 cam_periph_async(periph, code, path, arg);
 325                 break;
 326         }
 327 }
 328
 329 static void
 330 pmpsysctlinit(void *context, int pending)
 331 {
 332         struct cam_periph *periph;
 333         struct pmp_softc *softc;
 334         char tmpstr[80], tmpstr2[80];
 335
 336         periph = (struct cam_periph *)context;
 337         if (cam_periph_acquire(periph) != CAM_REQ_CMP)
 338                 return;
 339
 340         softc = (struct pmp_softc *)periph->softc;
 341         snprintf(tmpstr, sizeof(tmpstr), "CAM PMP unit %d", periph->unit_number);
 342         snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
 343
 344         sysctl_ctx_init(&softc->sysctl_ctx);
 345         softc->flags |= PMP_FLAG_SCTX_INIT;
 346         softc->sysctl_tree = SYSCTL_ADD_NODE(&softc->sysctl_ctx,
 347                 SYSCTL_STATIC_CHILDREN(_kern_cam_pmp), OID_AUTO, tmpstr2,
 348                 CTLFLAG_RD, 0, tmpstr);
 349         if (softc->sysctl_tree == NULL) {
 350                 printf("pmpsysctlinit: unable to allocate sysctl tree\n");
 351                 cam_periph_release(periph);
 352                 return;
 353         }
 354
 355         cam_periph_release(periph);
 356 }
 357
 358 static cam_status
 359 pmpregister(struct cam_periph *periph, void *arg)
 360 {
 361         struct pmp_softc *softc;
 362         struct ccb_getdev *cgd;
 363
 364         cgd = (struct ccb_getdev *)arg;
 365         if (periph == NULL) {
 366                 printf("pmpregister: periph was NULL!!\n");
 367                 return(CAM_REQ_CMP_ERR);
 368         }
 369
 370         if (cgd == NULL) {
 371                 printf("pmpregister: no getdev CCB, can't register device\n");
 372                 return(CAM_REQ_CMP_ERR);
 373         }
 374
 375         softc = (struct pmp_softc *)malloc(sizeof(*softc), M_DEVBUF,
 376             M_NOWAIT|M_ZERO);
 377
 378         if (softc == NULL) {
 379                 printf("pmpregister: Unable to probe new device. "
 380                        "Unable to allocate softc\n");
 381                 return(CAM_REQ_CMP_ERR);
 382         }
 383         periph->softc = softc;
 384
 385         softc->pm_pid = ((uint32_t *)&cgd->ident_data)[0];
 386         softc->pm_prv = ((uint32_t *)&cgd->ident_data)[1];
 387         TASK_INIT(&softc->sysctl_task, 0, pmpsysctlinit, periph);
 388
 389         xpt_announce_periph(periph, NULL);
 390
 391         /*
 392          * Add async callbacks for bus reset and
 393          * bus device reset calls.  I don't bother
 394          * checking if this fails as, in most cases,
 395          * the system will function just fine without
 396          * them and the only alternative would be to
 397          * not attach the device on failure.
 398          */
 399         xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
 400                 AC_SCSI_AEN, pmpasync, periph, periph->path);
 401
 402         /*
 403          * Take an exclusive refcount on the periph while pmpstart is called
 404          * to finish the probe.  The reference will be dropped in pmpdone at
 405          * the end of probe.
 406          */
 407         (void)cam_periph_acquire(periph);
 408         xpt_hold_boot();
 409         softc->state = PMP_STATE_PORTS;
 410         softc->events = PMP_EV_RESCAN;
 411         xpt_schedule(periph, CAM_PRIORITY_DEV);
 412
 413         return(CAM_REQ_CMP);
 414 }
 415
 416 static void
 417 pmpstart(struct cam_periph *periph, union ccb *start_ccb)
 418 {
 419         struct ccb_trans_settings cts;
 420         struct ccb_ataio *ataio;
 421         struct pmp_softc *softc;
 422         struct cam_path *dpath;
 423         int revision = 0;
 424
 425         softc = (struct pmp_softc *)periph->softc;
 426         ataio = &start_ccb->ataio;
 427
 428         if (softc->restart) {
 429                 softc->restart = 0;
 430                 softc->state = min(softc->state, PMP_STATE_PRECONFIG);
 431         }
 432         /* Fetch user wanted device speed. */
 433         if (softc->state == PMP_STATE_RESET ||
 434             softc->state == PMP_STATE_CONNECT) {
 435                 if (xpt_create_path(&dpath, periph,
 436                     xpt_path_path_id(periph->path),
 437                     softc->pm_step, 0) == CAM_REQ_CMP) {
 438                         bzero(&cts, sizeof(cts));
 439                         xpt_setup_ccb(&cts.ccb_h, dpath, CAM_PRIORITY_NONE);
 440                         cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 441                         cts.type = CTS_TYPE_USER_SETTINGS;
 442                         xpt_action((union ccb *)&cts);
 443                         if (cts.xport_specific.sata.valid & CTS_SATA_VALID_REVISION)
 444                                 revision = cts.xport_specific.sata.revision;
 445                         xpt_free_path(dpath);
 446                 }
 447         }
 448         switch (softc->state) {
 449         case PMP_STATE_PORTS:
 450                 cam_fill_ataio(ataio,
 451                       pmp_retry_count,
 452                       pmpdone,
 453                       /*flags*/CAM_DIR_NONE,
 454                       0,
 455                       /*data_ptr*/NULL,
 456                       /*dxfer_len*/0,
 457                       pmp_default_timeout * 1000);
 458                 ata_pm_read_cmd(ataio, 2, 15);
 459                 break;
 460         case PMP_STATE_PRECONFIG:
 461                 /* Get/update host SATA capabilities. */
 462                 bzero(&cts, sizeof(cts));
 463                 xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE);
 464                 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 465                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 466                 xpt_action((union ccb *)&cts);
 467                 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_CAPS)
 468                         softc->caps = cts.xport_specific.sata.caps;
 469                 cam_fill_ataio(ataio,
 470                       pmp_retry_count,
 471                       pmpdone,
 472                       /*flags*/CAM_DIR_NONE,
 473                       0,
 474                       /*data_ptr*/NULL,
 475                       /*dxfer_len*/0,
 476                       pmp_default_timeout * 1000);
 477                 ata_pm_write_cmd(ataio, 0x60, 15, 0x0);
 478                 break;
 479         case PMP_STATE_RESET:
 480                 cam_fill_ataio(ataio,
 481                       pmp_retry_count,
 482                       pmpdone,
 483                       /*flags*/CAM_DIR_NONE,
 484                       0,
 485                       /*data_ptr*/NULL,
 486                       /*dxfer_len*/0,
 487                       pmp_default_timeout * 1000);
 488                 ata_pm_write_cmd(ataio, 2, softc->pm_step,
 489                     (revision << 4) |
 490                     ((softc->found & (1 << softc->pm_step)) ? 0 : 1));
 491                 break;
 492         case PMP_STATE_CONNECT:
 493                 cam_fill_ataio(ataio,
 494                       pmp_retry_count,
 495                       pmpdone,
 496                       /*flags*/CAM_DIR_NONE,
 497                       0,
 498                       /*data_ptr*/NULL,
 499                       /*dxfer_len*/0,
 500                       pmp_default_timeout * 1000);
 501                 ata_pm_write_cmd(ataio, 2, softc->pm_step,
 502                     (revision << 4));
 503                 break;
 504         case PMP_STATE_CHECK:
 505                 cam_fill_ataio(ataio,
 506                       pmp_retry_count,
 507                       pmpdone,
 508                       /*flags*/CAM_DIR_NONE,
 509                       0,
 510                       /*data_ptr*/NULL,
 511                       /*dxfer_len*/0,
 512                       pmp_default_timeout * 1000);
 513                 ata_pm_read_cmd(ataio, 0, softc->pm_step);
 514                 break;
 515         case PMP_STATE_CLEAR:
 516                 softc->reset = 0;
 517                 cam_fill_ataio(ataio,
 518                       pmp_retry_count,
 519                       pmpdone,
 520                       /*flags*/CAM_DIR_NONE,
 521                       0,
 522                       /*data_ptr*/NULL,
 523                       /*dxfer_len*/0,
 524                       pmp_default_timeout * 1000);
 525                 ata_pm_write_cmd(ataio, 1, softc->pm_step, 0xFFFFFFFF);
 526                 break;
 527         case PMP_STATE_CONFIG:
 528                 cam_fill_ataio(ataio,
 529                       pmp_retry_count,
 530                       pmpdone,
 531                       /*flags*/CAM_DIR_NONE,
 532                       0,
 533                       /*data_ptr*/NULL,
 534                       /*dxfer_len*/0,
 535                       pmp_default_timeout * 1000);
 536                 ata_pm_write_cmd(ataio, 0x60, 15, 0xf);
 537                 break;
 538         default:
 539                 break;
 540         }
 541         xpt_action(start_ccb);
 542 }
 543
 544 static void
 545 pmpdone(struct cam_periph *periph, union ccb *done_ccb)
 546 {
 547         struct ccb_trans_settings cts;
 548         struct pmp_softc *softc;
 549         struct ccb_ataio *ataio;
 550         struct cam_path *path, *dpath;
 551         u_int32_t  priority, res;
 552         int i;
 553
 554         softc = (struct pmp_softc *)periph->softc;
 555         ataio = &done_ccb->ataio;
 556
 557         CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("pmpdone\n"));
 558
 559         path = done_ccb->ccb_h.path;
 560         priority = done_ccb->ccb_h.pinfo.priority;
 561
 562         if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 563                 if (cam_periph_error(done_ccb, 0, 0, NULL) == ERESTART) {
 564                         return;
 565                 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
 566                         cam_release_devq(done_ccb->ccb_h.path,
 567                             /*relsim_flags*/0,
 568                             /*reduction*/0,
 569                             /*timeout*/0,
 570                             /*getcount_only*/0);
 571                 }
 572                 goto done;
 573         }
 574
 575         if (softc->restart) {
 576                 softc->restart = 0;
 577                 xpt_release_ccb(done_ccb);
 578                 softc->state = min(softc->state, PMP_STATE_PRECONFIG);
 579                 xpt_schedule(periph, priority);
 580                 return;
 581         }
 582
 583         switch (softc->state) {
 584         case PMP_STATE_PORTS:
 585                 softc->pm_ports = (done_ccb->ataio.res.lba_high << 24) +
 586                     (done_ccb->ataio.res.lba_mid << 16) +
 587                     (done_ccb->ataio.res.lba_low << 8) +
 588                     done_ccb->ataio.res.sector_count;
 589                 /* This PMP declares 6 ports, while only 5 of them are real.
 590                  * Port 5 is enclosure management bridge port, which has implementation
 591                  * problems, causing probe faults. Hide it for now. */
 592                 if (softc->pm_pid == 0x37261095 && softc->pm_ports == 6)
 593                         softc->pm_ports = 5;
 594                 /* This PMP declares 7 ports, while only 5 of them are real.
 595                  * Port 5 is some fake "Config  Disk" with 640 sectors size,
 596                  * port 6 is enclosure management bridge port.
 597                  * Both fake ports has implementation problems, causing
 598                  * probe faults. Hide them for now. */
 599                 if (softc->pm_pid == 0x47261095 && softc->pm_ports == 7)
 600                         softc->pm_ports = 5;
 601                 /* These PMPs declare one more port then actually have,
 602                  * for configuration purposes. Hide it for now. */
 603                 if (softc->pm_pid == 0x57231095 || softc->pm_pid == 0x57331095 ||
 604                     softc->pm_pid == 0x57341095 || softc->pm_pid == 0x57441095)
 605                         softc->pm_ports--;
 606                 printf("%s%d: %d fan-out ports\n",
 607                     periph->periph_name, periph->unit_number,
 608                     softc->pm_ports);
 609                 softc->state = PMP_STATE_PRECONFIG;
 610                 xpt_release_ccb(done_ccb);
 611                 xpt_schedule(periph, priority);
 612                 return;
 613         case PMP_STATE_PRECONFIG:
 614                 softc->pm_step = 0;
 615                 softc->state = PMP_STATE_RESET;
 616                 softc->reset |= ~softc->found;
 617                 xpt_release_ccb(done_ccb);
 618                 xpt_schedule(periph, priority);
 619                 return;
 620         case PMP_STATE_RESET:
 621                 softc->pm_step++;
 622                 if (softc->pm_step >= softc->pm_ports) {
 623                         softc->pm_step = 0;
 624                         cam_freeze_devq(periph->path);
 625                         cam_release_devq(periph->path,
 626                             RELSIM_RELEASE_AFTER_TIMEOUT,
 627                             /*reduction*/0,
 628                             /*timeout*/5,
 629                             /*getcount_only*/0);
 630                         softc->state = PMP_STATE_CONNECT;
 631                 }
 632                 xpt_release_ccb(done_ccb);
 633                 xpt_schedule(periph, priority);
 634                 return;
 635         case PMP_STATE_CONNECT:
 636                 softc->pm_step++;
 637                 if (softc->pm_step >= softc->pm_ports) {
 638                         softc->pm_step = 0;
 639                         softc->pm_try = 0;
 640                         cam_freeze_devq(periph->path);
 641                         cam_release_devq(periph->path,
 642                             RELSIM_RELEASE_AFTER_TIMEOUT,
 643                             /*reduction*/0,
 644                             /*timeout*/10,
 645                             /*getcount_only*/0);
 646                         softc->state = PMP_STATE_CHECK;
 647                 }
 648                 xpt_release_ccb(done_ccb);
 649                 xpt_schedule(periph, priority);
 650                 return;
 651         case PMP_STATE_CHECK:
 652                 res = (done_ccb->ataio.res.lba_high << 24) +
 653                     (done_ccb->ataio.res.lba_mid << 16) +
 654                     (done_ccb->ataio.res.lba_low << 8) +
 655                     done_ccb->ataio.res.sector_count;
 656                 if (((res & 0xf0f) == 0x103 && (res & 0x0f0) != 0) ||
 657                     (res & 0x600) != 0) {
 658                         if (bootverbose) {
 659                                 printf("%s%d: port %d status: %08x\n",
 660                                     periph->periph_name, periph->unit_number,
 661                                     softc->pm_step, res);
 662                         }
 663                         /* Report device speed if it is online. */
 664                         if ((res & 0xf0f) == 0x103 &&
 665                             xpt_create_path(&dpath, periph,
 666                             xpt_path_path_id(periph->path),
 667                             softc->pm_step, 0) == CAM_REQ_CMP) {
 668                                 bzero(&cts, sizeof(cts));
 669                                 xpt_setup_ccb(&cts.ccb_h, dpath, CAM_PRIORITY_NONE);
 670                                 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
 671                                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 672                                 cts.xport_specific.sata.revision = (res & 0x0f0) >> 4;
 673                                 cts.xport_specific.sata.valid = CTS_SATA_VALID_REVISION;
 674                                 cts.xport_specific.sata.caps = softc->caps &
 675                                     (CTS_SATA_CAPS_H_PMREQ | CTS_SATA_CAPS_H_DMAAA);
 676                                 cts.xport_specific.sata.valid |= CTS_SATA_VALID_CAPS;
 677                                 xpt_action((union ccb *)&cts);
 678                                 xpt_free_path(dpath);
 679                         }
 680                         softc->found |= (1 << softc->pm_step);
 681                         softc->pm_step++;
 682                 } else {
 683                         if (softc->pm_try < 10) {
 684                                 cam_freeze_devq(periph->path);
 685                                 cam_release_devq(periph->path,
 686                                     RELSIM_RELEASE_AFTER_TIMEOUT,
 687                                     /*reduction*/0,
 688                                     /*timeout*/10,
 689                                     /*getcount_only*/0);
 690                                 softc->pm_try++;
 691                         } else {
 692                                 if (bootverbose) {
 693                                         printf("%s%d: port %d status: %08x\n",
 694                                             periph->periph_name, periph->unit_number,
 695                                             softc->pm_step, res);
 696                                 }
 697                                 softc->found &= ~(1 << softc->pm_step);
 698                                 if (xpt_create_path(&dpath, periph,
 699                                     done_ccb->ccb_h.path_id,
 700                                     softc->pm_step, 0) == CAM_REQ_CMP) {
 701                                         xpt_async(AC_LOST_DEVICE, dpath, NULL);
 702                                         xpt_free_path(dpath);
 703                                 }
 704                                 softc->pm_step++;
 705                         }
 706                 }
 707                 if (softc->pm_step >= softc->pm_ports) {
 708                         if (softc->reset & softc->found) {
 709                                 cam_freeze_devq(periph->path);
 710                                 cam_release_devq(periph->path,
 711                                     RELSIM_RELEASE_AFTER_TIMEOUT,
 712                                     /*reduction*/0,
 713                                     /*timeout*/1000,
 714                                     /*getcount_only*/0);
 715                         }
 716                         softc->state = PMP_STATE_CLEAR;
 717                         softc->pm_step = 0;
 718                 }
 719                 xpt_release_ccb(done_ccb);
 720                 xpt_schedule(periph, priority);
 721                 return;
 722         case PMP_STATE_CLEAR:
 723                 softc->pm_step++;
 724                 if (softc->pm_step >= softc->pm_ports) {
 725                         softc->state = PMP_STATE_CONFIG;
 726                         softc->pm_step = 0;
 727                 }
 728                 xpt_release_ccb(done_ccb);
 729                 xpt_schedule(periph, priority);
 730                 return;
 731         case PMP_STATE_CONFIG:
 732                 for (i = 0; i < softc->pm_ports; i++) {
 733                         union ccb *ccb;
 734
 735                         if ((softc->found & (1 << i)) == 0)
 736                                 continue;
 737                         if (xpt_create_path(&dpath, periph,
 738                             xpt_path_path_id(periph->path),
 739                             i, 0) != CAM_REQ_CMP) {
 740                                 printf("pmpdone: xpt_create_path failed"
 741                                     ", bus scan halted\n");
 742                                 xpt_free_ccb(done_ccb);
 743                                 goto done;
 744                         }
 745                         /* If we did hard reset to this device, inform XPT. */
 746                         if ((softc->reset & softc->found & (1 << i)) != 0)
 747                                 xpt_async(AC_SENT_BDR, dpath, NULL);
 748                         /* If rescan requested, scan this device. */
 749                         if (softc->events & PMP_EV_RESCAN) {
 750                                 ccb = xpt_alloc_ccb_nowait();
 751                                 if (ccb == NULL) {
 752                                         xpt_free_path(dpath);
 753                                         goto done;
 754                                 }
 755                                 xpt_setup_ccb(&ccb->ccb_h, dpath, CAM_PRIORITY_XPT);
 756                                 xpt_rescan(ccb);
 757                         } else
 758                                 xpt_free_path(dpath);
 759                 }
 760                 break;
 761         default:
 762                 break;
 763         }
 764 done:
 765         xpt_release_ccb(done_ccb);
 766         softc->state = PMP_STATE_NORMAL;
 767         softc->events = 0;
 768         xpt_release_boot();
 769         pmprelease(periph, -1);
 770         cam_periph_release_locked(periph);
 771 }
 772
 773 #endif /* _KERNEL */