1 /* 2 * (MPSAFE) 3 * 4 * Copyright (c) 2009 The DragonFly Project. All rights reserved. 5 * 6 * This code is derived from software contributed to The DragonFly Project 7 * by Matthew Dillon <dillon@backplane.com> 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in 17 * the documentation and/or other materials provided with the 18 * distribution. 19 * 3. Neither the name of The DragonFly Project nor the names of its 20 * contributors may be used to endorse or promote products derived 21 * from this software without specific, prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 26 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 27 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 28 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 29 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 31 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 33 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37 #include "ahci.h" 38 39 static void ahci_pm_dummy_done(struct ata_xfer *xa); 40 41 int 42 ahci_pm_port_init(struct ahci_port *ap, struct ata_port *at) 43 { 44 at->at_probe = ATA_PROBE_NEED_HARD_RESET; 45 return (0); 46 } 47 48 /* 49 * AHCI port multiplier probe. This routine is run by the hardreset code 50 * if it gets past the device detect, whether or not BSY is found to be 51 * stuck. 52 * 53 * We MUST use CLO to properly probe whether the port multiplier exists 54 * or not. 55 * 56 * Return 0 on success, non-zero on failure. 57 */ 58 int 59 ahci_pm_port_probe(struct ahci_port *ap, int orig_error) 60 { 61 struct ahci_cmd_hdr *cmd_slot; 62 struct ata_port *at; 63 struct ahci_ccb *ccb = NULL; 64 u_int8_t *fis = NULL; 65 int error; 66 u_int32_t cmd; 67 u_int32_t fbs; 68 int count; 69 int rstcount; 70 int i; 71 int fbsmode; 72 int sig; 73 74 count = 2; 75 rstcount = 2; 76 retry: 77 fbsmode = 0; 78 79 /* 80 * This code is only called from hardreset, which does not 81 * high level command processing. The port should be stopped. 82 * 83 * Set PMA mode while the port is stopped. 84 * 85 * NOTE: On retry the port might be running, stopped, or failed. 86 */ 87 ahci_port_stop(ap, 0); 88 ap->ap_state = AP_S_NORMAL; 89 cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC; 90 #if 1 91 if ((cmd & AHCI_PREG_CMD_PMA) == 0) { 92 cmd |= AHCI_PREG_CMD_PMA; 93 ahci_pwrite(ap, AHCI_PREG_CMD, cmd); 94 } 95 #endif 96 97 /* 98 * Check to see if FBS is supported by checking the cap and the 99 * support bit in the port CMD register. If it looks good, try 100 * to write to the FBS register. 101 */ 102 if (ap->ap_sc->sc_cap & AHCI_REG_CAP_FBSS) { 103 const char *str1 = ""; 104 const char *str2 = ""; 105 const char *str3 = ""; 106 107 if (cmd & AHCI_PREG_CMD_FBSCP) { 108 str1 = "HW indicates support"; 109 } else if (ap->ap_sc->sc_flags & AHCI_F_FORCE_FBSS) { 110 cmd |= AHCI_PREG_CMD_FBSCP; /* Force on */ 111 str1 = "HW indicates no-support, force"; 112 } else { 113 str1 = "HW indicates no-support"; 114 } 115 if (cmd & AHCI_PREG_CMD_FBSCP) { 116 fbs = ahci_pread(ap, AHCI_PREG_FBS); 117 ahci_pwrite(ap, AHCI_PREG_FBS, fbs | AHCI_PREG_FBS_EN); 118 fbs = ahci_pread(ap, AHCI_PREG_FBS); 119 if (fbs & AHCI_PREG_FBS_EN) { 120 str2 = ", enable succeeded"; 121 fbsmode = 1; 122 } else { 123 str2 = ", enable failed"; 124 } 125 126 /* 127 * Must be off during the PM probe, we will enable 128 * it at the end. 129 */ 130 ahci_pwrite(ap, AHCI_PREG_FBS, fbs & ~AHCI_PREG_FBS_EN); 131 } 132 kprintf("%s: FBS Cap detected: %s%s%s\n", 133 PORTNAME(ap), str1, str2, str3); 134 } 135 136 /* 137 * If the probe fails, cleanup any previous state. 138 */ 139 if (fbsmode == 0 && (ap->ap_flags & AP_F_FBSS_ENABLED)) { 140 ap->ap_flags &= ~AP_F_FBSS_ENABLED; 141 ahci_pwrite(ap, AHCI_PREG_FBS, 0); 142 } 143 144 /* 145 * Flush any errors and request CLO unconditionally, then start 146 * the port. 147 */ 148 ahci_flush_tfd(ap); 149 ahci_port_clo(ap); 150 if (ahci_port_start(ap)) { 151 kprintf("%s: PMPROBE cannot start port\n", 152 PORTNAME(ap)); 153 error = EIO; 154 goto err; 155 } 156 157 /* 158 * When a PM is present and the cable or driver cycles, the PM may 159 * hang in BSY and require another COMRESET sequence to clean it up. 160 * The CLO above didn't work (for example, if there is no CLO 161 * support), so do another hard COMRESET to try to clear the busy 162 * condition. 163 */ 164 if (ahci_pwait_clr(ap, AHCI_PREG_TFD, 165 AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) { 166 if (--rstcount) { 167 int pmdetect; 168 169 kprintf("%s: PMPROBE BUSY, comreset and retry\n", 170 PORTNAME(ap)); 171 ahci_comreset(ap, &pmdetect); 172 if (pmdetect) 173 goto retry; 174 } 175 kprintf("%s: PMPROBE BUSY, giving up\n", 176 PORTNAME(ap)); 177 error = EBUSY; 178 goto err; 179 } 180 181 /* 182 * Use the error CCB for all commands 183 * 184 * NOTE! This CCB is used for both the first and second commands. 185 * The second command must use CCB slot 1 to properly load 186 * the signature. 187 */ 188 ccb = ahci_get_err_ccb(ap); 189 ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_SILENT; 190 ccb->ccb_xa.complete = ahci_pm_dummy_done; 191 ccb->ccb_xa.at = ap->ap_ata[15]; 192 cmd_slot = ccb->ccb_cmd_hdr; 193 KKASSERT(ccb->ccb_slot == 1); 194 195 /* 196 * Prep the first H2D command with SRST feature & clear busy/reset 197 * flags. 198 */ 199 fis = ccb->ccb_cmd_table->cfis; 200 bzero(fis, sizeof(ccb->ccb_cmd_table->cfis)); 201 fis[0] = ATA_FIS_TYPE_H2D; 202 fis[1] = 0x0F; /* Target 15 */ 203 fis[15] = ATA_FIS_CONTROL_SRST | ATA_FIS_CONTROL_4BIT; 204 205 cmd_slot->prdtl = 0; 206 cmd_slot->flags = htole16(5); /* FIS length: 5 DWORDS */ 207 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_C); /* Clear busy on OK */ 208 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_R); /* Reset */ 209 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_PMP); /* port 0xF */ 210 211 ccb->ccb_xa.state = ATA_S_PENDING; 212 213 if (bootverbose) { 214 kprintf("%s: PMPROBE PreStatus 0x%pb%i\n", PORTNAME(ap), 215 AHCI_PFMT_TFD_STS, ahci_pread(ap, AHCI_PREG_TFD)); 216 } 217 218 /* 219 * The only way one can determine if a port multiplier is on the 220 * port is to probe target 15, and of course this will fail if 221 * there is no port multiplier. 222 * 223 * The probing has to be done whether or not a device is probed on 224 * target 0, because when a PM is attached target 0 represents 225 * slot #0 behind the PM. 226 * 227 * Port multipliers are expected to answer more quickly than normal 228 * devices, use a shorter timeout than normal. 229 * 230 * If there is no PM here this command can still succeed due to 231 * the _C_ 232 */ 233 if (ahci_poll(ccb, 1000, ahci_quick_timeout) != ATA_S_COMPLETE) { 234 kprintf("%s: PMPROBE(1) No Port Multiplier was found.\n", 235 PORTNAME(ap)); 236 if (--count) { 237 rstcount = 2; 238 ahci_put_err_ccb(ccb); 239 goto retry; 240 } 241 error = EBUSY; 242 goto err; 243 } 244 245 if (bootverbose) { 246 kprintf("%s: PMPROBE PosStatus 0x%pb%i\n", PORTNAME(ap), 247 AHCI_PFMT_TFD_STS, ahci_pread(ap, AHCI_PREG_TFD)); 248 } 249 #if 0 250 /* 251 * REMOVED - Ignore a BSY condition between the first and second 252 * FIS in the PM probe. Seems to work better. 253 */ 254 if (ahci_pwait_clr(ap, AHCI_PREG_TFD, 255 AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) { 256 kprintf("%s: PMPROBE Busy after first FIS\n", PORTNAME(ap)); 257 } else if (bootverbose) { 258 kprintf("%s: PMPROBE Clean after first FIS\n", PORTNAME(ap)); 259 } 260 #endif 261 262 /* 263 * The device may have muffed up the PHY when it reset. 264 */ 265 ahci_flush_tfd(ap); 266 ahci_pwrite(ap, AHCI_PREG_SERR, -1); 267 /* ahci_pm_phy_status(ap, 15, &cmd); */ 268 269 /* 270 * Prep second D2H command to read status and complete reset sequence 271 * AHCI 10.4.1 and "Serial ATA Revision 2.6". I can't find the ATA 272 * Rev 2.6 and it is unclear how the second FIS should be set up 273 * from the AHCI document. 274 * 275 * Give the device 3ms before sending the second FIS. 276 * 277 * It is unclear which other fields in the FIS are used. Just zero 278 * everything. 279 */ 280 ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_SILENT; 281 282 bzero(fis, sizeof(ccb->ccb_cmd_table->cfis)); 283 fis[0] = ATA_FIS_TYPE_H2D; 284 fis[1] = 0x0F; 285 fis[15] = ATA_FIS_CONTROL_4BIT; 286 287 cmd_slot->prdtl = 0; 288 cmd_slot->flags = htole16(5); /* FIS length: 5 DWORDS */ 289 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_PMP); /* port 0xF */ 290 291 ccb->ccb_xa.state = ATA_S_PENDING; 292 293 /* 294 * The only way one can determine if a port multiplier is on the 295 * port is to probe target 15, and of course this will fail if 296 * there is no port multiplier. 297 * 298 * The probing has to be done whether or not a device is probed on 299 * target 0, because when a PM is attached target 0 represents 300 * slot #0 behind the PM. 301 */ 302 if (ahci_poll(ccb, 5000, ahci_quick_timeout) != ATA_S_COMPLETE) { 303 kprintf("%s: PMPROBE(2) No Port Multiplier was found.\n", 304 PORTNAME(ap)); 305 if (--count) { 306 rstcount = 2; 307 ahci_put_err_ccb(ccb); 308 goto retry; 309 } 310 error = EBUSY; 311 goto err; 312 } 313 314 /* 315 * Some controllers return completion for the second FIS before 316 * updating the signature register. Sleep a bit to allow for it. 317 */ 318 ahci_os_sleep(500); 319 320 /* 321 * What? We succeeded? Yup, but for some reason the signature 322 * is still latched from the original detect (that saw target 0 323 * behind the PM), and I don't know how to clear the condition 324 * other then by retrying the whole reset sequence. 325 */ 326 sig = ahci_port_signature_detect(ap, NULL); 327 if (sig == ATA_PORT_T_PM) { 328 kprintf("%s: PMPROBE PM Signature detected\n", 329 PORTNAME(ap)); 330 ap->ap_ata[15]->at_probe = ATA_PROBE_GOOD; 331 error = 0; 332 } else if (--count == 0) { 333 kprintf("%s: PMPROBE PM Signature not detected\n", 334 PORTNAME(ap)); 335 error = EBUSY; 336 } else { 337 rstcount = 2; 338 fis[15] = 0; 339 ahci_put_err_ccb(ccb); 340 if (bootverbose) { 341 kprintf("%s: PMPROBE retry on count\n", 342 PORTNAME(ap)); 343 } 344 goto retry; 345 } 346 347 /* 348 * Fall through / clean up the CCB and perform error processing. 349 */ 350 err: 351 if (ccb != NULL) 352 ahci_put_err_ccb(ccb); 353 354 if (error == 0 && ahci_pm_identify(ap)) { 355 ahci_os_sleep(500); 356 if (ahci_pm_identify(ap)) { 357 kprintf("%s: PM - cannot identify port multiplier\n", 358 PORTNAME(ap)); 359 error = EBUSY; 360 } else { 361 kprintf("%s: PM - Had to identify twice\n", 362 PORTNAME(ap)); 363 } 364 } 365 366 /* 367 * Turn on FBS mode, clear any stale error. Enforce a 1/10 second 368 * delay primarily for the IGN_CR quirk. 369 */ 370 if (error == 0 && fbsmode) { 371 ahci_port_stop(ap, 0); 372 ap->ap_flags |= AP_F_FBSS_ENABLED; 373 fbs = ahci_pread(ap, AHCI_PREG_FBS); 374 fbs &= ~AHCI_PREG_FBS_DEV; 375 fbs |= AHCI_PREG_FBS_DEC; 376 ahci_pwrite(ap, AHCI_PREG_FBS, fbs | AHCI_PREG_FBS_EN); 377 ahci_os_sleep(100); 378 if (ahci_port_start(ap)) { 379 kprintf("%s: PMPROBE failed to restart port " 380 "after FBS enable\n", 381 PORTNAME(ap)); 382 ahci_pwrite(ap, AHCI_PREG_FBS, fbs & ~AHCI_PREG_FBS_EN); 383 ap->ap_flags &= ~AP_F_FBSS_ENABLED; 384 } 385 } 386 387 388 /* 389 * If we probed the PM reset the state for the targets behind 390 * it so they get probed by the state machine. 391 */ 392 if (error == 0) { 393 for (i = 0; i < AHCI_MAX_PMPORTS; ++i) { 394 at = ap->ap_ata[i]; 395 at->at_probe = ATA_PROBE_NEED_INIT; 396 at->at_features |= ATA_PORT_F_RESCAN; 397 } 398 ap->ap_type = ATA_PORT_T_PM; 399 return (0); 400 } 401 402 /* 403 * If we failed turn off PMA, otherwise identify the port multiplier. 404 * CAM will iterate the devices. 405 */ 406 ahci_port_stop(ap, 0); 407 ahci_port_clo(ap); 408 #if 1 409 cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC; 410 cmd &= ~AHCI_PREG_CMD_PMA; 411 ahci_pwrite(ap, AHCI_PREG_CMD, cmd); 412 #endif 413 if (orig_error == 0) { 414 if (ahci_pwait_clr(ap, AHCI_PREG_TFD, 415 AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) { 416 kprintf("%s: PM probe: port will not come ready\n", 417 PORTNAME(ap)); 418 orig_error = EBUSY; 419 ahci_port_init(ap); 420 } 421 } 422 return(orig_error); 423 } 424 425 /* 426 * Identify the port multiplier 427 */ 428 int 429 ahci_pm_identify(struct ahci_port *ap) 430 { 431 u_int32_t chipid; 432 u_int32_t rev; 433 u_int32_t nports; 434 u_int32_t data1; 435 u_int32_t data2; 436 int has_dummy_port; 437 438 ap->ap_probe = ATA_PROBE_FAILED; 439 if (ahci_pm_read(ap, 15, 0, &chipid)) 440 goto err; 441 if (ahci_pm_read(ap, 15, 1, &rev)) 442 goto err; 443 if (ahci_pm_read(ap, 15, 2, &nports)) 444 goto err; 445 nports &= 0x0000000F; /* only the low 4 bits */ 446 ap->ap_probe = ATA_PROBE_GOOD; 447 448 if ((rev & SATA_PMREV_MASK) == 0) { 449 if (bootverbose) 450 kprintf("%s: PM identify register empty!\n", 451 PORTNAME(ap)); 452 return EIO; 453 } 454 455 /* 456 * Ignore fake port on PMs which have it. We can probe it but the 457 * softreset will probably fail. 458 */ 459 switch(chipid) { 460 case 0x37261095: 461 has_dummy_port = 1; 462 break; 463 default: 464 has_dummy_port = 0; 465 break; 466 } 467 if (has_dummy_port) { 468 if (nports > 1) 469 --nports; 470 } 471 472 kprintf("%s: Port multiplier: chip=%08x rev=0x%pb%i nports=%d\n", 473 PORTNAME(ap), chipid, SATA_PFMT_PM_REV, rev, nports); 474 if (has_dummy_port) { 475 kprintf("%s: Port multiplier: Ignoring dummy port #%d\n", 476 PORTNAME(ap), nports); 477 } 478 ap->ap_pmcount = nports; 479 480 if (ahci_pm_read(ap, 15, SATA_PMREG_FEA, &data1)) { 481 kprintf("%s: Port multiplier: Warning, " 482 "cannot read feature register\n", PORTNAME(ap)); 483 } else { 484 kprintf("%s: Port multiplier features: 0x%pb%i\n", 485 PORTNAME(ap), SATA_PFMT_PM_FEA, data1); 486 } 487 if (ahci_pm_read(ap, 15, SATA_PMREG_FEAEN, &data2) == 0) { 488 kprintf("%s: Port multiplier defaults: 0x%pb%i\n", 489 PORTNAME(ap), SATA_PFMT_PM_FEA, data2); 490 } 491 492 /* 493 * Turn on async notification if we support and the PM supports it. 494 * This allows the PM to forward async notification events to us and 495 * it will also generate an event for target 15 for hot-plug events 496 * (or is supposed to anyway). 497 */ 498 if ((ap->ap_sc->sc_cap & AHCI_REG_CAP_SSNTF) && 499 (data1 & SATA_PMFEA_ASYNCNOTIFY)) { 500 u_int32_t serr_bits = AHCI_PREG_SERR_DIAG_N | 501 AHCI_PREG_SERR_DIAG_X; 502 data2 |= SATA_PMFEA_ASYNCNOTIFY; 503 if (ahci_pm_write(ap, 15, SATA_PMREG_FEAEN, data2)) { 504 kprintf("%s: Port multiplier: AsyncNotify cannot be " 505 "enabled\n", PORTNAME(ap)); 506 } else if (ahci_pm_write(ap, 15, SATA_PMREG_EEENA, serr_bits)) { 507 kprintf("%s: Port mulltiplier: AsyncNotify unable " 508 "to enable error info bits\n", PORTNAME(ap)); 509 } else { 510 kprintf("%s: Port multiplier: AsyncNotify enabled\n", 511 PORTNAME(ap)); 512 } 513 } 514 515 return (0); 516 err: 517 kprintf("%s: Port multiplier cannot be identified\n", PORTNAME(ap)); 518 return (EIO); 519 } 520 521 /* 522 * Do a COMRESET sequence on the target behind a port multiplier. 523 * 524 * If hard is 2 we also cycle the phy on the target. 525 * 526 * This must be done prior to any softreset or probe attempts on 527 * targets behind the port multiplier. 528 * 529 * Returns 0 on success or an error. 530 */ 531 int 532 ahci_pm_hardreset(struct ahci_port *ap, int target, int hard) 533 { 534 struct ata_port *at; 535 u_int32_t data; 536 int loop; 537 int error = EIO; 538 539 at = ap->ap_ata[target]; 540 541 /* 542 * Turn off power management and kill the phy on the target 543 * if requested. Hold state for 10ms. 544 */ 545 data = ap->ap_sc->sc_ipm_disable; 546 if (hard == 2) 547 data |= AHCI_PREG_SCTL_DET_DISABLE; 548 if (ahci_pm_write(ap, target, SATA_PMREG_SERR, -1)) 549 goto err; 550 if (ahci_pm_write(ap, target, SATA_PMREG_SCTL, data)) 551 goto err; 552 ahci_os_sleep(10); 553 554 /* 555 * Start transmitting COMRESET. COMRESET must be sent for at 556 * least 1ms. 557 */ 558 at->at_probe = ATA_PROBE_FAILED; 559 at->at_type = ATA_PORT_T_NONE; 560 data = ap->ap_sc->sc_ipm_disable | AHCI_PREG_SCTL_DET_INIT; 561 switch(AhciForceGen) { 562 case 0: 563 data |= AHCI_PREG_SCTL_SPD_ANY; 564 break; 565 case 1: 566 data |= AHCI_PREG_SCTL_SPD_GEN1; 567 break; 568 case 2: 569 data |= AHCI_PREG_SCTL_SPD_GEN2; 570 break; 571 case 3: 572 data |= AHCI_PREG_SCTL_SPD_GEN3; 573 break; 574 default: 575 data |= AHCI_PREG_SCTL_SPD_GEN3; 576 break; 577 } 578 if (ahci_pm_write(ap, target, SATA_PMREG_SCTL, data)) 579 goto err; 580 581 /* 582 * It takes about 100ms for the DET logic to settle down, 583 * from trial and error testing. If this is too short 584 * the softreset code will fail. 585 */ 586 ahci_os_sleep(100); 587 588 if (ahci_pm_phy_status(ap, target, &data)) { 589 kprintf("%s: (A)Cannot clear phy status\n", 590 ATANAME(ap ,at)); 591 } 592 593 /* 594 * Flush any status, then clear DET to initiate negotiation. 595 */ 596 ahci_pm_write(ap, target, SATA_PMREG_SERR, -1); 597 data = ap->ap_sc->sc_ipm_disable | AHCI_PREG_SCTL_DET_NONE; 598 if (ahci_pm_write(ap, target, SATA_PMREG_SCTL, data)) 599 goto err; 600 601 /* 602 * Try to determine if there is a device on the port. This 603 * operation usually runs sequentially on the PM, use a short 604 * 3/10 second timeout. The disks should already be sufficiently 605 * powered. 606 * 607 * If we fail clear any pending status since we may have 608 * cycled the phy and probably caused another PRCS interrupt. 609 */ 610 for (loop = 3; loop; --loop) { 611 if (ahci_pm_read(ap, target, SATA_PMREG_SSTS, &data)) 612 goto err; 613 if (data & AHCI_PREG_SSTS_DET) 614 break; 615 ahci_os_sleep(100); 616 } 617 if (loop == 0) { 618 kprintf("%s.%d: Port appears to be unplugged\n", 619 PORTNAME(ap), target); 620 error = ENODEV; 621 goto err; 622 } 623 624 /* 625 * There is something on the port. Give the device 3 seconds 626 * to fully negotiate. 627 */ 628 for (loop = 30; loop; --loop) { 629 if (ahci_pm_read(ap, target, SATA_PMREG_SSTS, &data)) 630 goto err; 631 if ((data & AHCI_PREG_SSTS_DET) == AHCI_PREG_SSTS_DET_DEV) 632 break; 633 ahci_os_sleep(100); 634 } 635 636 /* 637 * Device not detected 638 */ 639 if (loop == 0) { 640 kprintf("%s: Device may be powered down\n", 641 PORTNAME(ap)); 642 error = ENODEV; 643 goto err; 644 } 645 646 /* 647 * Device detected 648 */ 649 kprintf("%s.%d: Device detected data=%08x\n", 650 PORTNAME(ap), target, data); 651 /* 652 * Clear SERR on the target so we get a new NOTIFY event if a hot-plug 653 * or hot-unplug occurs. Clear any spurious IFS that may have 654 * occured during the probe. 655 * 656 * WARNING! 100ms seems to work in most cases but 657 */ 658 ahci_os_sleep(100); 659 ahci_pm_write(ap, target, SATA_PMREG_SERR, -1); 660 ahci_pwrite(ap, AHCI_PREG_SERR, -1); 661 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS); 662 663 error = 0; 664 err: 665 at->at_probe = error ? ATA_PROBE_FAILED : ATA_PROBE_NEED_SOFT_RESET; 666 return (error); 667 } 668 669 /* 670 * AHCI soft reset through port multiplier. 671 * 672 * This function keeps port communications intact and attempts to generate 673 * a reset to the connected device using device commands. Unlike 674 * hard-port operations we can't do fancy stop/starts or stuff like 675 * that without messing up other commands that might be running or 676 * queued. 677 */ 678 int 679 ahci_pm_softreset(struct ahci_port *ap, int target) 680 { 681 struct ata_port *at; 682 struct ahci_ccb *ccb; 683 struct ahci_cmd_hdr *cmd_slot; 684 u_int8_t *fis; 685 int count; 686 int error; 687 u_int32_t data; 688 689 error = EIO; 690 at = ap->ap_ata[target]; 691 692 DPRINTF(AHCI_D_VERBOSE, "%s: soft reset\n", PORTNAME(ap)); 693 694 count = 2; 695 retry: 696 /* 697 * Try to clear the phy so we get a good signature, otherwise 698 * the PM may not latch a new signature. 699 * 700 * NOTE: This cannot be safely done between the first and second 701 * softreset FISs. It's now or never. 702 */ 703 if (ahci_pm_phy_status(ap, target, &data)) { 704 kprintf("%s: (B)Cannot clear phy status\n", 705 ATANAME(ap ,at)); 706 } 707 ahci_pm_write(ap, target, SATA_PMREG_SERR, -1); 708 709 /* 710 * Prep first D2H command with SRST feature & clear busy/reset flags 711 * 712 * It is unclear which other fields in the FIS are used. Just zero 713 * everything. 714 * 715 * When soft-resetting a port behind a multiplier at will be 716 * non-NULL, assigning it to the ccb prevents the port interrupt 717 * from hard-resetting the port if a problem crops up. 718 */ 719 ccb = ahci_get_err_ccb(ap); 720 ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_EXCLUSIVE | ATA_F_AUTOSENSE; 721 ccb->ccb_xa.complete = ahci_pm_dummy_done; 722 ccb->ccb_xa.at = at; 723 724 fis = ccb->ccb_cmd_table->cfis; 725 bzero(fis, sizeof(ccb->ccb_cmd_table->cfis)); 726 fis[0] = ATA_FIS_TYPE_H2D; 727 fis[1] = at->at_target; 728 fis[15] = ATA_FIS_CONTROL_SRST|ATA_FIS_CONTROL_4BIT; 729 730 cmd_slot = ccb->ccb_cmd_hdr; 731 cmd_slot->prdtl = 0; 732 cmd_slot->flags = htole16(5); /* FIS length: 5 DWORDS */ 733 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_C); /* Clear busy on OK */ 734 cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_R); /* Reset */ 735 cmd_slot->flags |= htole16(at->at_target << 736 AHCI_CMD_LIST_FLAG_PMP_SHIFT); 737 738 ccb->ccb_xa.state = ATA_S_PENDING; 739 740 /* 741 * This soft reset of the AP target can cause a stream of IFS 742 * errors to occur. Setting AP_F_IGNORE_IFS prevents the port 743 * from being hard reset (because its the target behind the 744 * port that isn't happy). 745 * 746 * The act of sending the soft reset can cause the target to 747 * blow the port up and generate IFS errors. 748 */ 749 ap->ap_flags |= AP_F_IGNORE_IFS; 750 ap->ap_flags &= ~AP_F_IFS_IGNORED; 751 752 if (ahci_poll(ccb, 1000, ahci_ata_cmd_timeout) != ATA_S_COMPLETE) { 753 kprintf("%s: Soft-reset through PM failed, %s\n", 754 ATANAME(ap, at), 755 (count > 1 ? "retrying" : "giving up")); 756 ahci_put_err_ccb(ccb); 757 if (--count) { 758 if (ap->ap_flags & AP_F_IFS_IGNORED) 759 ahci_os_sleep(5000); 760 else 761 ahci_os_sleep(1000); 762 ahci_pwrite(ap, AHCI_PREG_SERR, -1); 763 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS); 764 goto retry; 765 } 766 goto err; 767 } 768 769 /* 770 * WARNING! SENSITIVE TIME PERIOD! WARNING! 771 * 772 * The first and second FISes are supposed to be back-to-back, 773 * I think the idea is to get the second sent and then after 774 * the device resets it will send a signature. Do not delay 775 * here and most definitely do not issue any commands to other 776 * targets! 777 */ 778 779 /* 780 * Prep second D2H command to read status and complete reset sequence 781 * AHCI 10.4.1 and "Serial ATA Revision 2.6". I can't find the ATA 782 * Rev 2.6 and it is unclear how the second FIS should be set up 783 * from the AHCI document. 784 * 785 * Give the device 3ms before sending the second FIS. 786 * 787 * It is unclear which other fields in the FIS are used. Just zero 788 * everything. 789 */ 790 bzero(fis, sizeof(ccb->ccb_cmd_table->cfis)); 791 fis[0] = ATA_FIS_TYPE_H2D; 792 fis[1] = at->at_target; 793 fis[15] = ATA_FIS_CONTROL_4BIT; 794 795 cmd_slot->prdtl = 0; 796 cmd_slot->flags = htole16(5); /* FIS length: 5 DWORDS */ 797 cmd_slot->flags |= htole16(at->at_target << 798 AHCI_CMD_LIST_FLAG_PMP_SHIFT); 799 800 ccb->ccb_xa.state = ATA_S_PENDING; 801 ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_EXCLUSIVE | ATA_F_AUTOSENSE; 802 803 ap->ap_flags &= ~AP_F_IFS_IGNORED; 804 805 if (ahci_poll(ccb, 1000, ahci_ata_cmd_timeout) != ATA_S_COMPLETE) { 806 kprintf("%s: Soft-reset(2) through PM failed, %s\n", 807 ATANAME(ap, at), 808 (count > 1 ? "retrying" : "giving up")); 809 if (--count) { 810 ahci_os_sleep(1000); 811 ahci_put_err_ccb(ccb); 812 ahci_pwrite(ap, AHCI_PREG_SERR, -1); 813 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS); 814 goto retry; 815 } 816 goto err; 817 } 818 819 ahci_put_err_ccb(ccb); 820 ahci_os_sleep(100); 821 ahci_pwrite(ap, AHCI_PREG_SERR, -1); 822 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS); 823 824 ahci_pm_write(ap, target, SATA_PMREG_SERR, -1); 825 if (ahci_pm_phy_status(ap, target, &data)) { 826 kprintf("%s: (C)Cannot clear phy status\n", 827 ATANAME(ap ,at)); 828 } 829 ahci_pm_write(ap, target, SATA_PMREG_SERR, -1); 830 831 /* 832 * Do it again, even if we think we got a good result 833 */ 834 if (--count) { 835 fis[15] = 0; 836 goto retry; 837 } 838 839 /* 840 * If the softreset is trying to clear a BSY condition after a 841 * normal portreset we assign the port type. 842 * 843 * If the softreset is being run first as part of the ccb error 844 * processing code then report if the device signature changed 845 * unexpectedly. 846 */ 847 if (at->at_type == ATA_PORT_T_NONE) { 848 at->at_type = ahci_port_signature_detect(ap, at); 849 } else { 850 if (ahci_port_signature_detect(ap, at) != at->at_type) { 851 kprintf("%s: device signature unexpectedly " 852 "changed\n", ATANAME(ap, at)); 853 error = EBUSY; /* XXX */ 854 } 855 } 856 error = 0; 857 858 /* 859 * Who knows what kind of mess occured. We have exclusive access 860 * to the port so try to clean up potential problems. 861 */ 862 err: 863 ahci_os_sleep(100); 864 865 /* 866 * Clear error status so we can detect removal. 867 */ 868 if (ahci_pm_write(ap, target, SATA_PMREG_SERR, -1)) { 869 kprintf("%s: ahci_pm_softreset unable to clear SERR\n", 870 ATANAME(ap, at)); 871 } 872 ahci_pwrite(ap, AHCI_PREG_SERR, -1); 873 ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS); 874 ap->ap_flags &= ~(AP_F_IGNORE_IFS | AP_F_IFS_IGNORED); 875 876 at->at_probe = error ? ATA_PROBE_FAILED : ATA_PROBE_NEED_IDENT; 877 return (error); 878 } 879 880 881 /* 882 * Return the phy status for a target behind a port multiplier and 883 * reset SATA_PMREG_SERR. 884 * 885 * Returned bits follow AHCI_PREG_SSTS bits. The AHCI_PREG_SSTS_SPD 886 * bits can be used to determine the link speed and will be 0 if there 887 * is no link. 888 * 889 * 0 is returned if any communications error occurs. 890 */ 891 int 892 ahci_pm_phy_status(struct ahci_port *ap, int target, u_int32_t *datap) 893 { 894 int error; 895 896 error = ahci_pm_read(ap, target, SATA_PMREG_SSTS, datap); 897 if (error == 0) 898 error = ahci_pm_write(ap, target, SATA_PMREG_SERR, -1); 899 if (error) 900 *datap = 0; 901 return(error); 902 } 903 904 /* 905 * Check that a target is still good. 906 */ 907 void 908 ahci_pm_check_good(struct ahci_port *ap, int target) 909 { 910 struct ata_port *at; 911 u_int32_t data; 912 913 /* 914 * It looks like we might have to read the EINFO register 915 * to allow the PM to generate a new event. 916 */ 917 if (ahci_pm_read(ap, 15, SATA_PMREG_EINFO, &data)) { 918 kprintf("%s: Port multiplier EINFO could not be read\n", 919 PORTNAME(ap)); 920 } 921 922 if (ahci_pm_write(ap, target, SATA_PMREG_SERR, -1)) { 923 kprintf("%s: Port multiplier: SERR could not be cleared\n", 924 PORTNAME(ap)); 925 } 926 927 if (target == CAM_TARGET_WILDCARD || target >= ap->ap_pmcount) 928 return; 929 at = ap->ap_ata[target]; 930 931 /* 932 * If the device needs an init or hard reset also make sure the 933 * PHY is turned on. 934 */ 935 if (at->at_probe <= ATA_PROBE_NEED_HARD_RESET) { 936 /*kprintf("%s DOHARD\n", ATANAME(ap, at));*/ 937 ahci_pm_hardreset(ap, target, 1); 938 } 939 940 /* 941 * Read the detect status 942 */ 943 if (ahci_pm_read(ap, target, SATA_PMREG_SSTS, &data)) { 944 kprintf("%s: Unable to access PM SSTS register target %d\n", 945 PORTNAME(ap), target); 946 return; 947 } 948 if ((data & AHCI_PREG_SSTS_DET) != AHCI_PREG_SSTS_DET_DEV) { 949 /*kprintf("%s: DETECT %08x\n", ATANAME(ap, at), data);*/ 950 if (at->at_probe != ATA_PROBE_FAILED) { 951 at->at_probe = ATA_PROBE_FAILED; 952 at->at_type = ATA_PORT_T_NONE; 953 at->at_features |= ATA_PORT_F_RESCAN; 954 kprintf("%s: HOTPLUG (PM) - Device removed\n", 955 ATANAME(ap, at)); 956 } 957 } else { 958 if (at->at_probe == ATA_PROBE_FAILED) { 959 at->at_probe = ATA_PROBE_NEED_HARD_RESET; 960 at->at_features |= ATA_PORT_F_RESCAN; 961 kprintf("%s: HOTPLUG (PM) - Device inserted\n", 962 ATANAME(ap, at)); 963 } 964 } 965 } 966 967 /* 968 * Read a PM register 969 */ 970 int 971 ahci_pm_read(struct ahci_port *ap, int target, int which, u_int32_t *datap) 972 { 973 struct ata_xfer *xa; 974 int error; 975 976 xa = ahci_ata_get_xfer(ap, ap->ap_ata[15]); 977 978 xa->fis->type = ATA_FIS_TYPE_H2D; 979 xa->fis->flags = ATA_H2D_FLAGS_CMD | 15; 980 xa->fis->command = ATA_C_READ_PM; 981 xa->fis->features = which; 982 xa->fis->device = target | ATA_H2D_DEVICE_LBA; 983 xa->fis->control = ATA_FIS_CONTROL_4BIT; 984 985 xa->complete = ahci_pm_dummy_done; 986 xa->datalen = 0; 987 xa->flags = ATA_F_POLL | ATA_F_AUTOSENSE; 988 xa->timeout = 1000; 989 990 if (ahci_ata_cmd(xa) == ATA_S_COMPLETE) { 991 *datap = xa->rfis.sector_count | (xa->rfis.lba_low << 8) | 992 (xa->rfis.lba_mid << 16) | (xa->rfis.lba_high << 24); 993 error = 0; 994 } else { 995 kprintf("%s.%d pm_read SCA[%d] failed\n", 996 PORTNAME(ap), target, which); 997 *datap = 0; 998 error = EIO; 999 } 1000 ahci_ata_put_xfer(xa); 1001 return (error); 1002 } 1003 1004 /* 1005 * Write a PM register 1006 */ 1007 int 1008 ahci_pm_write(struct ahci_port *ap, int target, int which, u_int32_t data) 1009 { 1010 struct ata_xfer *xa; 1011 int error; 1012 1013 xa = ahci_ata_get_xfer(ap, ap->ap_ata[15]); 1014 1015 xa->fis->type = ATA_FIS_TYPE_H2D; 1016 xa->fis->flags = ATA_H2D_FLAGS_CMD | 15; 1017 xa->fis->command = ATA_C_WRITE_PM; 1018 xa->fis->features = which; 1019 xa->fis->device = target | ATA_H2D_DEVICE_LBA; 1020 xa->fis->sector_count = (u_int8_t)data; 1021 xa->fis->lba_low = (u_int8_t)(data >> 8); 1022 xa->fis->lba_mid = (u_int8_t)(data >> 16); 1023 xa->fis->lba_high = (u_int8_t)(data >> 24); 1024 xa->fis->control = ATA_FIS_CONTROL_4BIT; 1025 1026 xa->complete = ahci_pm_dummy_done; 1027 xa->datalen = 0; 1028 xa->flags = ATA_F_POLL; 1029 xa->timeout = 1000; 1030 1031 if (ahci_ata_cmd(xa) == ATA_S_COMPLETE) 1032 error = 0; 1033 else 1034 error = EIO; 1035 ahci_ata_put_xfer(xa); 1036 return(error); 1037 } 1038 1039 /* 1040 * Dummy done callback for xa. 1041 */ 1042 static void 1043 ahci_pm_dummy_done(struct ata_xfer *xa) 1044 { 1045 } 1046 1047