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 #ifndef PMP_DEFAULT_HIDE_SPECIAL
 130 #define PMP_DEFAULT_HIDE_SPECIAL        1
 131 #endif
 132
 133 static int pmp_retry_count = PMP_DEFAULT_RETRY;
 134 static int pmp_default_timeout = PMP_DEFAULT_TIMEOUT;
 135 static int pmp_hide_special = PMP_DEFAULT_HIDE_SPECIAL;
 136
 137 SYSCTL_NODE(_kern_cam, OID_AUTO, pmp, CTLFLAG_RD, 0,
 138             "CAM Direct Access Disk driver");
 139 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, retry_count, CTLFLAG_RW,
 140            &pmp_retry_count, 0, "Normal I/O retry count");
 141 TUNABLE_INT("kern.cam.pmp.retry_count", &pmp_retry_count);
 142 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, default_timeout, CTLFLAG_RW,
 143            &pmp_default_timeout, 0, "Normal I/O timeout (in seconds)");
 144 TUNABLE_INT("kern.cam.pmp.default_timeout", &pmp_default_timeout);
 145 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, hide_special, CTLFLAG_RW,
 146            &pmp_hide_special, 0, "Hide extra ports");
 147 TUNABLE_INT("kern.cam.pmp.hide_special", &pmp_hide_special);
 148
 149 static struct periph_driver pmpdriver =
 150 {
 151         pmpinit, "pmp",
 152         TAILQ_HEAD_INITIALIZER(pmpdriver.units), /* generation */ 0,
 153         CAM_PERIPH_DRV_EARLY
 154 };
 155
 156 PERIPHDRIVER_DECLARE(pmp, pmpdriver);
 157
 158 MALLOC_DEFINE(M_ATPMP, "ata_pmp", "ata_pmp buffers");
 159
 160 static void
 161 pmpinit(void)
 162 {
 163         cam_status status;
 164
 165         /*
 166          * Install a global async callback.  This callback will
 167          * receive async callbacks like "new device found".
 168          */
 169         status = xpt_register_async(AC_FOUND_DEVICE, pmpasync, NULL, NULL);
 170
 171         if (status != CAM_REQ_CMP) {
 172                 printf("pmp: Failed to attach master async callback "
 173                        "due to status 0x%x!\n", status);
 174         }
 175 }
 176
 177 static void
 178 pmpfreeze(struct cam_periph *periph, int mask)
 179 {
 180         struct pmp_softc *softc = (struct pmp_softc *)periph->softc;
 181         struct cam_path *dpath;
 182         int i;
 183
 184         mask &= ~softc->frozen;
 185         for (i = 0; i < 15; i++) {
 186                 if ((mask & (1 << i)) == 0)
 187                         continue;
 188                 if (xpt_create_path(&dpath, periph,
 189                     xpt_path_path_id(periph->path),
 190                     i, 0) == CAM_REQ_CMP) {
 191                         softc->frozen |= (1 << i);
 192                         xpt_acquire_device(dpath->device);
 193                         cam_freeze_devq_arg(dpath,
 194                             RELSIM_RELEASE_RUNLEVEL, CAM_RL_BUS + 1);
 195                         xpt_free_path(dpath);
 196                 }
 197         }
 198 }
 199
 200 static void
 201 pmprelease(struct cam_periph *periph, int mask)
 202 {
 203         struct pmp_softc *softc = (struct pmp_softc *)periph->softc;
 204         struct cam_path *dpath;
 205         int i;
 206
 207         mask &= softc->frozen;
 208         for (i = 0; i < 15; i++) {
 209                 if ((mask & (1 << i)) == 0)
 210                         continue;
 211                 if (xpt_create_path(&dpath, periph,
 212                     xpt_path_path_id(periph->path),
 213                     i, 0) == CAM_REQ_CMP) {
 214                         softc->frozen &= ~(1 << i);
 215                         cam_release_devq(dpath,
 216                             RELSIM_RELEASE_RUNLEVEL, 0, CAM_RL_BUS + 1, FALSE);
 217                         xpt_release_device(dpath->device);
 218                         xpt_free_path(dpath);
 219                 }
 220         }
 221 }
 222
 223 static void
 224 pmponinvalidate(struct cam_periph *periph)
 225 {
 226         struct cam_path *dpath;
 227         int i;
 228
 229         /*
 230          * De-register any async callbacks.
 231          */
 232         xpt_register_async(0, pmpasync, periph, periph->path);
 233
 234         for (i = 0; i < 15; i++) {
 235                 if (xpt_create_path(&dpath, periph,
 236                     xpt_path_path_id(periph->path),
 237                     i, 0) == CAM_REQ_CMP) {
 238                         xpt_async(AC_LOST_DEVICE, dpath, NULL);
 239                         xpt_free_path(dpath);
 240                 }
 241         }
 242         pmprelease(periph, -1);
 243         xpt_print(periph->path, "lost device\n");
 244 }
 245
 246 static void
 247 pmpcleanup(struct cam_periph *periph)
 248 {
 249         struct pmp_softc *softc;
 250
 251         softc = (struct pmp_softc *)periph->softc;
 252
 253         xpt_print(periph->path, "removing device entry\n");
 254         cam_periph_unlock(periph);
 255
 256         /*
 257          * If we can't free the sysctl tree, oh well...
 258          */
 259         if ((softc->flags & PMP_FLAG_SCTX_INIT) != 0
 260             && sysctl_ctx_free(&softc->sysctl_ctx) != 0) {
 261                 xpt_print(periph->path, "can't remove sysctl context\n");
 262         }
 263
 264         free(softc, M_DEVBUF);
 265         cam_periph_lock(periph);
 266 }
 267
 268 static void
 269 pmpasync(void *callback_arg, u_int32_t code,
 270         struct cam_path *path, void *arg)
 271 {
 272         struct cam_periph *periph;
 273         struct pmp_softc *softc;
 274
 275         periph = (struct cam_periph *)callback_arg;
 276         switch (code) {
 277         case AC_FOUND_DEVICE:
 278         {
 279                 struct ccb_getdev *cgd;
 280                 cam_status status;
 281
 282                 cgd = (struct ccb_getdev *)arg;
 283                 if (cgd == NULL)
 284                         break;
 285
 286                 if (cgd->protocol != PROTO_SATAPM)
 287                         break;
 288
 289                 /*
 290                  * Allocate a peripheral instance for
 291                  * this device and start the probe
 292                  * process.
 293                  */
 294                 status = cam_periph_alloc(pmpregister, pmponinvalidate,
 295                                           pmpcleanup, pmpstart,
 296                                           "pmp", CAM_PERIPH_BIO,
 297                                           cgd->ccb_h.path, pmpasync,
 298                                           AC_FOUND_DEVICE, cgd);
 299
 300                 if (status != CAM_REQ_CMP
 301                  && status != CAM_REQ_INPROG)
 302                         printf("pmpasync: Unable to attach to new device "
 303                                 "due to status 0x%x\n", status);
 304                 break;
 305         }
 306         case AC_SCSI_AEN:
 307         case AC_SENT_BDR:
 308         case AC_BUS_RESET:
 309                 softc = (struct pmp_softc *)periph->softc;
 310                 cam_periph_async(periph, code, path, arg);
 311                 if (code == AC_SCSI_AEN)
 312                         softc->events |= PMP_EV_RESCAN;
 313                 else
 314                         softc->events |= PMP_EV_RESET;
 315                 if (code == AC_SCSI_AEN && softc->state != PMP_STATE_NORMAL)
 316                         break;
 317                 xpt_hold_boot();
 318                 pmpfreeze(periph, softc->found);
 319                 if (code == AC_SENT_BDR || code == AC_BUS_RESET)
 320                         softc->found = 0; /* We have to reset everything. */
 321                 if (softc->state == PMP_STATE_NORMAL) {
 322                         softc->state = PMP_STATE_PRECONFIG;
 323                         cam_periph_acquire(periph);
 324                         xpt_schedule(periph, CAM_PRIORITY_DEV);
 325                 } else
 326                         softc->restart = 1;
 327                 break;
 328         default:
 329                 cam_periph_async(periph, code, path, arg);
 330                 break;
 331         }
 332 }
 333
 334 static void
 335 pmpsysctlinit(void *context, int pending)
 336 {
 337         struct cam_periph *periph;
 338         struct pmp_softc *softc;
 339         char tmpstr[80], tmpstr2[80];
 340
 341         periph = (struct cam_periph *)context;
 342         if (cam_periph_acquire(periph) != CAM_REQ_CMP)
 343                 return;
 344
 345         softc = (struct pmp_softc *)periph->softc;
 346         snprintf(tmpstr, sizeof(tmpstr), "CAM PMP unit %d", periph->unit_number);
 347         snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
 348
 349         sysctl_ctx_init(&softc->sysctl_ctx);
 350         softc->flags |= PMP_FLAG_SCTX_INIT;
 351         softc->sysctl_tree = SYSCTL_ADD_NODE(&softc->sysctl_ctx,
 352                 SYSCTL_STATIC_CHILDREN(_kern_cam_pmp), OID_AUTO, tmpstr2,
 353                 CTLFLAG_RD, 0, tmpstr);
 354         if (softc->sysctl_tree == NULL) {
 355                 printf("pmpsysctlinit: unable to allocate sysctl tree\n");
 356                 cam_periph_release(periph);
 357                 return;
 358         }
 359
 360         cam_periph_release(periph);
 361 }
 362
 363 static cam_status
 364 pmpregister(struct cam_periph *periph, void *arg)
 365 {
 366         struct pmp_softc *softc;
 367         struct ccb_getdev *cgd;
 368
 369         cgd = (struct ccb_getdev *)arg;
 370         if (periph == NULL) {
 371                 printf("pmpregister: periph was NULL!!\n");
 372                 return(CAM_REQ_CMP_ERR);
 373         }
 374
 375         if (cgd == NULL) {
 376                 printf("pmpregister: no getdev CCB, can't register device\n");
 377                 return(CAM_REQ_CMP_ERR);
 378         }
 379
 380         softc = (struct pmp_softc *)malloc(sizeof(*softc), M_DEVBUF,
 381             M_NOWAIT|M_ZERO);
 382
 383         if (softc == NULL) {
 384                 printf("pmpregister: Unable to probe new device. "
 385                        "Unable to allocate softc\n");
 386                 return(CAM_REQ_CMP_ERR);
 387         }
 388         periph->softc = softc;
 389
 390         softc->pm_pid = ((uint32_t *)&cgd->ident_data)[0];
 391         softc->pm_prv = ((uint32_t *)&cgd->ident_data)[1];
 392         TASK_INIT(&softc->sysctl_task, 0, pmpsysctlinit, periph);
 393
 394         xpt_announce_periph(periph, NULL);
 395
 396         /*
 397          * Add async callbacks for bus reset and
 398          * bus device reset calls.  I don't bother
 399          * checking if this fails as, in most cases,
 400          * the system will function just fine without
 401          * them and the only alternative would be to
 402          * not attach the device on failure.
 403          */
 404         xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
 405                 AC_SCSI_AEN, pmpasync, periph, periph->path);
 406
 407         /*
 408          * Take an exclusive refcount on the periph while pmpstart is called
 409          * to finish the probe.  The reference will be dropped in pmpdone at
 410          * the end of probe.
 411          */
 412         (void)cam_periph_acquire(periph);
 413         xpt_hold_boot();
 414         softc->state = PMP_STATE_PORTS;
 415         softc->events = PMP_EV_RESCAN;
 416         xpt_schedule(periph, CAM_PRIORITY_DEV);
 417
 418         return(CAM_REQ_CMP);
 419 }
 420
 421 static void
 422 pmpstart(struct cam_periph *periph, union ccb *start_ccb)
 423 {
 424         struct ccb_trans_settings cts;
 425         struct ccb_ataio *ataio;
 426         struct pmp_softc *softc;
 427         struct cam_path *dpath;
 428         int revision = 0;
 429
 430         softc = (struct pmp_softc *)periph->softc;
 431         ataio = &start_ccb->ataio;
 432
 433         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("pmpstart\n"));
 434
 435         if (softc->restart) {
 436                 softc->restart = 0;
 437                 softc->state = min(softc->state, PMP_STATE_PRECONFIG);
 438         }
 439         /* Fetch user wanted device speed. */
 440         if (softc->state == PMP_STATE_RESET ||
 441             softc->state == PMP_STATE_CONNECT) {
 442                 if (xpt_create_path(&dpath, periph,
 443                     xpt_path_path_id(periph->path),
 444                     softc->pm_step, 0) == CAM_REQ_CMP) {
 445                         bzero(&cts, sizeof(cts));
 446                         xpt_setup_ccb(&cts.ccb_h, dpath, CAM_PRIORITY_NONE);
 447                         cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 448                         cts.type = CTS_TYPE_USER_SETTINGS;
 449                         xpt_action((union ccb *)&cts);
 450                         if (cts.xport_specific.sata.valid & CTS_SATA_VALID_REVISION)
 451                                 revision = cts.xport_specific.sata.revision;
 452                         xpt_free_path(dpath);
 453                 }
 454         }
 455         switch (softc->state) {
 456         case PMP_STATE_PORTS:
 457                 cam_fill_ataio(ataio,
 458                       pmp_retry_count,
 459                       pmpdone,
 460                       /*flags*/CAM_DIR_NONE,
 461                       0,
 462                       /*data_ptr*/NULL,
 463                       /*dxfer_len*/0,
 464                       pmp_default_timeout * 1000);
 465                 ata_pm_read_cmd(ataio, 2, 15);
 466                 break;
 467         case PMP_STATE_PRECONFIG:
 468                 /* Get/update host SATA capabilities. */
 469                 bzero(&cts, sizeof(cts));
 470                 xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE);
 471                 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 472                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 473                 xpt_action((union ccb *)&cts);
 474                 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_CAPS)
 475                         softc->caps = cts.xport_specific.sata.caps;
 476                 cam_fill_ataio(ataio,
 477                       pmp_retry_count,
 478                       pmpdone,
 479                       /*flags*/CAM_DIR_NONE,
 480                       0,
 481                       /*data_ptr*/NULL,
 482                       /*dxfer_len*/0,
 483                       pmp_default_timeout * 1000);
 484                 ata_pm_write_cmd(ataio, 0x60, 15, 0x0);
 485                 break;
 486         case PMP_STATE_RESET:
 487                 cam_fill_ataio(ataio,
 488                       pmp_retry_count,
 489                       pmpdone,
 490                       /*flags*/CAM_DIR_NONE,
 491                       0,
 492                       /*data_ptr*/NULL,
 493                       /*dxfer_len*/0,
 494                       pmp_default_timeout * 1000);
 495                 ata_pm_write_cmd(ataio, 2, softc->pm_step,
 496                     (revision << 4) |
 497                     ((softc->found & (1 << softc->pm_step)) ? 0 : 1));
 498                 break;
 499         case PMP_STATE_CONNECT:
 500                 cam_fill_ataio(ataio,
 501                       pmp_retry_count,
 502                       pmpdone,
 503                       /*flags*/CAM_DIR_NONE,
 504                       0,
 505                       /*data_ptr*/NULL,
 506                       /*dxfer_len*/0,
 507                       pmp_default_timeout * 1000);
 508                 ata_pm_write_cmd(ataio, 2, softc->pm_step,
 509                     (revision << 4));
 510                 break;
 511         case PMP_STATE_CHECK:
 512                 cam_fill_ataio(ataio,
 513                       pmp_retry_count,
 514                       pmpdone,
 515                       /*flags*/CAM_DIR_NONE,
 516                       0,
 517                       /*data_ptr*/NULL,
 518                       /*dxfer_len*/0,
 519                       pmp_default_timeout * 1000);
 520                 ata_pm_read_cmd(ataio, 0, softc->pm_step);
 521                 break;
 522         case PMP_STATE_CLEAR:
 523                 softc->reset = 0;
 524                 cam_fill_ataio(ataio,
 525                       pmp_retry_count,
 526                       pmpdone,
 527                       /*flags*/CAM_DIR_NONE,
 528                       0,
 529                       /*data_ptr*/NULL,
 530                       /*dxfer_len*/0,
 531                       pmp_default_timeout * 1000);
 532                 ata_pm_write_cmd(ataio, 1, softc->pm_step, 0xFFFFFFFF);
 533                 break;
 534         case PMP_STATE_CONFIG:
 535                 cam_fill_ataio(ataio,
 536                       pmp_retry_count,
 537                       pmpdone,
 538                       /*flags*/CAM_DIR_NONE,
 539                       0,
 540                       /*data_ptr*/NULL,
 541                       /*dxfer_len*/0,
 542                       pmp_default_timeout * 1000);
 543                 ata_pm_write_cmd(ataio, 0x60, 15, 0x07 |
 544                     ((softc->caps & CTS_SATA_CAPS_H_AN) ? 0x08 : 0));
 545                 break;
 546         default:
 547                 break;
 548         }
 549         xpt_action(start_ccb);
 550 }
 551
 552 static void
 553 pmpdone(struct cam_periph *periph, union ccb *done_ccb)
 554 {
 555         struct ccb_trans_settings cts;
 556         struct pmp_softc *softc;
 557         struct ccb_ataio *ataio;
 558         struct cam_path *dpath;
 559         u_int32_t  priority, res;
 560         int i;
 561
 562         softc = (struct pmp_softc *)periph->softc;
 563         ataio = &done_ccb->ataio;
 564
 565         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("pmpdone\n"));
 566
 567         priority = done_ccb->ccb_h.pinfo.priority;
 568
 569         if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 570                 if (cam_periph_error(done_ccb, 0, 0, NULL) == ERESTART) {
 571                         return;
 572                 } else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
 573                         cam_release_devq(done_ccb->ccb_h.path,
 574                             /*relsim_flags*/0,
 575                             /*reduction*/0,
 576                             /*timeout*/0,
 577                             /*getcount_only*/0);
 578                 }
 579                 goto done;
 580         }
 581
 582         if (softc->restart) {
 583                 softc->restart = 0;
 584                 xpt_release_ccb(done_ccb);
 585                 softc->state = min(softc->state, PMP_STATE_PRECONFIG);
 586                 xpt_schedule(periph, priority);
 587                 return;
 588         }
 589
 590         switch (softc->state) {
 591         case PMP_STATE_PORTS:
 592                 softc->pm_ports = (ataio->res.lba_high << 24) +
 593                     (ataio->res.lba_mid << 16) +
 594                     (ataio->res.lba_low << 8) +
 595                     ataio->res.sector_count;
 596                 if (pmp_hide_special) {
 597                         /*
 598                          * This PMP declares 6 ports, while only 5 of them
 599                          * are real. Port 5 is a SEMB port, probing which
 600                          * causes timeouts if external SEP is not connected
 601                          * to PMP over I2C.
 602                          */
 603                         if (softc->pm_pid == 0x37261095 && softc->pm_ports == 6)
 604                                 softc->pm_ports = 5;
 605
 606                         /*
 607                          * This PMP declares 7 ports, while only 5 of them
 608                          * are real. Port 5 is a fake "Config  Disk" with
 609                          * 640 sectors size. Port 6 is a SEMB port.
 610                          */
 611                         if (softc->pm_pid == 0x47261095 && softc->pm_ports == 7)
 612                                 softc->pm_ports = 5;
 613
 614                         /*
 615                          * These PMPs have extra configuration port.
 616                          */
 617                         if (softc->pm_pid == 0x57231095 ||
 618                             softc->pm_pid == 0x57331095 ||
 619                             softc->pm_pid == 0x57341095 ||
 620                             softc->pm_pid == 0x57441095)
 621                                 softc->pm_ports--;
 622                 }
 623                 printf("%s%d: %d fan-out ports\n",
 624                     periph->periph_name, periph->unit_number,
 625                     softc->pm_ports);
 626                 softc->state = PMP_STATE_PRECONFIG;
 627                 xpt_release_ccb(done_ccb);
 628                 xpt_schedule(periph, priority);
 629                 return;
 630         case PMP_STATE_PRECONFIG:
 631                 softc->pm_step = 0;
 632                 softc->state = PMP_STATE_RESET;
 633                 softc->reset |= ~softc->found;
 634                 xpt_release_ccb(done_ccb);
 635                 xpt_schedule(periph, priority);
 636                 return;
 637         case PMP_STATE_RESET:
 638                 softc->pm_step++;
 639                 if (softc->pm_step >= softc->pm_ports) {
 640                         softc->pm_step = 0;
 641                         cam_freeze_devq(periph->path);
 642                         cam_release_devq(periph->path,
 643                             RELSIM_RELEASE_AFTER_TIMEOUT,
 644                             /*reduction*/0,
 645                             /*timeout*/5,
 646                             /*getcount_only*/0);
 647                         softc->state = PMP_STATE_CONNECT;
 648                 }
 649                 xpt_release_ccb(done_ccb);
 650                 xpt_schedule(periph, priority);
 651                 return;
 652         case PMP_STATE_CONNECT:
 653                 softc->pm_step++;
 654                 if (softc->pm_step >= softc->pm_ports) {
 655                         softc->pm_step = 0;
 656                         softc->pm_try = 0;
 657                         cam_freeze_devq(periph->path);
 658                         cam_release_devq(periph->path,
 659                             RELSIM_RELEASE_AFTER_TIMEOUT,
 660                             /*reduction*/0,
 661                             /*timeout*/10,
 662                             /*getcount_only*/0);
 663                         softc->state = PMP_STATE_CHECK;
 664                 }
 665                 xpt_release_ccb(done_ccb);
 666                 xpt_schedule(periph, priority);
 667                 return;
 668         case PMP_STATE_CHECK:
 669                 res = (ataio->res.lba_high << 24) +
 670                     (ataio->res.lba_mid << 16) +
 671                     (ataio->res.lba_low << 8) +
 672                     ataio->res.sector_count;
 673                 if (((res & 0xf0f) == 0x103 && (res & 0x0f0) != 0) ||
 674                     (res & 0x600) != 0) {
 675                         if (bootverbose) {
 676                                 printf("%s%d: port %d status: %08x\n",
 677                                     periph->periph_name, periph->unit_number,
 678                                     softc->pm_step, res);
 679                         }
 680                         /* Report device speed if it is online. */
 681                         if ((res & 0xf0f) == 0x103 &&
 682                             xpt_create_path(&dpath, periph,
 683                             xpt_path_path_id(periph->path),
 684                             softc->pm_step, 0) == CAM_REQ_CMP) {
 685                                 bzero(&cts, sizeof(cts));
 686                                 xpt_setup_ccb(&cts.ccb_h, dpath, CAM_PRIORITY_NONE);
 687                                 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
 688                                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 689                                 cts.xport_specific.sata.revision = (res & 0x0f0) >> 4;
 690                                 cts.xport_specific.sata.valid = CTS_SATA_VALID_REVISION;
 691                                 cts.xport_specific.sata.caps = softc->caps &
 692                                     (CTS_SATA_CAPS_H_PMREQ |
 693                                      CTS_SATA_CAPS_H_DMAAA |
 694                                      CTS_SATA_CAPS_H_AN);
 695                                 cts.xport_specific.sata.valid |= CTS_SATA_VALID_CAPS;
 696                                 xpt_action((union ccb *)&cts);
 697                                 xpt_free_path(dpath);
 698                         }
 699                         softc->found |= (1 << softc->pm_step);
 700                         softc->pm_step++;
 701                 } else {
 702                         if (softc->pm_try < 10) {
 703                                 cam_freeze_devq(periph->path);
 704                                 cam_release_devq(periph->path,
 705                                     RELSIM_RELEASE_AFTER_TIMEOUT,
 706                                     /*reduction*/0,
 707                                     /*timeout*/10,
 708                                     /*getcount_only*/0);
 709                                 softc->pm_try++;
 710                         } else {
 711                                 if (bootverbose) {
 712                                         printf("%s%d: port %d status: %08x\n",
 713                                             periph->periph_name, periph->unit_number,
 714                                             softc->pm_step, res);
 715                                 }
 716                                 softc->found &= ~(1 << softc->pm_step);
 717                                 if (xpt_create_path(&dpath, periph,
 718                                     done_ccb->ccb_h.path_id,
 719                                     softc->pm_step, 0) == CAM_REQ_CMP) {
 720                                         xpt_async(AC_LOST_DEVICE, dpath, NULL);
 721                                         xpt_free_path(dpath);
 722                                 }
 723                                 softc->pm_step++;
 724                         }
 725                 }
 726                 if (softc->pm_step >= softc->pm_ports) {
 727                         if (softc->reset & softc->found) {
 728                                 cam_freeze_devq(periph->path);
 729                                 cam_release_devq(periph->path,
 730                                     RELSIM_RELEASE_AFTER_TIMEOUT,
 731                                     /*reduction*/0,
 732                                     /*timeout*/1000,
 733                                     /*getcount_only*/0);
 734                         }
 735                         softc->state = PMP_STATE_CLEAR;
 736                         softc->pm_step = 0;
 737                 }
 738                 xpt_release_ccb(done_ccb);
 739                 xpt_schedule(periph, priority);
 740                 return;
 741         case PMP_STATE_CLEAR:
 742                 softc->pm_step++;
 743                 if (softc->pm_step >= softc->pm_ports) {
 744                         softc->state = PMP_STATE_CONFIG;
 745                         softc->pm_step = 0;
 746                 }
 747                 xpt_release_ccb(done_ccb);
 748                 xpt_schedule(periph, priority);
 749                 return;
 750         case PMP_STATE_CONFIG:
 751                 for (i = 0; i < softc->pm_ports; i++) {
 752                         union ccb *ccb;
 753
 754                         if ((softc->found & (1 << i)) == 0)
 755                                 continue;
 756                         if (xpt_create_path(&dpath, periph,
 757                             xpt_path_path_id(periph->path),
 758                             i, 0) != CAM_REQ_CMP) {
 759                                 printf("pmpdone: xpt_create_path failed\n");
 760                                 continue;
 761                         }
 762                         /* If we did hard reset to this device, inform XPT. */
 763                         if ((softc->reset & softc->found & (1 << i)) != 0)
 764                                 xpt_async(AC_SENT_BDR, dpath, NULL);
 765                         /* If rescan requested, scan this device. */
 766                         if (softc->events & PMP_EV_RESCAN) {
 767                                 ccb = xpt_alloc_ccb_nowait();
 768                                 if (ccb == NULL) {
 769                                         xpt_free_path(dpath);
 770                                         goto done;
 771                                 }
 772                                 xpt_setup_ccb(&ccb->ccb_h, dpath, CAM_PRIORITY_XPT);
 773                                 xpt_rescan(ccb);
 774                         } else
 775                                 xpt_free_path(dpath);
 776                 }
 777                 break;
 778         default:
 779                 break;
 780         }
 781 done:
 782         xpt_release_ccb(done_ccb);
 783         softc->state = PMP_STATE_NORMAL;
 784         softc->events = 0;
 785         xpt_release_boot();
 786         pmprelease(periph, -1);
 787         cam_periph_release_locked(periph);
 788 }
 789
 790 #endif /* _KERNEL */