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