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