sys/dev/disk/ahci/ahci_pm.c

   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         int             count;
  68         int             i;
  69
  70         count = 2;
  71 retry:
  72         /*
  73          * This code is only called from hardreset, which does not
  74          * high level command processing.  The port should be stopped.
  75          *
  76          * Set PMA mode while the port is stopped.
  77          *
  78          * NOTE: On retry the port might be running, stopped, or failed.
  79          */
  80         ahci_port_stop(ap, 0);
  81         ap->ap_state = AP_S_NORMAL;
  82         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
  83         if ((cmd & AHCI_PREG_CMD_PMA) == 0) {
  84                 cmd |= AHCI_PREG_CMD_PMA;
  85                 ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
  86         }
  87
  88         /*
  89          * Flush any errors and request CLO unconditionally, then start
  90          * the port.
  91          */
  92         ahci_flush_tfd(ap);
  93         ahci_port_clo(ap);
  94         if (ahci_port_start(ap)) {
  95                 kprintf("%s: PMPROBE failed to start port, cannot softreset\n",
  96                         PORTNAME(ap));
  97                 error = EIO;
  98                 goto err;
  99         }
 100
 101         /*
 102          * Check whether CLO worked
 103          */
 104         if (ahci_pwait_clr(ap, AHCI_PREG_TFD,
 105                                AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
 106                 kprintf("%s: PMPROBE CLO %s, need port reset\n",
 107                         PORTNAME(ap),
 108                         (ahci_read(ap->ap_sc, AHCI_REG_CAP) & AHCI_REG_CAP_SCLO)
 109                         ? "failed" : "unsupported");
 110                 error = EBUSY;
 111                 goto err;
 112         }
 113
 114         /*
 115          * Use the error CCB for all commands
 116          *
 117          * NOTE!  This CCB is used for both the first and second commands.
 118          *        The second command must use CCB slot 1 to properly load
 119          *        the signature.
 120          */
 121         ccb = ahci_get_err_ccb(ap);
 122         ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_SILENT;
 123         ccb->ccb_xa.complete = ahci_pm_dummy_done;
 124         ccb->ccb_xa.at = ap->ap_ata[15];
 125         cmd_slot = ccb->ccb_cmd_hdr;
 126         KKASSERT(ccb->ccb_slot == 1);
 127
 128         /*
 129          * Prep the first H2D command with SRST feature & clear busy/reset
 130          * flags.
 131          */
 132         fis = ccb->ccb_cmd_table->cfis;
 133         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
 134         fis[0] = ATA_FIS_TYPE_H2D;
 135         fis[1] = 0x0F;                  /* Target 15 */
 136         fis[15] = ATA_FIS_CONTROL_SRST | ATA_FIS_CONTROL_4BIT;
 137
 138         cmd_slot->prdtl = 0;
 139         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
 140         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_C); /* Clear busy on OK */
 141         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_R); /* Reset */
 142         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_PMP); /* port 0xF */
 143
 144         ccb->ccb_xa.state = ATA_S_PENDING;
 145
 146         /*
 147          * The only way one can determine if a port multiplier is on the
 148          * port is to probe target 15, and of course this will fail if
 149          * there is no port multiplier.
 150          *
 151          * The probing has to be done whether or not a device is probed on
 152          * target 0, because when a PM is attached target 0 represents
 153          * slot #0 behind the PM.
 154          *
 155          * Port multipliers are expected to answer more quickly than normal
 156          * devices, use a shorter timeout than normal.
 157          *
 158          * If there is no PM here this command can still succeed due to
 159          * the _C_
 160          */
 161         if (ahci_poll(ccb, 500, ahci_quick_timeout) != ATA_S_COMPLETE) {
 162                 kprintf("%s: PMPROBE(1) No Port Multiplier was found.\n",
 163                         PORTNAME(ap));
 164                 if (--count) {
 165                         ahci_put_err_ccb(ccb);
 166                         goto retry;
 167                 }
 168                 error = EBUSY;
 169                 goto err;
 170         }
 171
 172         if (ahci_pwait_clr(ap, AHCI_PREG_TFD,
 173                                AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
 174                 kprintf("%s: PMPROBE Busy after first FIS\n", PORTNAME(ap));
 175         }
 176
 177         /*
 178          * The device may have muffed up the PHY when it reset.
 179          */
 180         ahci_flush_tfd(ap);
 181         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
 182         /* ahci_pm_phy_status(ap, 15, &cmd); */
 183
 184         /*
 185          * Prep second D2H command to read status and complete reset sequence
 186          * AHCI 10.4.1 and "Serial ATA Revision 2.6".  I can't find the ATA
 187          * Rev 2.6 and it is unclear how the second FIS should be set up
 188          * from the AHCI document.
 189          *
 190          * Give the device 3ms before sending the second FIS.
 191          *
 192          * It is unclear which other fields in the FIS are used.  Just zero
 193          * everything.
 194          */
 195         ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_SILENT;
 196
 197         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
 198         fis[0] = ATA_FIS_TYPE_H2D;
 199         fis[1] = 0x0F;
 200         fis[15] = ATA_FIS_CONTROL_4BIT;
 201
 202         cmd_slot->prdtl = 0;
 203         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
 204         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_PMP); /* port 0xF */
 205
 206         ccb->ccb_xa.state = ATA_S_PENDING;
 207
 208         /*
 209          * The only way one can determine if a port multiplier is on the
 210          * port is to probe target 15, and of course this will fail if
 211          * there is no port multiplier.
 212          *
 213          * The probing has to be done whether or not a device is probed on
 214          * target 0, because when a PM is attached target 0 represents
 215          * slot #0 behind the PM.
 216          */
 217         if (ahci_poll(ccb, 5000, ahci_quick_timeout) != ATA_S_COMPLETE) {
 218                 kprintf("%s: PMPROBE(2) No Port Multiplier was found.\n",
 219                         PORTNAME(ap));
 220                 if (--count) {
 221                         ahci_put_err_ccb(ccb);
 222                         goto retry;
 223                 }
 224                 error = EBUSY;
 225                 goto err;
 226         }
 227
 228         /*
 229          * What? We succeeded?  Yup, but for some reason the signature
 230          * is still latched from the original detect (that saw target 0
 231          * behind the PM), and I don't know how to clear the condition
 232          * other then by retrying the whole reset sequence.
 233          */
 234         if (--count) {
 235                 fis[15] = 0;
 236                 ahci_put_err_ccb(ccb);
 237                 goto retry;
 238         }
 239
 240         /*
 241          * Get the signature.  The caller sets the ap fields.
 242          */
 243         if (ahci_port_signature_detect(ap, NULL) == ATA_PORT_T_PM) {
 244                 ap->ap_ata[15]->at_probe = ATA_PROBE_GOOD;
 245                 error = 0;
 246         } else {
 247                 error = EBUSY;
 248         }
 249
 250         /*
 251          * Fall through / clean up the CCB and perform error processing.
 252          */
 253 err:
 254         if (ccb != NULL)
 255                 ahci_put_err_ccb(ccb);
 256
 257         if (error == 0 && ahci_pm_identify(ap)) {
 258                 kprintf("%s: PM - cannot identify port multiplier\n",
 259                         PORTNAME(ap));
 260                 error = EBUSY;
 261         }
 262
 263         /*
 264          * If we probed the PM reset the state for the targets behind
 265          * it so they get probed by the state machine.
 266          */
 267         if (error == 0) {
 268                 for (i = 0; i < AHCI_MAX_PMPORTS; ++i) {
 269                         at = ap->ap_ata[i];
 270                         at->at_probe = ATA_PROBE_NEED_INIT;
 271                         at->at_features |= ATA_PORT_F_RESCAN;
 272                 }
 273                 ap->ap_type = ATA_PORT_T_PM;
 274                 return (0);
 275         }
 276
 277         /*
 278          * If we failed turn off PMA, otherwise identify the port multiplier.
 279          * CAM will iterate the devices.
 280          */
 281         ahci_port_stop(ap, 0);
 282         ahci_port_clo(ap);
 283         cmd = ahci_pread(ap, AHCI_PREG_CMD) & ~AHCI_PREG_CMD_ICC;
 284         cmd &= ~AHCI_PREG_CMD_PMA;
 285         ahci_pwrite(ap, AHCI_PREG_CMD, cmd);
 286         if (orig_error == 0) {
 287                 if (ahci_pwait_clr(ap, AHCI_PREG_TFD,
 288                             AHCI_PREG_TFD_STS_BSY | AHCI_PREG_TFD_STS_DRQ)) {
 289                         kprintf("%s: PM probe: port will not come ready\n",
 290                                 PORTNAME(ap));
 291                         orig_error = EBUSY;
 292                         ahci_port_init(ap);
 293                 }
 294         }
 295         return(orig_error);
 296 }
 297
 298 /*
 299  * Identify the port multiplier
 300  */
 301 int
 302 ahci_pm_identify(struct ahci_port *ap)
 303 {
 304         u_int32_t chipid;
 305         u_int32_t rev;
 306         u_int32_t nports;
 307         u_int32_t data1;
 308         u_int32_t data2;
 309         int       has_dummy_port;
 310
 311         ap->ap_probe = ATA_PROBE_FAILED;
 312         if (ahci_pm_read(ap, 15, 0, &chipid))
 313                 goto err;
 314         if (ahci_pm_read(ap, 15, 1, &rev))
 315                 goto err;
 316         if (ahci_pm_read(ap, 15, 2, &nports))
 317                 goto err;
 318         nports &= 0x0000000F;   /* only the low 4 bits */
 319         ap->ap_probe = ATA_PROBE_GOOD;
 320
 321         /*
 322          * Ignore fake port on PMs which have it.  We can probe it but the
 323          * softreset will probably fail.
 324          */
 325         switch(chipid) {
 326         case 0x37261095:
 327                 has_dummy_port = 1;
 328                 break;
 329         default:
 330                 has_dummy_port = 0;
 331                 break;
 332         }
 333         if (has_dummy_port) {
 334                 if (nports > 1)
 335                         --nports;
 336         }
 337
 338         kprintf("%s: Port multiplier: chip=%08x rev=0x%b nports=%d\n",
 339                 PORTNAME(ap),
 340                 chipid,
 341                 rev, SATA_PFMT_PM_REV,
 342                 nports);
 343         if (has_dummy_port) {
 344                 kprintf("%s: Port multiplier: Ignoring dummy port #%d\n",
 345                 PORTNAME(ap), nports);
 346         }
 347         ap->ap_pmcount = nports;
 348
 349         if (ahci_pm_read(ap, 15, SATA_PMREG_FEA, &data1)) {
 350                 kprintf("%s: Port multiplier: Warning, "
 351                         "cannot read feature register\n", PORTNAME(ap));
 352         } else {
 353                 kprintf("%s: Port multiplier features: 0x%b\n",
 354                         PORTNAME(ap),
 355                         data1,
 356                         SATA_PFMT_PM_FEA);
 357         }
 358         if (ahci_pm_read(ap, 15, SATA_PMREG_FEAEN, &data2) == 0) {
 359                 kprintf("%s: Port multiplier defaults: 0x%b\n",
 360                         PORTNAME(ap),
 361                         data2,
 362                         SATA_PFMT_PM_FEA);
 363         }
 364
 365         /*
 366          * Turn on async notification if we support and the PM supports it.
 367          * This allows the PM to forward async notification events to us and
 368          * it will also generate an event for target 15 for hot-plug events
 369          * (or is supposed to anyway).
 370          */
 371         if ((ap->ap_sc->sc_cap & AHCI_REG_CAP_SSNTF) &&
 372             (data1 & SATA_PMFEA_ASYNCNOTIFY)) {
 373                 u_int32_t serr_bits = AHCI_PREG_SERR_DIAG_N |
 374                                       AHCI_PREG_SERR_DIAG_X;
 375                 data2 |= SATA_PMFEA_ASYNCNOTIFY;
 376                 if (ahci_pm_write(ap, 15, SATA_PMREG_FEAEN, data2)) {
 377                         kprintf("%s: Port multiplier: AsyncNotify cannot be "
 378                                 "enabled\n", PORTNAME(ap));
 379                 } else if (ahci_pm_write(ap, 15, SATA_PMREG_EEENA, serr_bits)) {
 380                         kprintf("%s: Port mulltiplier: AsyncNotify unable "
 381                                 "to enable error info bits\n", PORTNAME(ap));
 382                 } else {
 383                         kprintf("%s: Port multiplier: AsyncNotify enabled\n",
 384                                 PORTNAME(ap));
 385                 }
 386         }
 387
 388         return (0);
 389 err:
 390         kprintf("%s: Port multiplier cannot be identified\n", PORTNAME(ap));
 391         return (EIO);
 392 }
 393
 394 /*
 395  * Do a COMRESET sequence on the target behind a port multiplier.
 396  *
 397  * If hard is 2 we also cycle the phy on the target.
 398  *
 399  * This must be done prior to any softreset or probe attempts on
 400  * targets behind the port multiplier.
 401  *
 402  * Returns 0 on success or an error.
 403  */
 404 int
 405 ahci_pm_hardreset(struct ahci_port *ap, int target, int hard)
 406 {
 407         struct ata_port *at;
 408         u_int32_t data;
 409         int loop;
 410         int error = EIO;
 411
 412         at = ap->ap_ata[target];
 413
 414         /*
 415          * Turn off power management and kill the phy on the target
 416          * if requested.  Hold state for 10ms.
 417          */
 418         data = AHCI_PREG_SCTL_IPM_DISABLED;
 419         if (hard == 2)
 420                 data |= AHCI_PREG_SCTL_DET_DISABLE;
 421         if (ahci_pm_write(ap, target, SATA_PMREG_SERR, -1))
 422                 goto err;
 423         if (ahci_pm_write(ap, target, SATA_PMREG_SCTL, data))
 424                 goto err;
 425         ahci_os_sleep(10);
 426
 427         /*
 428          * Start transmitting COMRESET.  COMRESET must be sent for at
 429          * least 1ms.
 430          */
 431         at->at_probe = ATA_PROBE_FAILED;
 432         at->at_type = ATA_PORT_T_NONE;
 433         data = AHCI_PREG_SCTL_IPM_DISABLED | AHCI_PREG_SCTL_DET_INIT;
 434         switch(AhciForceGen) {
 435         case 0:
 436                 data |= AHCI_PREG_SCTL_SPD_ANY;
 437                 break;
 438         case 1:
 439                 data |= AHCI_PREG_SCTL_SPD_GEN1;
 440                 break;
 441         case 2:
 442                 data |= AHCI_PREG_SCTL_SPD_GEN2;
 443                 break;
 444         case 3:
 445                 data |= AHCI_PREG_SCTL_SPD_GEN3;
 446                 break;
 447         default:
 448                 data |= AHCI_PREG_SCTL_SPD_GEN3;
 449                 break;
 450         }
 451         if (ahci_pm_write(ap, target, SATA_PMREG_SCTL, data))
 452                 goto err;
 453
 454         /*
 455          * It takes about 100ms for the DET logic to settle down,
 456          * from trial and error testing.  If this is too short
 457          * the softreset code will fail.
 458          */
 459         ahci_os_sleep(100);
 460
 461         if (ahci_pm_phy_status(ap, target, &data)) {
 462                 kprintf("%s: (A)Cannot clear phy status\n",
 463                         ATANAME(ap ,at));
 464         }
 465
 466         /*
 467          * Flush any status, then clear DET to initiate negotiation.
 468          */
 469         ahci_pm_write(ap, target, SATA_PMREG_SERR, -1);
 470         data = AHCI_PREG_SCTL_IPM_DISABLED | AHCI_PREG_SCTL_DET_NONE;
 471         if (ahci_pm_write(ap, target, SATA_PMREG_SCTL, data))
 472                 goto err;
 473
 474         /*
 475          * Try to determine if there is a device on the port.
 476          *
 477          * Give the device 3/10 second to at least be detected.
 478          * If we fail clear any pending status since we may have
 479          * cycled the phy and probably caused another PRCS interrupt.
 480          */
 481         for (loop = 3; loop; --loop) {
 482                 if (ahci_pm_read(ap, target, SATA_PMREG_SSTS, &data))
 483                         goto err;
 484                 if (data & AHCI_PREG_SSTS_DET)
 485                         break;
 486                 ahci_os_sleep(100);
 487         }
 488         if (loop == 0) {
 489                 kprintf("%s.%d: Port appears to be unplugged\n",
 490                         PORTNAME(ap), target);
 491                 error = ENODEV;
 492                 goto err;
 493         }
 494
 495         /*
 496          * There is something on the port.  Give the device 3 seconds
 497          * to fully negotiate.
 498          */
 499         for (loop = 30; loop; --loop) {
 500                 if (ahci_pm_read(ap, target, SATA_PMREG_SSTS, &data))
 501                         goto err;
 502                 if ((data & AHCI_PREG_SSTS_DET) == AHCI_PREG_SSTS_DET_DEV)
 503                         break;
 504                 ahci_os_sleep(100);
 505         }
 506
 507         /*
 508          * Device not detected
 509          */
 510         if (loop == 0) {
 511                 kprintf("%s: Device may be powered down\n",
 512                         PORTNAME(ap));
 513                 error = ENODEV;
 514                 goto err;
 515         }
 516
 517         /*
 518          * Device detected
 519          */
 520         kprintf("%s.%d: Device detected data=%08x\n",
 521                 PORTNAME(ap), target, data);
 522         /*
 523          * Clear SERR on the target so we get a new NOTIFY event if a hot-plug
 524          * or hot-unplug occurs.  Clear any spurious IFS that may have
 525          * occured during the probe.
 526          *
 527          * WARNING!  100ms seems to work in most cases but
 528          */
 529         ahci_os_sleep(100);
 530         ahci_pm_write(ap, target, SATA_PMREG_SERR, -1);
 531         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
 532         ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS);
 533
 534         error = 0;
 535 err:
 536         at->at_probe = error ? ATA_PROBE_FAILED : ATA_PROBE_NEED_SOFT_RESET;
 537         return (error);
 538 }
 539
 540 /*
 541  * AHCI soft reset through port multiplier.
 542  *
 543  * This function keeps port communications intact and attempts to generate
 544  * a reset to the connected device using device commands.  Unlike
 545  * hard-port operations we can't do fancy stop/starts or stuff like
 546  * that without messing up other commands that might be running or
 547  * queued.
 548  */
 549 int
 550 ahci_pm_softreset(struct ahci_port *ap, int target)
 551 {
 552         struct ata_port         *at;
 553         struct ahci_ccb         *ccb;
 554         struct ahci_cmd_hdr     *cmd_slot;
 555         u_int8_t                *fis;
 556         int                     count;
 557         int                     error;
 558         u_int32_t               data;
 559
 560         error = EIO;
 561         at = ap->ap_ata[target];
 562
 563         DPRINTF(AHCI_D_VERBOSE, "%s: soft reset\n", PORTNAME(ap));
 564
 565         count = 2;
 566 retry:
 567         /*
 568          * Try to clear the phy so we get a good signature, otherwise
 569          * the PM may not latch a new signature.
 570          *
 571          * NOTE: This cannot be safely done between the first and second
 572          *       softreset FISs.  It's now or never.
 573          */
 574         if (ahci_pm_phy_status(ap, target, &data)) {
 575                 kprintf("%s: (B)Cannot clear phy status\n",
 576                         ATANAME(ap ,at));
 577         }
 578         ahci_pm_write(ap, target, SATA_PMREG_SERR, -1);
 579
 580         /*
 581          * Prep first D2H command with SRST feature & clear busy/reset flags
 582          *
 583          * It is unclear which other fields in the FIS are used.  Just zero
 584          * everything.
 585          *
 586          * When soft-resetting a port behind a multiplier at will be
 587          * non-NULL, assigning it to the ccb prevents the port interrupt
 588          * from hard-resetting the port if a problem crops up.
 589          */
 590         ccb = ahci_get_err_ccb(ap);
 591         ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_EXCLUSIVE | ATA_F_AUTOSENSE;
 592         ccb->ccb_xa.complete = ahci_pm_dummy_done;
 593         ccb->ccb_xa.at = at;
 594
 595         fis = ccb->ccb_cmd_table->cfis;
 596         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
 597         fis[0] = ATA_FIS_TYPE_H2D;
 598         fis[1] = at->at_target;
 599         fis[15] = ATA_FIS_CONTROL_SRST|ATA_FIS_CONTROL_4BIT;
 600
 601         cmd_slot = ccb->ccb_cmd_hdr;
 602         cmd_slot->prdtl = 0;
 603         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
 604         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_C); /* Clear busy on OK */
 605         cmd_slot->flags |= htole16(AHCI_CMD_LIST_FLAG_R); /* Reset */
 606         cmd_slot->flags |= htole16(at->at_target <<
 607                                    AHCI_CMD_LIST_FLAG_PMP_SHIFT);
 608
 609         ccb->ccb_xa.state = ATA_S_PENDING;
 610
 611         /*
 612          * This soft reset of the AP target can cause a stream of IFS
 613          * errors to occur.  Setting AP_F_IGNORE_IFS prevents the port
 614          * from being hard reset (because its the target behind the
 615          * port that isn't happy).
 616          *
 617          * The act of sending the soft reset can cause the target to
 618          * blow the port up and generate IFS errors.
 619          */
 620         ap->ap_flags |= AP_F_IGNORE_IFS;
 621         ap->ap_flags &= ~AP_F_IFS_IGNORED;
 622
 623         if (ahci_poll(ccb, 1000, ahci_ata_cmd_timeout) != ATA_S_COMPLETE) {
 624                 kprintf("%s: Soft-reset through PM failed, %s\n",
 625                         ATANAME(ap, at),
 626                         (count > 1 ? "retrying" : "giving up"));
 627                 ahci_put_err_ccb(ccb);
 628                 if (--count) {
 629                         if (ap->ap_flags & AP_F_IFS_IGNORED)
 630                                 ahci_os_sleep(5000);
 631                         else
 632                                 ahci_os_sleep(1000);
 633                         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
 634                         ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS);
 635                         goto retry;
 636                 }
 637                 goto err;
 638         }
 639
 640         /*
 641          * WARNING!  SENSITIVE TIME PERIOD!  WARNING!
 642          *
 643          * The first and second FISes are supposed to be back-to-back,
 644          * I think the idea is to get the second sent and then after
 645          * the device resets it will send a signature.  Do not delay
 646          * here and most definitely do not issue any commands to other
 647          * targets!
 648          */
 649
 650         /*
 651          * Prep second D2H command to read status and complete reset sequence
 652          * AHCI 10.4.1 and "Serial ATA Revision 2.6".  I can't find the ATA
 653          * Rev 2.6 and it is unclear how the second FIS should be set up
 654          * from the AHCI document.
 655          *
 656          * Give the device 3ms before sending the second FIS.
 657          *
 658          * It is unclear which other fields in the FIS are used.  Just zero
 659          * everything.
 660          */
 661         bzero(fis, sizeof(ccb->ccb_cmd_table->cfis));
 662         fis[0] = ATA_FIS_TYPE_H2D;
 663         fis[1] = at->at_target;
 664         fis[15] = ATA_FIS_CONTROL_4BIT;
 665
 666         cmd_slot->prdtl = 0;
 667         cmd_slot->flags = htole16(5);   /* FIS length: 5 DWORDS */
 668         cmd_slot->flags |= htole16(at->at_target <<
 669                                    AHCI_CMD_LIST_FLAG_PMP_SHIFT);
 670
 671         ccb->ccb_xa.state = ATA_S_PENDING;
 672         ccb->ccb_xa.flags = ATA_F_POLL | ATA_F_EXCLUSIVE | ATA_F_AUTOSENSE;
 673
 674         ap->ap_flags &= ~AP_F_IFS_IGNORED;
 675
 676         if (ahci_poll(ccb, 1000, ahci_ata_cmd_timeout) != ATA_S_COMPLETE) {
 677                 kprintf("%s: Soft-reset(2) through PM failed, %s\n",
 678                         ATANAME(ap, at),
 679                         (count > 1 ? "retrying" : "giving up"));
 680                 if (--count) {
 681                         ahci_os_sleep(1000);
 682                         ahci_put_err_ccb(ccb);
 683                         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
 684                         ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS);
 685                         goto retry;
 686                 }
 687                 goto err;
 688         }
 689
 690         ahci_put_err_ccb(ccb);
 691         ahci_os_sleep(100);
 692         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
 693         ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS);
 694
 695         ahci_pm_write(ap, target, SATA_PMREG_SERR, -1);
 696         if (ahci_pm_phy_status(ap, target, &data)) {
 697                 kprintf("%s: (C)Cannot clear phy status\n",
 698                         ATANAME(ap ,at));
 699         }
 700         ahci_pm_write(ap, target, SATA_PMREG_SERR, -1);
 701
 702         /*
 703          * Do it again, even if we think we got a good result
 704          */
 705         if (--count) {
 706                 fis[15] = 0;
 707                 goto retry;
 708         }
 709
 710         /*
 711          * If the softreset is trying to clear a BSY condition after a
 712          * normal portreset we assign the port type.
 713          *
 714          * If the softreset is being run first as part of the ccb error
 715          * processing code then report if the device signature changed
 716          * unexpectedly.
 717          */
 718         if (at->at_type == ATA_PORT_T_NONE) {
 719                 at->at_type = ahci_port_signature_detect(ap, at);
 720         } else {
 721                 if (ahci_port_signature_detect(ap, at) != at->at_type) {
 722                         kprintf("%s: device signature unexpectedly "
 723                                 "changed\n", ATANAME(ap, at));
 724                         error = EBUSY; /* XXX */
 725                 }
 726         }
 727         error = 0;
 728
 729         /*
 730          * Who knows what kind of mess occured.  We have exclusive access
 731          * to the port so try to clean up potential problems.
 732          */
 733 err:
 734         ahci_os_sleep(100);
 735
 736         /*
 737          * Clear error status so we can detect removal.
 738          */
 739         if (ahci_pm_write(ap, target, SATA_PMREG_SERR, -1)) {
 740                 kprintf("%s: ahci_pm_softreset unable to clear SERR\n",
 741                         ATANAME(ap, at));
 742         }
 743         ahci_pwrite(ap, AHCI_PREG_SERR, -1);
 744         ahci_pwrite(ap, AHCI_PREG_IS, AHCI_PREG_IS_IFS);
 745         ap->ap_flags &= ~(AP_F_IGNORE_IFS | AP_F_IFS_IGNORED);
 746
 747         at->at_probe = error ? ATA_PROBE_FAILED : ATA_PROBE_NEED_IDENT;
 748         return (error);
 749 }
 750
 751
 752 /*
 753  * Return the phy status for a target behind a port multiplier and
 754  * reset SATA_PMREG_SERR.
 755  *
 756  * Returned bits follow AHCI_PREG_SSTS bits.  The AHCI_PREG_SSTS_SPD
 757  * bits can be used to determine the link speed and will be 0 if there
 758  * is no link.
 759  *
 760  * 0 is returned if any communications error occurs.
 761  */
 762 int
 763 ahci_pm_phy_status(struct ahci_port *ap, int target, u_int32_t *datap)
 764 {
 765         int error;
 766
 767         error = ahci_pm_read(ap, target, SATA_PMREG_SSTS, datap);
 768         if (error == 0)
 769                 error = ahci_pm_write(ap, target, SATA_PMREG_SERR, -1);
 770         if (error)
 771                 *datap = 0;
 772         return(error);
 773 }
 774
 775 /*
 776  * Check that a target is still good.
 777  */
 778 void
 779 ahci_pm_check_good(struct ahci_port *ap, int target)
 780 {
 781         struct ata_port *at;
 782         u_int32_t data;
 783
 784         /*
 785          * It looks like we might have to read the EINFO register
 786          * to allow the PM to generate a new event.
 787          */
 788         if (ahci_pm_read(ap, 15, SATA_PMREG_EINFO, &data)) {
 789                 kprintf("%s: Port multiplier EINFO could not be read\n",
 790                         PORTNAME(ap));
 791         }
 792
 793         if (ahci_pm_write(ap, target, SATA_PMREG_SERR, -1)) {
 794                 kprintf("%s: Port multiplier: SERR could not be cleared\n",
 795                         PORTNAME(ap));
 796         }
 797
 798         if (target == CAM_TARGET_WILDCARD || target >= ap->ap_pmcount)
 799                 return;
 800         at = ap->ap_ata[target];
 801
 802         /*
 803          * If the device needs an init or hard reset also make sure the
 804          * PHY is turned on.
 805          */
 806         if (at->at_probe <= ATA_PROBE_NEED_HARD_RESET) {
 807                 /*kprintf("%s DOHARD\n", ATANAME(ap, at));*/
 808                 ahci_pm_hardreset(ap, target, 1);
 809         }
 810
 811         /*
 812          * Read the detect status
 813          */
 814         if (ahci_pm_read(ap, target, SATA_PMREG_SSTS, &data)) {
 815                 kprintf("%s: Unable to access PM SSTS register target %d\n",
 816                         PORTNAME(ap), target);
 817                 return;
 818         }
 819         if ((data & AHCI_PREG_SSTS_DET) != AHCI_PREG_SSTS_DET_DEV) {
 820                 /*kprintf("%s: DETECT %08x\n", ATANAME(ap, at), data);*/
 821                 if (at->at_probe != ATA_PROBE_FAILED) {
 822                         at->at_probe = ATA_PROBE_FAILED;
 823                         at->at_type = ATA_PORT_T_NONE;
 824                         at->at_features |= ATA_PORT_F_RESCAN;
 825                         kprintf("%s: HOTPLUG (PM) - Device removed\n",
 826                                 ATANAME(ap, at));
 827                 }
 828         } else {
 829                 if (at->at_probe == ATA_PROBE_FAILED) {
 830                         at->at_probe = ATA_PROBE_NEED_HARD_RESET;
 831                         at->at_features |= ATA_PORT_F_RESCAN;
 832                         kprintf("%s: HOTPLUG (PM) - Device inserted\n",
 833                                 ATANAME(ap, at));
 834                 }
 835         }
 836 }
 837
 838 /*
 839  * Read a PM register
 840  */
 841 int
 842 ahci_pm_read(struct ahci_port *ap, int target, int which, u_int32_t *datap)
 843 {
 844         struct ata_xfer *xa;
 845         int error;
 846
 847         xa = ahci_ata_get_xfer(ap, ap->ap_ata[15]);
 848
 849         xa->fis->type = ATA_FIS_TYPE_H2D;
 850         xa->fis->flags = ATA_H2D_FLAGS_CMD | 15;
 851         xa->fis->command = ATA_C_READ_PM;
 852         xa->fis->features = which;
 853         xa->fis->device = target | ATA_H2D_DEVICE_LBA;
 854         xa->fis->control = ATA_FIS_CONTROL_4BIT;
 855
 856         xa->complete = ahci_pm_dummy_done;
 857         xa->datalen = 0;
 858         xa->flags = ATA_F_POLL | ATA_F_AUTOSENSE;
 859         xa->timeout = 1000;
 860
 861         if (ahci_ata_cmd(xa) == ATA_S_COMPLETE) {
 862                 *datap = xa->rfis.sector_count | (xa->rfis.lba_low << 8) |
 863                        (xa->rfis.lba_mid << 16) | (xa->rfis.lba_high << 24);
 864                 error = 0;
 865         } else {
 866                 kprintf("%s.%d pm_read SCA[%d] failed\n",
 867                         PORTNAME(ap), target, which);
 868                 *datap = 0;
 869                 error = EIO;
 870         }
 871         ahci_ata_put_xfer(xa);
 872         return (error);
 873 }
 874
 875 /*
 876  * Write a PM register
 877  */
 878 int
 879 ahci_pm_write(struct ahci_port *ap, int target, int which, u_int32_t data)
 880 {
 881         struct ata_xfer *xa;
 882         int error;
 883
 884         xa = ahci_ata_get_xfer(ap, ap->ap_ata[15]);
 885
 886         xa->fis->type = ATA_FIS_TYPE_H2D;
 887         xa->fis->flags = ATA_H2D_FLAGS_CMD | 15;
 888         xa->fis->command = ATA_C_WRITE_PM;
 889         xa->fis->features = which;
 890         xa->fis->device = target | ATA_H2D_DEVICE_LBA;
 891         xa->fis->sector_count = (u_int8_t)data;
 892         xa->fis->lba_low = (u_int8_t)(data >> 8);
 893         xa->fis->lba_mid = (u_int8_t)(data >> 16);
 894         xa->fis->lba_high = (u_int8_t)(data >> 24);
 895         xa->fis->control = ATA_FIS_CONTROL_4BIT;
 896
 897         xa->complete = ahci_pm_dummy_done;
 898         xa->datalen = 0;
 899         xa->flags = ATA_F_POLL;
 900         xa->timeout = 1000;
 901
 902         if (ahci_ata_cmd(xa) == ATA_S_COMPLETE)
 903                 error = 0;
 904         else
 905                 error = EIO;
 906         ahci_ata_put_xfer(xa);
 907         return(error);
 908 }
 909
 910 /*
 911  * Dummy done callback for xa.
 912  */
 913 static void
 914 ahci_pm_dummy_done(struct ata_xfer *xa)
 915 {
 916 }
 917