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