| blob | f59fcb974ef7d1eaef2fe10c05933ece85e1af9b |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
22 /*
23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2018 Nexenta Systems, Inc. All rights reserved.
25 */
27 /*
28 * AHCI (Advanced Host Controller Interface) SATA HBA Driver
29 *
30 * Power Management Support
31 * ------------------------
32 *
33 * At the moment, the ahci driver only implements suspend/resume to
34 * support Suspend to RAM on X86 feature. Device power management isn't
35 * implemented, link power management is disabled, and hot plug isn't
36 * allowed during the period from suspend to resume.
37 *
38 * For s/r support, the ahci driver only need to implement DDI_SUSPEND
39 * and DDI_RESUME entries, and don't need to take care of new requests
40 * sent down after suspend because the target driver (sd) has already
41 * handled these conditions, and blocked these requests. For the detailed
42 * information, please check with sdopen, sdclose and sdioctl routines.
43 *
44 */
46 #include <sys/note.h>
47 #include <sys/scsi/scsi.h>
48 #include <sys/pci.h>
49 #include <sys/disp.h>
50 #include <sys/sata/sata_hba.h>
51 #include <sys/sata/adapters/ahci/ahcireg.h>
52 #include <sys/sata/adapters/ahci/ahcivar.h>
54 /*
55 * FMA header files
56 */
57 #include <sys/ddifm.h>
58 #include <sys/fm/protocol.h>
59 #include <sys/fm/util.h>
60 #include <sys/fm/io/ddi.h>
62 /*
63 * This is the string displayed by modinfo, etc.
64 */
67 /*
68 * Function prototypes for driver entry points
69 */
75 /*
76 * Function prototypes for SATA Framework interfaces
77 */
87 #if defined(__lock_lint)
89 #endif
91 /*
92 * FMA Prototypes
93 */
105 /*
106 * Local function prototypes
107 */
134 sata_device_t *);
136 sata_pmult_gscr_t *);
138 sata_device_t *);
142 sata_device_t *);
147 ahci_addr_t *);
168 ahci_addr_t *);
170 ahci_addr_t *);
172 ahci_addr_t *);
220 #if AHCI_DEBUG
222 #endif
225 /*
226 * DMA attributes for the data buffer
227 *
228 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
229 * does not support 64-bit addressing
230 */
244 };
246 /*
247 * DMA attributes for the rcvd FIS
248 *
249 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
250 * does not support 64-bit addressing
251 */
265 };
267 /*
268 * DMA attributes for the command list
269 *
270 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
271 * does not support 64-bit addressing
272 */
286 };
288 /*
289 * DMA attributes for cmd tables
290 *
291 * dma_attr_addr_hi will be changed to 0xffffffffull if the HBA
292 * does not support 64-bit addressing
293 */
307 };
310 /* Device access attributes */
312 DDI_DEVICE_ATTR_V1,
313 DDI_STRUCTURE_LE_ACC,
314 DDI_STRICTORDER_ACC,
315 DDI_DEFAULT_ACC
316 };
332 };
335 SATA_TRAN_HOTPLUG_OPS_REV_1,
336 ahci_tran_hotplug_port_activate,
337 ahci_tran_hotplug_port_deactivate
338 };
346 };
349 MODREV_1,
351 NULL
352 };
354 /* The following variables are watchdog handler related */
358 /*
359 * This static variable indicates the size of command table,
360 * and it's changeable with prdt number, which ahci_dma_prdt_number
361 * indicates.
362 */
365 /*
366 * The below global variables are tunable via /etc/system
367 *
368 * ahci_dma_prdt_number
369 * ahci_msi_enabled
370 * ahci_buf_64bit_dma
371 * ahci_commu_64bit_dma
372 */
374 /* The number of Physical Region Descriptor Table(PRDT) in Command Table */
377 /* AHCI MSI is tunable */
380 /*
381 * 64-bit dma addressing for data buffer is tunable
382 *
383 * The variable controls only the below value:
384 * DBAU (upper 32-bits physical address of data block)
385 */
388 /*
389 * 64-bit dma addressing for communication system descriptors is tunable
390 *
391 * The variable controls the below three values:
392 *
393 * PxCLBU (upper 32-bits for the command list base physical address)
394 * PxFBU (upper 32-bits for the received FIS base physical address)
395 * CTBAU (upper 32-bits of command table base)
396 */
399 /*
400 * By default, 64-bit dma for data buffer will be disabled for AMD/ATI SB600
401 * chipset. If the users want to have a try with 64-bit dma, please change
402 * the below variable value to enable it.
403 */
406 /*
407 * By default, 64-bit dma for command buffer will be disabled for AMD/ATI
408 * SB600/700/710/750/800. If the users want to have a try with 64-bit dma,
409 * please change the below value to enable it.
410 */
414 /*
415 * End of global tunable variable definition
416 */
418 #if AHCI_DEBUG
420 #else
422 #endif
425 #if AHCI_DEBUG
426 /* The following is needed for ahci_log() */
429 #endif
431 /* Opaque state pointer initialized by ddi_soft_state_init() */
434 /*
435 * ahci module initialization.
436 */
437 int
439 {
445 }
447 #if AHCI_DEBUG
449 #endif
452 #if AHCI_DEBUG
454 #endif
457 }
459 /* watchdog tick */
466 #if AHCI_DEBUG
468 #endif
471 }
475 err_out:
478 }
480 /*
481 * ahci module uninitialize.
482 */
483 int
485 {
491 }
493 /* Remove the resources allocated in _init(). */
495 #if AHCI_DEBUG
497 #endif
501 }
503 /*
504 * _info entry point
505 */
506 int
508 {
510 }
512 /*
513 * The attach entry point for dev_ops.
514 */
515 static int
517 {
529 #if AHCI_DEBUG
531 #endif
534 NULL);
542 /*
543 * During DDI_RESUME, the hardware state of the device
544 * (power may have been removed from the device) must be
545 * restored, allow pending requests to continue, and
546 * service new requests.
547 */
551 /*
552 * GHC.AE must be set to 1 before any other AHCI register
553 * is accessed
554 */
561 /* Restart watch thread */
569 /*
570 * Re-initialize the controller and enable the interrupts and
571 * restart all the ports.
572 *
573 * Note that so far we don't support hot-plug during
574 * suspend/resume.
575 */
578 "Failed to initialize the controller "
581 }
591 }
595 /* Allocate soft state */
599 instance);
601 }
607 /* Initialize the cport/port mapping */
611 }
615 /* Initialize FMA properties */
620 /*
621 * Now map the AHCI base address; which includes global
622 * registers and port control registers
623 *
624 * According to the spec, the AHCI Base Address is BAR5,
625 * but BAR0-BAR4 are optional, so we need to check which
626 * rnumber is used for BAR5.
627 */
629 /*
630 * search through DDI "reg" property for the AHCI register set
631 */
636 instance);
638 }
640 /* AHCI Base Address is located at 0x24 offset */
645 }
651 instance);
653 }
658 rnumber,
666 instance);
668 }
672 /*
673 * GHC.AE must be set to 1 before any other AHCI register
674 * is accessed
675 */
682 /* Get the AHCI version information */
691 /* We don't support controllers whose versions are lower than 1.0 */
696 }
698 /* Get the HBA capabilities information */
703 cap_status);
705 /* CAP2 (HBA Capabilities Extended) is available since AHCI spec 1.2 */
709 /* Get the HBA capabilities extended information */
715 }
717 #if AHCI_DEBUG
718 /* Get the interface speed supported by the HBA */
729 }
730 #endif
732 /* Get the number of command slots supported by the HBA */
740 /* Get the bit map which indicates ports implemented by the HBA */
748 /* Max port number implemented */
755 /* Get the number of implemented ports by the HBA */
764 /* Check whether HBA supports 64bit DMA addressing */
770 }
772 /* Checking for the support of Port Multiplier */
778 /* Support FIS-based switching ? */
783 }
784 }
786 /* Checking for Support Command List Override */
791 }
793 /* Checking for Asynchronous Notification */
798 }
803 instance);
805 }
809 /*
810 * Check the pci configuration space, and set caps. We also
811 * handle the hardware defect in this function.
812 *
813 * For example, force ATI SB600 to use 32-bit dma addressing
814 * since it doesn't support 64-bit dma though its CAP register
815 * declares it support.
816 */
819 instance);
821 }
823 /*
824 * Disable the whole controller interrupts before adding
825 * interrupt handlers(s).
826 */
829 /* Get supported interrupt types */
832 instance);
834 }
838 intr_types);
841 /*
842 * Try MSI first, but fall back to FIXED if failed
843 */
845 DDI_SUCCESS) {
850 }
853 "MSI registration failed, "
855 }
859 DDI_SUCCESS) {
864 }
868 }
874 intr_done:
878 /* Initialize the controller mutex */
888 }
895 "ahci_attach: ahci_dma_prdt_number set by user is 0x%x,"
901 ahci_dma_prdt_number;
908 /*
909 * enable 64bit dma for data buffer for SB600 if
910 * sb600_buf_64bit_dma_disable is B_FALSE
911 */
919 }
921 /*
922 * enable 64bit dma for command buffer for SB600/700/710/800
923 * if sbxxx_commu_64bit_dma_disable is B_FALSE
924 */
937 }
939 /* Allocate the ports structure */
943 instance);
945 }
949 /*
950 * Initialize the controller and ports.
951 */
955 instance);
957 }
961 /* Start one thread to check packet timeouts */
970 instance);
972 }
974 /* Check all handles at the end of the attach operation. */
977 instance);
979 }
987 err_out:
988 /* FMA message */
997 }
1001 }
1005 }
1009 }
1013 }
1017 }
1021 }
1025 }
1029 }
1032 }
1034 /*
1035 * The detach entry point for dev_ops.
1036 */
1037 static int
1039 {
1052 /* disable the interrupts for an uninterrupted detach */
1057 /* unregister from the sata framework. */
1064 }
1068 /* stop the watchdog handler */
1074 /* uninitialize the controller */
1077 /* remove the interrupts */
1080 /* deallocate the ports structures */
1083 /* destroy mutex */
1086 /* teardown the pci config */
1089 /* remove the reg maps. */
1092 /* release fma resource */
1095 /* free the soft state. */
1102 /*
1103 * The steps associated with suspension must include putting
1104 * the underlying device into a quiescent state so that it
1105 * will not generate interrupts or modify or access memory.
1106 */
1111 }
1115 /* stop the watchdog handler */
1119 }
1123 /*
1124 * drain the taskq
1125 */
1128 /*
1129 * Disable the interrupts and stop all the ports.
1130 */
1137 }
1138 }
1140 /*
1141 * The info entry point for dev_ops.
1142 *
1143 */
1144 static int
1146 {
1151 dev_t dev;
1165 }
1171 }
1174 }
1176 /*
1177 * Registers the ahci with sata framework.
1178 */
1179 static int
1181 {
1189 /* Allocate memory for the sata_hba_tran */
1197 /* Report the number of implemented ports */
1201 /* Support ATAPI device */
1204 /* Get the data transfer capability for PIO command by the HBA */
1209 }
1211 /*
1212 * According to the AHCI spec, the ATA/ATAPI-7 queued feature set
1213 * is not supported by AHCI (including the READ QUEUED (EXT), WRITE
1214 * QUEUED (EXT), and SERVICE commands). Queued operations are
1215 * supported in AHCI using the READ FPDMA QUEUED and WRITE FPDMA
1216 * QUEUED commands when the HBA and device support native command
1217 * queuing(NCQ).
1218 *
1219 * SATA_CTLF_NCQ will be set to sata_tran_hba_features_support if the
1220 * CAP register of the HBA indicates NCQ is supported.
1221 *
1222 * SATA_CTLF_NCQ cannot be set if AHCI_CAP_NO_MCMDLIST_NONQUEUE is
1223 * set because the previous register content of PxCI can be re-written
1224 * in the register write.
1225 */
1232 }
1234 /* Support port multiplier? */
1237 SATA_CTLF_PORT_MULTIPLIER;
1239 /* Support FIS-based switching for port multiplier? */
1242 SATA_CTLF_PMULT_FBS;
1243 }
1244 }
1246 /* Report the number of command slots */
1254 #ifdef __lock_lint
1256 #endif
1257 /*
1258 * When SATA framework adds support for pwrmgt the
1259 * pwrmgt_ops needs to be updated
1260 */
1268 /* Attach it to SATA framework */
1276 }
1279 }
1281 /*
1282 * Unregisters the ahci with sata framework.
1283 */
1284 static int
1286 {
1290 /* Detach from the SATA framework. */
1292 DDI_SUCCESS) {
1294 }
1296 /* Deallocate sata_hba_tran. */
1305 }
1307 #define SET_PORTSTR(str, addrp) \
1308 if (AHCI_ADDR_IS_PORT(addrp)) \
1310 else if (AHCI_ADDR_IS_PMULT(addrp)) \
1312 else \
1314 (addrp)->aa_pmport);
1316 /*
1317 * ahci_tran_probe_port is called by SATA framework. It returns port state,
1318 * port status registers and an attached device type via sata_device
1319 * structure.
1320 *
1321 * We return the cached information from a previous hardware probe. The
1322 * actual hardware probing itself was done either from within
1323 * ahci_initialize_controller() during the driver attach or from a phy
1324 * ready change interrupt handler.
1325 */
1326 static int
1328 {
1356 /* port mutliplier is removed. */
1358 "ahci_tran_probe_port: "
1362 }
1364 /*
1365 * The sata_device may refer to
1366 * 1. A controller port.
1367 * A controller port should be ready here.
1368 * 2. A port multiplier.
1369 * SATA_ADDR_PMULT_SPEC - if it is not initialized yet, initialize
1370 * it and register the port multiplier to the framework.
1371 * SATA_ADDR_PMULT - check the status of all its device ports.
1372 * 3. A port multiplier port.
1373 * If it has not been initialized, initialized it.
1374 *
1375 * A port multiplier or a port multiplier port may require some
1376 * initialization because we cannot do these time-consuming jobs in an
1377 * interrupt context.
1378 */
1381 /* Initialize registers on a port multiplier */
1386 "ahci_tran_probe_port: "
1390 }
1392 /* Check pmports hotplug events */
1395 SATA_ADDR_DPMPORT)) {
1400 }
1401 }
1403 /* Update port state and device type */
1438 }
1451 /*
1452 * HBA driver only knows it's an ATAPI device, and don't know
1453 * it's CD/DVD, tape or ATAPI disk because the ATAPI device
1454 * type need to be determined by checking IDENTIFY PACKET
1455 * DEVICE data
1456 */
1466 /* Update the number of pmports. */
1473 portstr);
1480 portstr);
1484 /* we don't support any other device types */
1489 }
1491 out:
1492 /* Register update only fails while probing a pmult/pmport */
1500 }
1502 /* Check handles for the sata registers access */
1506 DDI_SERVICE_UNAFFECTED);
1508 }
1512 }
1514 /*
1515 * There are four operation modes in sata framework:
1516 * SATA_OPMODE_INTERRUPTS
1517 * SATA_OPMODE_POLLING
1518 * SATA_OPMODE_ASYNCH
1519 * SATA_OPMODE_SYNCH
1520 *
1521 * Their combined meanings as following:
1522 *
1523 * SATA_OPMODE_SYNCH
1524 * The command has to be completed before sata_tran_start functions returns.
1525 * Either interrupts or polling could be used - it's up to the driver.
1526 * Mode used currently for internal, sata-module initiated operations.
1527 *
1528 * SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS
1529 * It is the same as the one above.
1530 *
1531 * SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING
1532 * The command has to be completed before sata_tran_start function returns.
1533 * No interrupt used, polling only. This should be the mode used for scsi
1534 * packets with FLAG_NOINTR.
1535 *
1536 * SATA_OPMODE_ASYNCH | SATA_OPMODE_INTERRUPTS
1537 * The command may be queued (callback function specified). Interrupts could
1538 * be used. It's normal operation mode.
1539 */
1540 /*
1541 * Called by sata framework to transport a sata packet down stream.
1542 */
1543 static int
1545 {
1548 ahci_addr_t addr;
1566 /* Sanity check */
1577 "ahci_tran_start returning PORT_ERROR while "
1581 }
1584 SATA_STATE_READY)) {
1596 "ahci_tran_start returning PORT_ERROR "
1597 "while sub-link is not initialized "
1601 }
1602 }
1603 }
1608 /*
1609 * In case the target driver would send the packet before
1610 * sata framework can have the opportunity to process those
1611 * event reports.
1612 */
1619 "ahci_tran_start returning PORT_ERROR while "
1620 "port in FAILED/SHUTDOWN/PWROFF state: "
1624 }
1627 /*
1628 * ahci_intr_phyrdy_change() may have rendered it to
1629 * SATA_DTYPE_NONE.
1630 */
1638 "ahci_tran_start returning PORT_ERROR while "
1642 }
1644 /* R/W PMULT command will occupy the whole HBA port */
1647 "ahci_tran_start returning BUSY while "
1648 "executing READ/WRITE PORT-MULT command: "
1653 }
1657 "ahci_tran_start returning BUSY while "
1662 }
1664 /*
1665 * SATA HBA driver should remember that a device was reset and it
1666 * is supposed to reject any packets which do not specify either
1667 * SATA_IGNORE_DEV_RESET_STATE or SATA_CLEAR_DEV_RESET_STATE.
1668 *
1669 * This is to prevent a race condition when a device was arbitrarily
1670 * reset by the HBA driver (and lost it's setting) and a target
1671 * driver sending some commands to a device before the sata framework
1672 * has a chance to restore the device setting (such as cache enable/
1673 * disable or other resettable stuff).
1674 */
1675 /*
1676 * It is unnecessary to use specific flags to indicate
1677 * reset_in_progress for a pmport. While mopping, all command will be
1678 * mopped so that the entire HBA port is being dealt as a single
1679 * object.
1680 */
1684 "ahci_tran_start [CLEAR] the "
1686 }
1693 "ahci_tran_start returning BUSY while "
1697 }
1699 #ifdef AHCI_DEBUG
1704 }
1705 #endif
1710 "ahci_tran_start returning BUSY while "
1714 }
1718 DDI_SERVICE_UNAFFECTED);
1721 }
1725 /*
1726 * If a SYNC command to be executed in interrupt context,
1727 * bounce it back to sata module.
1728 */
1733 "ahci_tran_start returning BUSY while "
1734 "sending SYNC mode under interrupt context: "
1738 }
1740 /* We need to do the sync start now */
1744 }
1746 /* Async start, using interrupt */
1751 }
1752 }
1760 fail_out:
1761 /*
1762 * Failed to deliver packet to the controller.
1763 * Check if it's caused by invalid handles.
1764 */
1774 }
1780 }
1782 /*
1783 * SATA_OPMODE_SYNCH flag is set
1784 *
1785 * If SATA_OPMODE_POLLING flag is set, then we must poll the command
1786 * without interrupt, otherwise we can still use the interrupt.
1787 */
1788 static int
1791 {
1809 }
1811 pkt_timeout_ticks =
1815 /* Simulate the interrupt */
1837 }
1838 }
1848 #if AHCI_DEBUG
1849 /*
1850 * Note that the driver always uses the slot 0 to deliver
1851 * REQUEST SENSE or READ LOG EXT command
1852 */
1855 #endif
1862 }
1863 }
1865 /*
1866 * Searches for and claims a free command slot.
1867 *
1868 * Returns value:
1869 *
1870 * AHCI_FAILURE returned only if
1871 * 1. No empty slot left
1872 * 2. Non-queued command requested while queued command(s) is outstanding
1873 * 3. Queued command requested while non-queued command(s) is outstanding
1874 * 4. HBA doesn't support multiple-use of command list while already a
1875 * non-queued command is oustanding
1876 * 5. Queued command requested while some queued command(s) has been
1877 * outstanding on a different port multiplier port. (AHCI spec 1.2,
1878 * 9.1.2)
1879 *
1880 * claimed slot number returned if succeeded
1881 *
1882 * NOTE: it will always return slot 0 for following commands to simplify the
1883 * algorithm.
1884 * 1. REQUEST SENSE or READ LOG EXT command during error recovery process
1885 * 2. READ/WRITE PORTMULT command
1886 */
1887 static int
1890 {
1898 "ahciport_pending_tags = 0x%x "
1903 /*
1904 * According to the AHCI spec, system software is responsible to
1905 * ensure that queued and non-queued commands are not mixed in
1906 * the command list.
1907 */
1909 /* Non-NCQ command request */
1912 "ahci_claim_free_slot: there is still pending "
1913 "queued command(s) in the command list, "
1914 "so no available slot for the non-queued "
1917 }
1920 "ahci_claim_free_slot: there is still pending "
1921 "read/write port-mult command(s) in command list, "
1923 NULL);
1925 }
1929 "ahci_claim_free_slot: HBA cannot support multiple-"
1931 NULL);
1933 }
1937 /* NCQ command request */
1940 "ahci_claim_free_slot: there is still pending "
1941 "non-queued command(s) in the command list, "
1943 NULL);
1945 }
1947 /*
1948 * NCQ commands cannot be sent to different port multiplier
1949 * ports in Command-Based Switching mode
1950 */
1951 /*
1952 * NOTE: In Command-Based Switching mode, AHCI controller
1953 * usually reports a 'Handshake Error' when multiple NCQ
1954 * commands are outstanding simultaneously.
1955 */
1963 "ahci_claim_free_slot: there is still "
1964 "pending queued command(s) in the "
1965 "command list for another Port Multiplier "
1968 }
1969 }
1974 /* Error retrieval command request */
1976 "ahci_claim_free_slot: slot 0 is allocated for REQUEST "
1981 /*
1982 * An extra check on PxCI. Sometimes PxCI bits may not be
1983 * cleared during hot-plug or error recovery process.
1984 */
1990 "ahci_claim_free_slot: there is still pending "
1991 "command(s) in command list (0x%x/0x%x, PxCI %x),"
1995 port_cmd_issue);
1997 }
2000 "ahci_claim_free_slot: slot 0 is allocated for "
2004 }
2011 }
2013 /*
2014 * According to the AHCI spec, to allow a simple mechanism for the
2015 * HBA to map command list slots to queue entries, software must
2016 * match the tag number it uses to the slot it is placing the command
2017 * in. For example, if a queued command is placed in slot 5, the tag
2018 * for that command must be 5.
2019 */
2025 }
2026 }
2030 out:
2035 }
2037 /*
2038 * Builds the Command Table for the sata packet and delivers it to controller.
2039 *
2040 * Returns:
2041 * slot number if we can obtain a slot successfully
2042 * otherwise, return AHCI_FAILURE
2043 */
2044 static int
2047 {
2059 #if AHCI_DEBUG
2062 #endif
2073 /* Check if the command is a NCQ command */
2078 /*
2079 * When NCQ is support, system software must determine the
2080 * maximum tag allowed by the device and the HBA, and it
2081 * must use a value not beyond of the lower bound of the two.
2082 *
2083 * Sata module is going to calculate the qdepth and send
2084 * down to HBA driver via sata_cmd.
2085 */
2088 /*
2089 * At the moment, the driver doesn't support the dynamic
2090 * setting of the maximum ncq depth, and the value can be
2091 * set either during the attach or after hot-plug insertion.
2092 */
2096 "ahci_deliver_satapkt: port %d the max tags for "
2101 " port %d the max tag for NCQ command is "
2102 "requested to change from %d to %d, at the"
2103 " moment the driver doesn't support the "
2104 "dynamic change so it's going to "
2108 ncq_qdepth);
2109 }
2110 }
2111 }
2113 /* Check if the command is an error retrieval command */
2117 /* Check if the command is an read/write pmult command */
2121 /* Check if there is an empty command slot */
2127 }
2130 "ahci_deliver_satapkt enter: cmd_reg: 0x%x, cmd_slot: 0x%x, "
2137 /* For data transfer operations, it is the H2D Register FIS */
2138 h2d_register_fisp =
2143 /*
2144 * PMP field only make sense when target is a port multiplier or a
2145 * device behind a port multiplier. Otherwise should set it to 0.
2146 */
2158 /*
2159 * satacmd_addr_type will be 0 for the commands below:
2160 * ATAPI command
2161 * SATAC_IDLE_IM
2162 * SATAC_STANDBY_IM
2163 * SATAC_DOWNLOAD_MICROCODE
2164 * SATAC_FLUSH_CACHE
2165 * SATAC_SET_FEATURES
2166 * SATAC_SMART
2167 * SATAC_ID_PACKET_DEVICE
2168 * SATAC_ID_DEVICE
2169 * SATAC_READ_PORTMULT
2170 * SATAC_WRITE_PORTMULT
2171 */
2172 /* FALLTHRU */
2175 /* FALLTHRU */
2178 /* LBA[7:0] */
2181 /* LBA[15:8] */
2184 /* LBA[23:16] */
2187 /* LBA [27:24] (also called dev_head) */
2193 /* LBA[7:0] */
2196 /* LBA[15:8] */
2199 /* LBA[23:16] */
2202 /* LBA [31:24] */
2206 /* LBA [39:32] */
2210 /* LBA [47:40] */
2214 /* Set dev_head */
2218 /* Set the extended sector count and features */
2224 }
2226 /*
2227 * For NCQ command (READ/WRITE FPDMA QUEUED), sector count 7:0 is
2228 * filled into features field, and sector count 8:15 is filled into
2229 * features (exp) field. The hba driver doesn't need to anything
2230 * special with regard to this, since sata framework has already
2231 * done so.
2232 *
2233 * However the driver needs to make sure TAG is filled into sector
2234 * field.
2235 */
2239 }
2249 /* *** now fill the scatter gather list ******* */
2259 }
2265 /* The ACMD field is filled in for ATAPI command */
2268 SATA_ATAPI_MAX_CDB_LEN);
2269 }
2271 /* Set Command Header in Command List */
2276 /* Set the number of entries in the PRD table */
2279 /* Set the length of the command in the CFIS area */
2282 /*
2283 * PMP field only make sense when target is a port multiplier or a
2284 * device behind a port multiplier. Otherwise should set it to 0.
2285 */
2293 /* Set A bit if it is an ATAPI command */
2297 /* Set W bit if data is going to the device */
2301 /*
2302 * Set the prefetchable bit - this bit is only valid if the PRDTL
2303 * field is non-zero or the ATAPI 'A' bit is set in the command
2304 * header. This bit cannot be set when using native command
2305 * queuing commands or when using FIS-based switching with a Port
2306 * multiplier.
2307 */
2311 /*
2312 * Now remember the sata packet in ahciport_slot_pkts[].
2313 * Error retrieval command and r/w port multiplier command will
2314 * be stored specifically for each port.
2315 */
2320 /*
2321 * Keep the timeout value
2322 */
2325 /*
2326 * If the intial timout is less than 1 tick, then make it longer by
2327 * 1 tick to avoid immediate timeout
2328 */
2330 ahci_watchdog_timeout)
2332 ahci_watchdog_timeout;
2334 #if AHCI_DEBUG
2340 /* Dump the command header and table */
2350 /* Dump the H2D register FIS */
2356 /* Dump the ACMD register FIS */
2361 " ATAPI command: %2x %2x %2x %2x "
2368 /* Dump the PRDT */
2374 }
2375 }
2376 #endif
2381 ahci_cmd_table_size,
2382 DDI_DMA_SYNC_FORDEV);
2387 DDI_DMA_SYNC_FORDEV);
2394 DDI_SERVICE_UNAFFECTED);
2396 }
2398 /* Set the corresponding bit in the PxSACT.DS for queued command */
2403 }
2405 /* Indicate to the HBA that a command is active. */
2413 /* Make sure the command is started by the PxSACT/PxCI */
2417 DDI_SERVICE_UNAFFECTED);
2419 }
2422 }
2424 /*
2425 * Called by the sata framework to abort the previously sent packet(s).
2426 *
2427 * Reset device to abort commands.
2428 */
2429 static int
2431 {
2451 /*
2452 * If AHCI_PORT_FLAG_MOPPING flag is set, it means all the pending
2453 * commands are being mopped, therefore there is nothing else to do
2454 */
2457 "ahci_tran_abort: port %d is in "
2461 }
2463 /*
2464 * If AHCI_PORT_FLAG_RDWR_PMULT flag is set, it means a R/W PMULT
2465 * command is being executed so no other commands is outstanding,
2466 * nothing to do.
2467 */
2470 "ahci_tran_abort: port %d is reading/writing "
2474 }
2479 /*
2480 * In case the targer driver would send the request before
2481 * sata framework can have the opportunity to process those
2482 * event reports.
2483 */
2490 "ahci_tran_abort returning SATA_FAILURE while "
2491 "port in FAILED/SHUTDOWN/PWROFF state: "
2495 }
2498 /*
2499 * ahci_intr_phyrdy_change() may have rendered it to
2500 * AHCI_PORT_TYPE_NODEV.
2501 */
2509 "ahci_tran_abort returning SATA_FAILURE while "
2513 }
2525 /*
2526 * Aborting one specific packet, first search the
2527 * ahciport_slot_pkts[] list for matching spkt.
2528 */
2534 }
2535 }
2538 /* request packet is not on the pending list */
2540 "Cannot find the aborting pkt 0x%p on the "
2546 }
2549 }
2561 /*
2562 * To abort the packet(s), first we are trying to clear PxCMD.ST
2563 * to stop the port, and if the port can be stopped
2564 * successfully with PxTFD.STS.BSY and PxTFD.STS.DRQ cleared to '0',
2565 * then we just send back the aborted packet(s) with ABORTED flag
2566 * and then restart the port by setting PxCMD.ST and PxCMD.FRE.
2567 * If PxTFD.STS.BSY or PxTFD.STS.DRQ is set to '1', then we
2568 * perform a COMRESET.
2569 */
2573 /*
2574 * Compute which have finished and which need to be retried.
2575 *
2576 * The finished tags are ahciport_pending_tags/ahciport_pending_ncq_tags
2577 * minus the slot_status. The aborted_tags has to be deducted by
2578 * finished_tags since we can't possibly abort a tag which had finished
2579 * already.
2580 */
2591 ahci_portp,
2592 slot_status,
2595 aborted_tags,
2602 }
2604 /*
2605 * Used to do device reset and reject all the pending packets on a device
2606 * during the reset operation.
2607 *
2608 * NOTE: ONLY called by ahci_tran_reset_dport
2609 */
2610 static int
2613 {
2618 sata_device_t sdevice;
2626 /*
2627 * If AHCI_PORT_FLAG_MOPPING flag is set, it means all the pending
2628 * commands are being mopped, therefore there is nothing else to do
2629 */
2632 "ahci_reset_device_reject_pkts: port %d is in "
2635 }
2645 }
2650 "Try to do a port reset after software "
2655 "ahci_reset_device_reject_pkts: port %d "
2658 }
2659 }
2660 /* Set the reset in progress flag */
2666 /* Indicate to the framework that a reset has happened */
2672 SATA_DSTATE_PWR_ACTIVE;
2677 SATA_EVNT_DEVICE_RESET);
2683 /* Next try to mop the pending commands */
2694 ahci_portp,
2695 slot_status,
2702 }
2704 /*
2705 * Used to do device reset and reject all the pending packets on a device
2706 * during the reset operation.
2707 *
2708 * NOTE: ONLY called by ahci_tran_reset_dport
2709 */
2710 static int
2713 {
2717 sata_device_t sdevice;
2726 "ahci_reset_pmdevice_reject_pkts: port %d is in "
2729 }
2731 /* Checking for outstanding commands */
2740 }
2742 /* Issue SOFTWARE reset command. */
2746 "Try to do a port reset after software "
2749 }
2751 /* Set the reset in progress flag */
2757 /* Indicate to the framework that a reset has happened */
2763 else
2766 SATA_DSTATE_PWR_ACTIVE;
2771 SATA_EVNT_DEVICE_RESET);
2778 /* Next try to mop the pending commands */
2791 /*
2792 * NOTE: Because PxCI be only erased by unset PxCMD.ST bit, so even we
2793 * try to reset a single device behind a port multiplier will
2794 * terminate all the commands on that HBA port. We need mop these
2795 * commands as well.
2796 */
2798 ahci_portp,
2799 slot_status,
2806 }
2808 /*
2809 * Used to do port reset and reject all the pending packets on a port during
2810 * the reset operation.
2811 */
2812 static int
2815 {
2826 /*
2827 * If AHCI_PORT_FLAG_MOPPING flag is set, it means all the pending
2828 * commands are being mopped, therefore there is nothing else to do
2829 */
2832 "ahci_reset_port_reject_pkts: port %d is in "
2835 }
2848 }
2854 /* Clear mop flag */
2860 }
2872 ahci_portp,
2873 slot_status,
2880 }
2882 /*
2883 * Used to do hba reset and reject all the pending packets on all ports
2884 * during the reset operation.
2885 */
2886 static int
2888 {
2906 }
2932 }
2934 }
2938 }
2943 }
2948 /*
2949 * To prevent recursive enter to ahci_mop_commands, we need
2950 * check AHCI_PORT_FLAG_MOPPING flag.
2951 */
2954 "ahci_reset_hba_reject_pkts: port %d is in "
2958 }
2975 ahci_portp,
2982 }
2983 out:
2985 }
2987 /*
2988 * Called by sata framework to reset a port(s) or device.
2989 */
2990 static int
2992 {
2995 ahci_addr_t addr;
3013 /*
3014 * If we want to issue a COMRESET on a pmport, we need to
3015 * reject the outstanding commands on that pmport. According
3016 * to AHCI spec, PxCI register could only be cleared by
3017 * clearing PxCMD.ST, which will halt the controller port - as
3018 * well as other pmports.
3019 *
3020 * Therefore we directly reset the controller port for
3021 * simplicity. ahci_tran_probe_port() will handle reset stuff
3022 * like initializing the given pmport.
3023 */
3024 /* FALLTHRU */
3026 /* Port reset */
3040 /* FALLTHRU */
3042 /* Device reset */
3048 /*
3049 * software reset request must be sent to SATA_PMULT_HOSTPORT
3050 * if target is a port multiplier:
3051 */
3059 /*
3060 * In case the targer driver would send the request
3061 * before sata framework can have the opportunity to
3062 * process those event reports.
3063 */
3067 "ahci_tran_reset_dport returning SATA_FAILURE "
3068 "while port in FAILED/SHUTDOWN/PWROFF state: "
3073 }
3076 SATA_DTYPE_NONE) {
3077 /*
3078 * ahci_intr_phyrdy_change() may have rendered it to
3079 * AHCI_PORT_TYPE_NODEV.
3080 */
3086 "ahci_tran_reset_dport returning SATA_FAILURE "
3091 }
3099 }
3105 /* Reset the whole controller */
3113 }
3116 }
3118 /*
3119 * Called by sata framework to activate a port as part of hotplug.
3120 * (cfgadm -c connect satax/y)
3121 * Support port multiplier.
3122 */
3123 static int
3125 {
3128 ahci_addr_t addr;
3150 /* Enable the interrupts on the port */
3153 /*
3154 * Reset the port so that the PHY communication would be
3155 * re-established. But this reset is an internal operation
3156 * and the sata module doesn't need to know about it.
3157 * Moreover, the port with a device attached will be started
3158 * too.
3159 */
3163 NULL);
3165 /*
3166 * Need to check the link status and device status of the port
3167 * and consider raising power if the port was in D3 state
3168 */
3175 /* AHCI_ADDR_PMPORT */
3179 }
3187 }
3189 /*
3190 * Called by sata framework to deactivate a port as part of hotplug.
3191 * (cfgadm -c disconnect satax/y)
3192 * Support port multiplier.
3193 */
3194 static int
3196 {
3199 ahci_addr_t addr;
3221 /* Disable the interrupts on the port */
3226 /* First to abort all the pending commands */
3229 /* Then stop the port */
3232 }
3234 /* Next put the PHY offline */
3249 /* Re-enable the interrupts for the other pmports */
3251 }
3253 /* Update port state */
3261 }
3263 /*
3264 * To be used to mark all the outstanding pkts with SATA_PKT_ABORTED
3265 * when a device is unplugged or a port is deactivated.
3266 */
3267 static void
3270 {
3279 /* Read/write port multiplier command takes highest priority */
3284 }
3286 /*
3287 * When AHCI_PORT_FLAG_MOPPING is set, we need to check whether a
3288 * REQUEST SENSE command or READ LOG EXT command is delivered to HBA
3289 * to get the error data, if yes when the device is removed, the
3290 * command needs to be aborted too.
3291 */
3299 "ahci_reject_all_abort_pkts return directly "
3300 "port %d no needs to reject any outstanding "
3303 }
3304 }
3314 }
3316 out:
3317 /* No need to do mop when there is no outstanding commands */
3323 ahci_portp,
3324 slot_status,
3329 }
3330 }
3332 #if defined(__lock_lint)
3333 static int
3335 {
3337 }
3338 #endif
3340 /*
3341 * Initialize fma capabilities and register with IO fault services.
3342 */
3343 static void
3345 {
3346 /*
3347 * Need to change iblock to priority for new MSI intr
3348 */
3349 ddi_iblock_cookie_t fm_ibc;
3357 /* Only register with IO Fault Services if we have some capability */
3359 /* Adjust access and dma attributes for FMA */
3366 /*
3367 * Register capabilities with IO Fault Services.
3368 * ahcictl_fm_cap will be updated to indicate
3369 * capabilities actually supported (not requested.)
3370 */
3378 }
3379 /*
3380 * Initialize pci ereport capabilities if ereport
3381 * capable (should always be.)
3382 */
3386 }
3388 /*
3389 * Register error callback if error callback capable.
3390 */
3394 }
3398 }
3399 }
3401 /*
3402 * Releases fma capabilities and un-registers with IO fault services.
3403 */
3404 static void
3406 {
3407 /* Only unregister FMA capabilities if registered */
3409 /*
3410 * Un-register error callback if error callback capable.
3411 */
3414 }
3416 /*
3417 * Release any resources allocated by pci_ereport_setup()
3418 */
3422 }
3424 /* Unregister from IO Fault Services */
3427 /* Adjust access and dma attributes for FMA */
3436 }
3437 }
3439 /*ARGSUSED*/
3440 static int
3442 {
3443 /*
3444 * as the driver can always deal with an error in any dma or
3445 * access handle, we can just return the fme_status value.
3446 */
3449 }
3451 int
3453 {
3454 ddi_fm_error_t de;
3458 }
3460 int
3462 {
3463 ddi_fm_error_t de;
3467 }
3469 /*
3470 * Generate an ereport
3471 */
3472 void
3474 {
3484 }
3485 }
3487 /*
3488 * Check if all handles are correctly allocated.
3489 */
3490 static int
3492 {
3497 }
3511 }
3513 }
3516 }
3518 /*
3519 * Check the access handles for the controller. Note that
3520 * ahcictl_pci_conf_handle is only used in attach process.
3521 */
3522 static int
3524 {
3530 }
3532 }
3534 /*
3535 * Check the DMA handles and the access handles of a controller port.
3536 */
3537 static int
3539 {
3554 }
3559 }
3560 }
3562 }
3564 /*
3565 * Check the DMA handles and the access handles of a cmd table slot.
3566 */
3567 static int
3569 {
3577 }
3579 }
3581 /*
3582 * Allocate the ports structure, only called by ahci_attach
3583 */
3584 static int
3586 {
3594 /* Allocate structures only for the implemented ports */
3600 }
3608 }
3609 }
3614 err_out:
3618 }
3619 }
3623 }
3625 /*
3626 * Reverse of ahci_alloc_ports_state(), only called by ahci_detach
3627 */
3628 static void
3630 {
3635 /* if this port is implemented by the HBA */
3638 }
3640 }
3642 /*
3643 * Drain the taskq.
3644 */
3645 static void
3647 {
3654 }
3661 }
3662 }
3664 /*
3665 * Initialize the controller and all ports. And then try to start the ports
3666 * if there are devices attached.
3667 *
3668 * This routine can be called from three seperate cases: DDI_ATTACH,
3669 * PM_LEVEL_D0 and DDI_RESUME. The DDI_ATTACH case is different from
3670 * other two cases; device signature probing are attempted only during
3671 * DDI_ATTACH case.
3672 */
3673 static int
3675 {
3677 ahci_addr_t addr;
3683 /* Disable the whole controller interrupts */
3688 /* Initialize the implemented ports and structures */
3692 }
3697 /*
3698 * Ensure that the controller is not in the running state
3699 * by checking every implemented port's PxCMD register
3700 */
3706 "ahci_initialize_controller: failed to "
3708 /*
3709 * Set the port state to SATA_PSTATE_FAILED if
3710 * failed to initialize it.
3711 */
3713 }
3716 }
3718 /* Enable the whole controller interrupts */
3724 }
3726 /*
3727 * Reverse of ahci_initialize_controller()
3728 *
3729 * We only need to stop the ports and disable the interrupt.
3730 */
3731 static void
3733 {
3740 /* disable all the interrupts. */
3748 }
3752 /* Stop the port by clearing PxCMD.ST */
3755 /*
3756 * Here we must disable the port interrupt because
3757 * ahci_disable_all_intrs only clear GHC.IE, and IS
3758 * register will be still set if PxIE is enabled.
3759 * When ahci shares one IRQ with other drivers, the
3760 * intr handler may claim the intr mistakenly.
3761 */
3766 }
3767 }
3769 /*
3770 * ahci_alloc_pmult()
3771 * 1. Setting HBA port registers which are necessary for a port multiplier.
3772 * (Set PxCMD.PMA while PxCMD.ST is '0')
3773 * 2. Allocate ahci_pmult_info structure.
3774 *
3775 * NOTE: Must stop port before the function is called.
3776 */
3777 static void
3779 {
3788 /* The port must have been stopped before. */
3792 /* set PMA bit */
3798 "ahci_alloc_pmult: "
3800 }
3802 /* Allocate port multiplier information structure */
3806 }
3809 }
3811 /*
3812 * ahci_dealloc_pmult()
3813 * 1. Clearing related registers when a port multiplier is detached.
3814 * (Clear PxCMD.PMA while PxCMD.ST is '0')
3815 * 2. Deallocate ahci_pmult_info structure.
3816 *
3817 * NOTE: Must stop port before the function is called.
3818 */
3819 static void
3821 {
3831 /* Clear PMA bit */
3837 "ahci_dealloc_pmult: "
3839 }
3841 /* Release port multiplier information structure */
3846 }
3847 }
3849 /*
3850 * Staggered Spin-up.
3851 */
3852 static void
3854 {
3863 /* Check for staggered spin-up support */
3870 /* If PxCMD.SUD == 1, no staggered spin-up is needed */
3876 /* Set PxCMD.SUD */
3880 port_cmd_status);
3881 }
3883 /*
3884 * The routine is to initialize a port. First put the port in NotRunning
3885 * state, then enable port interrupt and clear Serror register. And under
3886 * AHCI_ATTACH case, find device signature and then try to start the port.
3887 *
3888 * Called by
3889 * 1. ahci_initialize_controller
3890 * 2. ahci_intr_phyrdy_change (hotplug)
3891 */
3892 static int
3895 {
3903 /* AHCI_ADDR_PORT: We've no idea of the attached device here. */
3906 /*
3907 * At the time being, only probe ports/devices and get the types of
3908 * attached devices during DDI_ATTACH. In fact, the device can be
3909 * changed during power state changes, but at the time being, we
3910 * don't support the situation.
3911 */
3915 /* check for DDI_RESUME case */
3922 }
3925 /*
3926 * During the resume, we need to set the PxCLB, PxCLBU, PxFB
3927 * and PxFBU registers in case these registers were cleared
3928 * during the suspend.
3929 */
3931 "ahci_initialize_port: port %d "
3932 "set PxCLB, PxCLBU, PxFB and PxFBU "
3936 AHCI_SUCCESS)
3938 }
3946 /*
3947 * Check whether the port is in NotRunning state, if not,
3948 * put the port in NotRunning state
3949 */
3952 AHCI_CMD_STATUS_CR |
3953 AHCI_CMD_STATUS_FRE |
3954 AHCI_CMD_STATUS_FR)) {
3957 }
3959 /* Make sure the drive is spun-up */
3962 /* Disable interrupt */
3965 /* Device is unknown at first */
3968 /* Disable the interface power management */
3976 /* Check physcial link status */
3980 /* Check interface status */
3984 /* Check whether port reset must be executed */
3987 /* Always reset port on RESUME */
3990 /* Something went wrong, we need do some reset things */
3993 /* Does port reset succeed on HBA port? */
3996 "ahci_initialize_port:"
3999 }
4001 /* Is port failed? */
4003 SATA_PSTATE_FAILED) {
4008 }
4009 }
4014 /*
4015 * Try to get the device signature if the port is not empty.
4016 */
4018 SATA_DTYPE_NONE)
4021 /* Return directly if no device connected */
4026 }
4028 /* If this is a port multiplier, we need do some initialization */
4033 }
4035 /* Try to start the port */
4041 }
4042 out:
4043 /* Enable port interrupts */
4047 }
4049 /*
4050 * Handle hardware defect, and check the capabilities. For example,
4051 * power management capabilty and MSI capability.
4052 */
4053 static int
4055 {
4057 #if AHCI_DEBUG
4059 ushort_t msimc;
4060 #endif
4065 PCI_CONF_VENID);
4069 PCI_CONF_DEVID);
4071 /*
4072 * Modify dma_attr_align of ahcictl_buffer_dma_attr. For VT8251, those
4073 * controllers with 0x00 revision id work on 4-byte aligned buffer,
4074 * which is a bug and was fixed after 0x00 revision id controllers.
4075 *
4076 * Moreover, VT8251 cannot use multiple command slots in the command
4077 * list for non-queued commands because the previous register content
4078 * of PxCI can be re-written in the register write, so a flag will be
4079 * set to record this defect - AHCI_CAP_NO_MCMDLIST_NONQUEUE.
4080 *
4081 * For VT8251, software reset also has the same defect as the below
4082 * AMD/ATI chipset. That is, software reset will get failed if 0xf
4083 * is filled in pmport field. Therefore, another software reset need
4084 * to be done with 0 filled in pmport field.
4085 */
4088 PCI_CONF_REVID);
4095 }
4099 "VT8251 cannot use multiple command lists for "
4103 }
4105 /*
4106 * AMD/ATI SB600 (0x1002,0x4380) AHCI chipset doesn't support 64-bit
4107 * DMA addressing for communication memory descriptors though S64A bit
4108 * of CAP register declares it supports. Even though 64-bit DMA for
4109 * data buffer works on ASUS M2A-VM with newer BIOS, three other
4110 * motherboards are known not, so both AHCI_CAP_BUF_32BIT_DMA and
4111 * AHCI_CAP_COMMU_32BIT_DMA are set for this controller.
4112 *
4113 * Due to certain hardware issue, the chipset must do port reset during
4114 * initialization, otherwise, when retrieving device signature,
4115 * software reset will get time out. So AHCI_CAP_INIT_PORT_RESET flag
4116 * need to set.
4117 *
4118 * For this chipset software reset will get failure if the pmport of
4119 * Register FIS was set with SATA_PMULT_HOSTPORT (0xf) and no port
4120 * multiplier is connected to the port. In order to fix the issue,
4121 * AHCI_CAP_SRST_NO_HOSTPORT flag need to be set, and once software
4122 * reset got failure, the driver will try to do another software reset
4123 * with pmport 0.
4124 */
4133 "ATI SB600 cannot do 64-bit DMA for both data buffer and "
4134 "communication memory descriptors though CAP indicates "
4138 NULL);
4140 "ATI SB600 will get software reset failure if pmport "
4142 }
4144 /*
4145 * AMD/ATI SB700/710/750/800 and SP5100 AHCI chipset share the same
4146 * vendor ID and device ID (0x1002,0x4391).
4147 *
4148 * SB700/750 AHCI chipset on some boards doesn't support 64-bit
4149 * DMA addressing for communication memory descriptors though S64A bit
4150 * of CAP register declares the support. However, it does support
4151 * 64-bit DMA for data buffer. So only AHCI_CAP_COMMU_32BIT_DMA is
4152 * set for this controller.
4153 *
4154 * SB710 has the same initialization issue as SB600, so it also need
4155 * a port reset. That is AHCI_CAP_INIT_PORT_RESET need to set for it.
4156 *
4157 * SB700 also has the same issue about software reset, and thus
4158 * AHCI_CAP_SRST_NO_HOSTPORT flag also is needed.
4159 */
4167 "ATI SB700/750 cannot do 64-bit DMA for communication "
4168 "memory descriptors though CAP indicates support, "
4172 NULL);
4174 "ATI SB700 will get software reset failure if pmport "
4176 }
4178 /*
4179 * Check if capabilities list is supported and if so,
4180 * get initial capabilities pointer and clear bits 0,1.
4181 */
4189 }
4191 /*
4192 * Walk capabilities if supported.
4193 */
4196 /*
4197 * Check that we haven't exceeded the maximum number of
4198 * capabilities and that the pointer is in a valid range.
4199 */
4204 }
4208 caps_ptr);
4210 }
4212 /*
4213 * Get next capability and check that it is valid.
4214 * For now, we only support power management.
4215 */
4217 caps_ptr);
4221 /* power management supported */
4224 /* Save PMCSR offset */
4227 #if AHCI_DEBUG
4235 "Power Management capability found PCI_PMCAP "
4239 "PCI Power Management Interface "
4241 #endif
4245 #if AHCI_DEBUG
4250 "Message Signaled Interrupt capability found "
4252 #endif
4286 }
4288 /*
4289 * Get next capabilities pointer and clear bits 0,1.
4290 */
4294 }
4297 }
4299 /*
4300 * Read/Write a register at port multiplier by SATA READ PORTMULT / SATA WRITE
4301 * PORTMULT command. SYNC & POLLING mode is used.
4302 */
4303 static int
4306 {
4308 ahci_addr_t pmult_addr;
4311 sata_device_t sata_device;
4326 /* Check the existence of the port multiplier */
4330 /* Request a READ/WRITE PORTMULT sata packet. */
4337 /*
4338 * Make sure no command is outstanding here. All R/W PMULT requests
4339 * come from
4340 *
4341 * 1. ahci_attach()
4342 * The port should be empty.
4343 *
4344 * 2. ahci_tran_probe_port()
4345 * Any request from SATA framework (via ahci_tran_start) should be
4346 * rejected if R/W PMULT command is outstanding.
4347 *
4348 * If we are doing mopping, do not check those flags because no
4349 * command will be actually outstanding.
4350 *
4351 * If the port has been occupied by any other commands, the probe
4352 * function will return a SATA_RETRY. SATA framework will retry
4353 * later.
4354 */
4360 }
4370 }
4372 /*
4373 * The port multiplier is gone. This may happen when
4374 * 1. Cutting off the power of an enclosure. The device lose the power
4375 * before port multiplier.
4376 * 2. Disconnecting the port multiplier during hot-plugging a sub-drive.
4377 *
4378 * The issued command should be aborted and the following command
4379 * should not be continued.
4380 */
4383 "READ/WRITE PMULT failed: "
4386 }
4393 /*
4394 * READ/WRITE PORTMULT command is intended to sent to the control port
4395 * of the port multiplier.
4396 */
4401 /* No interrupt here. Store the interrupt enable mask. */
4417 }
4419 /* Failed or not completed. */
4425 }
4426 out:
4427 /* Restore the interrupt mask */
4435 }
4437 static int
4440 {
4442 SATA_RDWR_PMULT_PKT_TYPE_READ);
4443 }
4445 static int
4448 {
4450 SATA_RDWR_PMULT_PKT_TYPE_WRITE);
4451 }
4453 #define READ_PMULT(addrp, r, pv, out) \
4454 if (ahci_read_pmult(ahci_ctlp, addrp, r, pv) != AHCI_SUCCESS) \
4455 goto out;
4457 #define WRITE_PMULT(addrp, r, v, out) \
4458 if (ahci_write_pmult(ahci_ctlp, addrp, r, v) != AHCI_SUCCESS) \
4459 goto out;
4461 /*
4462 * Update sata registers on port multiplier, including GSCR/PSCR registers.
4463 * ahci_update_pmult_gscr()
4464 * ahci_update_pmult_pscr()
4465 */
4466 static int
4469 {
4482 }
4484 static int
4487 {
4501 }
4503 /*
4504 * ahci_initialize_pmult()
4505 *
4506 * Initialize a port multiplier, including
4507 * 1. Enable FEATURES register at port multiplier. (SATA Chp.16)
4508 * 2. Redefine MASK register. (SATA Chap 16.?)
4509 */
4510 static int
4513 {
4514 sata_pmult_gscr_t sg;
4523 /*
4524 * Enable features of port multiplier. Currently only
4525 * Asynchronous Notification is enabled.
4526 */
4527 /* Check gscr64 for supported features. */
4532 "port %d: Port Multiplier supports "
4535 /* Write to gscr96 to enabled features */
4541 AHCI_SNOTIF_CLEAR_ALL);
4545 }
4547 /*
4548 * Now we need to update gscr33 register to enable hot-plug interrupt
4549 * for sub devices behind port multiplier.
4550 */
4555 /*
4556 * Fetch the number of device ports of the port multiplier
4557 */
4561 /* Register the port multiplier to SATA Framework. */
4573 /* Till now port-mult is successfully initialized */
4579 }
4581 /*
4582 * Initialize a port multiplier port. According to spec, firstly we need
4583 * issue a COMRESET, then a software reset to get its signature.
4584 *
4585 * NOTE: This function should only be called in ahci_probe_pmport()
4586 */
4587 static int
4590 {
4602 /* Check HBA port state */
4605 "ahci_initialize_pmport:"
4609 }
4613 }
4616 /* Checking for outstanding commands */
4625 }
4630 /* Clear status */
4633 /* Firstly assume an unknown device */
4638 /* port reset is necessary for port multiplier port */
4641 "ahci_initialize_pmport:"
4645 }
4647 /* Is port failed? */
4649 SATA_PSTATE_FAILED) {
4651 "ahci_initialize_pmport: port %d:%d failed. "
4655 }
4657 /* Is there any device attached? */
4660 /* Do not waste time on an empty port */
4662 "ahci_initialize_pmport: No device is found "
4666 }
4672 /*
4673 * Till now we can assure a device attached to that HBA port and work
4674 * correctly. Now try to get the device signature. This is an optional
4675 * step. If failed, unknown device is assumed, then SATA module will
4676 * continue to use IDENTIFY DEVICE to get the information of the
4677 * device.
4678 */
4683 out:
4684 /* Next try to mop the pending commands */
4694 ahci_portp,
4695 slot_status,
4701 /* Clear PxSNTF register if supported. */
4705 AHCI_SNOTIF_CLEAR_ALL);
4706 }
4711 }
4713 /*
4714 * ahci_probe_pmult()
4715 *
4716 * This function will be called to probe a port multiplier, which will
4717 * handle hotplug events on port multiplier ports.
4718 *
4719 * NOTE: Only called from ahci_tran_probe_port()
4720 */
4721 static int
4724 {
4725 sata_device_t sdevice;
4726 ahci_addr_t pmport_addr;
4735 /* The bits in GSCR32 refers to the pmport that has a hot-plug event. */
4742 /* no pending hot plug events. */
4750 /* Check previous device at that port */
4755 /* PxSStatus tells the presence of device. */
4760 SSTATUS_DET_DEVPRE_PHYCOM)
4763 /*
4764 * Clear PxSERR is critical. The transition from 0 to 1 will
4765 * emit a FIS which generates an asynchronous notification
4766 * event at controller. If we fail to clear the PxSERR, the
4767 * Async Notif events will no longer be activated on this
4768 * pmport.
4769 */
4782 dev_exists_now);
4786 /* Link (may) not change: Exist -> Exist * */
4788 "ahci_probe_pmult: port %d:%d "
4795 sata_tran_hba_dip,
4797 SATA_EVNT_LINK_LOST|
4798 SATA_EVNT_LINK_ESTABLISHED);
4801 /* Link change: None -> Exist */
4803 "ahci_probe_pmult: port %d:%d "
4806 /* Clear port state */
4808 SATA_STATE_UNKNOWN);
4810 "ahci_probe_pmult: port %d "
4816 sata_tran_hba_dip,
4818 SATA_EVNT_LINK_ESTABLISHED);
4820 }
4824 /* Link change: Exist -> None */
4826 "ahci_probe_pmult: port %d:%d "
4829 /* An existing device is lost. */
4831 SATA_STATE_UNKNOWN);
4833 SATA_DTYPE_NONE);
4838 sata_tran_hba_dip,
4840 SATA_EVNT_LINK_LOST);
4842 }
4843 }
4852 }
4854 /*
4855 * Probe and initialize a port multiplier port.
4856 * A port multiplier port could only be initilaizer here.
4857 */
4858 static int
4861 {
4864 ahci_addr_t addr_pmult;
4868 /*
4869 * Check the parent - port multiplier first.
4870 */
4872 /*
4873 * Parent port multiplier might have been removed. This event will be
4874 * ignored and failure.
4875 */
4879 "ahci_tran_probe_port: "
4883 }
4885 /* The port is ready? */
4889 "ahci_tran_probe_port: "
4894 AHCI_SUCCESS) {
4896 "ahci_tran_probe_port: "
4899 }
4900 }
4902 /*
4903 * If port-mult is restarted due to some reason, we need
4904 * re-initialized the PMult.
4905 */
4907 /* Initialize registers on a port multiplier */
4912 }
4914 /*
4915 * Then we check the port-mult port
4916 */
4917 /* Is this pmport initialized? */
4921 /* ahci_initialize_pmport() will set READY state */
4925 }
4928 }
4930 /*
4931 * AHCI device reset ...; a single device on one of the ports is reset,
4932 * but the HBA and physical communication remain intact. This is the
4933 * least intrusive.
4934 *
4935 * When issuing a software reset sequence, there should not be other
4936 * commands in the command list, so we will first clear and then re-set
4937 * PxCMD.ST to clear PxCI. And before issuing the software reset,
4938 * the port must be idle and PxTFD.STS.BSY and PxTFD.STS.DRQ must be
4939 * cleared unless command list override (PxCMD.CLO) is supported.
4940 */
4941 static int
4944 {
4959 /* First clear PxCMD.ST (AHCI v1.2 10.4.1) */
4965 }
4967 /* Check PxTFD.STS.BSY and PxTFD.STS.DRQ */
4975 "PxTFD.STS.BSY/DRQ is set (PxTFD=0x%x), "
4978 }
4980 /*
4981 * If HBA Support CLO, as Command List Override (CAP.SCLO is
4982 * set), PxCMD.CLO bit should be set before set PxCMD.ST, in
4983 * order to clear PxTFD.STS.BSY and PxTFD.STS.DRQ.
4984 */
4994 /* Waiting till PxCMD.SCLO bit is cleared */
4997 /* Wait for 10 millisec */
5000 /* We are effectively timing out after 1 sec. */
5005 }
5007 port_cmd_status =
5012 /* Re-check */
5019 port_task_file);
5021 }
5022 }
5024 /* Then start port */
5030 }
5032 /*
5033 * When ahci_port.ahciport_mop_in_progress is set, A non-zero
5034 * ahci_port.ahciport_pending_ncq_tags may fail
5035 * ahci_claim_free_slot(). Actually according to spec, by clearing
5036 * PxCMD.ST there is no command outstanding while executing software
5037 * reseting. Hence we directly use slot 0 instead of
5038 * ahci_claim_free_slot().
5039 */
5042 /* Now send the first H2D Register FIS with SRST set to 1 */
5046 h2d_register_fisp =
5053 /* Set Command Header in Command List */
5066 ahci_cmd_table_size,
5067 DDI_DMA_SYNC_FORDEV);
5072 DDI_DMA_SYNC_FORDEV);
5074 /* Indicate to the HBA that a command is active. */
5081 /* Loop till the first command is finished */
5086 /* We are effectively timing out after 1 sec. */
5089 "the first SRST FIS is timed out, "
5092 }
5093 /* Wait for 10 millisec */
5098 "ahci_software_reset: 1st loop count: %d, "
5102 /* According to ATA spec, we need wait at least 5 microsecs here. */
5105 /* Now send the second H2D Register FIS with SRST cleard to zero */
5109 h2d_register_fisp =
5115 /* Set Command Header in Command List */
5126 ahci_cmd_table_size,
5127 DDI_DMA_SYNC_FORDEV);
5132 DDI_DMA_SYNC_FORDEV);
5134 /* Indicate to the HBA that a command is active. */
5141 /* Loop till the second command is finished */
5146 /* We are effectively timing out after 1 sec. */
5149 "the second SRST FIS is timed out, "
5152 }
5154 /* Wait for 10 millisec */
5159 "ahci_software_reset: 2nd loop count: %d, "
5166 DDI_SERVICE_UNAFFECTED);
5168 }
5171 out:
5178 }
5180 /*
5181 * AHCI port reset ...; the physical communication between the HBA and device
5182 * on a port are disabled. This is more intrusive.
5183 *
5184 * When an HBA or port reset occurs, Phy communication is going to
5185 * be re-established with the device through a COMRESET followed by the
5186 * normal out-of-band communication sequence defined in Serial ATA. At
5187 * the end of reset, the device, if working properly, will send a D2H
5188 * Register FIS, which contains the device signature. When the HBA receives
5189 * this FIS, it updates PxTFD.STS and PxTFD.ERR register fields, and updates
5190 * the PxSIG register with the signature.
5191 *
5192 * NOTE: It is expected both PxCMD.ST and PxCMD.CR are cleared before the
5193 * function is called. If not, it is assumed the interface is in hung
5194 * condition.
5195 */
5196 static int
5199 {
5200 ahci_addr_t pmult_addr;
5212 /* Target is a port multiplier port? */
5216 /* Otherwise it must be an HBA port. */
5226 /*
5227 * According to the spec, SUD bit should be set here,
5228 * but JMicron JMB363 doesn't follow it, so print
5229 * a debug message.
5230 */
5241 port_scontrol);
5243 /* Enable PxCMD.FRE to read device */
5248 /*
5249 * The port enters P:StartComm state, and the HBA tells the link layer
5250 * to start communication, which involves sending COMRESET to the
5251 * device. And the HBA resets PxTFD.STS to 7Fh.
5252 *
5253 * Give time for COMRESET to percolate, according to the AHCI
5254 * spec, software shall wait at least 1 millisecond before
5255 * clearing PxSCTL.DET
5256 */
5259 /* Fetch the SCONTROL again and rewrite the DET part with 0 */
5265 port_scontrol);
5267 /*
5268 * When a COMINIT is received from the device, then the port enters
5269 * P:ComInit state. And HBA sets PxTFD.STS to FFh or 80h. HBA sets
5270 * PxSSTS.DET to 1h to indicate a device is detected but communication
5271 * is not yet established. HBA sets PxSERR.DIAG.X to '1' to indicate
5272 * a COMINIT has been received.
5273 */
5274 /*
5275 * The DET field is valid only if IPM field indicates
5276 * that the interface is in active state.
5277 */
5284 /*
5285 * If the interface is not active, the DET field
5286 * is considered not accurate. So we want to
5287 * continue looping.
5288 */
5290 }
5296 /*
5297 * We are effectively timing out after 0.1 sec.
5298 */
5300 }
5302 /* Wait for 10 millisec */
5304 }
5307 "ahci_port_reset: 1st loop count: %d, "
5312 /*
5313 * Either the port is not active or there
5314 * is no device present.
5315 */
5318 }
5320 /* Clear port serror register for the port */
5323 AHCI_SERROR_CLEAR_ALL);
5325 /*
5326 * Devices should return a FIS contains its signature to HBA after
5327 * COMINIT signal. Check whether a D2H Register FIS is received by
5328 * polling PxTFD.STS.
5329 */
5332 port_task_file =
5341 /*
5342 * We are effectively timing out after 11 sec.
5343 */
5345 "the device hardware has been initialized and "
5350 "port %d: some or all of BSY, DRQ and ERR in "
5351 "PxTFD.STS are not clear. We need another "
5354 /* Clear port serror register for the port */
5357 AHCI_SERROR_CLEAR_ALL);
5361 /* Try another software reset. */
5365 SATA_PSTATE_FAILED);
5367 }
5369 }
5371 /* Wait for 10 millisec */
5373 }
5376 "ahci_port_reset: 2nd loop count: %d, "
5380 /* Clear port serror register for the port */
5383 AHCI_SERROR_CLEAR_ALL);
5385 /* Set port as ready */
5392 }
5394 /*
5395 * COMRESET on a port multiplier port.
5396 *
5397 * NOTE: Only called in ahci_port_reset()
5398 */
5399 static int
5402 {
5414 /* Initialize pmport state */
5421 /* PxCMD.FRE should be set before. */
5428 /*
5429 * Give time for COMRESET to percolate, according to the AHCI
5430 * spec, software shall wait at least 1 millisecond before
5431 * clearing PxSCTL.DET
5432 */
5435 /*
5436 * Fetch the SCONTROL again and rewrite the DET part with 0
5437 * This will generate an Asychronous Notification events.
5438 */
5443 /*
5444 * The port enters P:StartComm state, and HBA tells link layer to
5445 * start communication, which involves sending COMRESET to device.
5446 * And the HBA resets PxTFD.STS to 7Fh.
5447 *
5448 * When a COMINIT is received from the device, then the port enters
5449 * P:ComInit state. And HBA sets PxTFD.STS to FFh or 80h. HBA sets
5450 * PxSSTS.DET to 1h to indicate a device is detected but communication
5451 * is not yet established. HBA sets PxSERR.DIAG.X to '1' to indicate
5452 * a COMINIT has been received.
5453 */
5454 /*
5455 * The DET field is valid only if IPM field indicates
5456 * that the interface is in active state.
5457 */
5463 /*
5464 * If the interface is not active, the DET field
5465 * is considered not accurate. So we want to
5466 * continue looping.
5467 */
5469 }
5472 /*
5473 * We are effectively timing out after 0.1 sec.
5474 */
5476 }
5478 /* Wait for 10 millisec */
5484 "ahci_pmport_reset: 1st loop count: %d, "
5490 /*
5491 * Either the port is not active or there
5492 * is no device present.
5493 */
5495 "ahci_pmport_reset: "
5500 }
5502 /* Now we can make sure there is a device connected to the port */
5503 /* COMINIT signal is supposed to be received (PxSERR.DIAG.X = '1') */
5513 }
5515 /*
5516 * After clear PxSERR register, we will receive a D2H FIS.
5517 * Normally this FIS will cause a IPMS error according to AHCI spec
5518 * v1.2 because there is no command outstanding for it. So we need
5519 * to ignore this error.
5520 */
5524 /* Now we need to check the D2H FIS by checking IPMS error. */
5531 /*
5532 * No D2H FIS received. This is possible according
5533 * to SATA 2.6 spec.
5534 */
5536 "PxIS.IPMS is not set, we need another "
5540 }
5542 /* Wait for 10 millisec */
5550 "ahci_pmport_reset: 2st loop count: %d, "
5554 /* Clear IPMS */
5557 AHCI_INTR_STATUS_IPMS);
5560 /* This pmport is now ready for ahci_tran_start() */
5569 /* IPMS flags might be set before. */
5575 }
5577 /*
5578 * AHCI HBA reset ...; the entire HBA is reset, and all ports are disabled.
5579 * This is the most intrusive.
5580 *
5581 * When an HBA reset occurs, Phy communication will be re-established with
5582 * the device through a COMRESET followed by the normal out-of-band
5583 * communication sequence defined in Serial ATA. At the end of reset, the
5584 * device, if working properly, will send a D2H Register FIS, which contains
5585 * the device signature. When the HBA receives this FIS, it updates PxTFD.STS
5586 * and PxTFD.ERR register fields, and updates the PxSIG register with the
5587 * signature.
5588 *
5589 * Remember to set GHC.AE to 1 before calling ahci_hba_reset.
5590 */
5591 static int
5593 {
5601 NULL);
5608 /* Setting GHC.HR to 1, remember GHC.AE is already set to 1 before */
5613 /*
5614 * Wait until HBA Reset complete or timeout
5615 */
5623 "ahci hba reset is timing out, "
5625 /* We are effectively timing out after 1 sec. */
5627 }
5629 /* Wait for 10 millisec */
5634 "ahci_hba_reset: 1st loop count: %d, "
5638 /* The hba is not reset for some reasons */
5643 }
5645 /*
5646 * HBA reset will clear (AHCI Spec v1.2 10.4.3) GHC.IE / GHC.AE
5647 */
5657 /* Only check implemented ports */
5660 }
5665 /* Make sure the drive is spun-up */
5670 AHCI_SUCCESS) {
5674 /*
5675 * Set the port state to SATA_PSTATE_FAILED if
5676 * failed to initialize it.
5677 */
5679 }
5682 }
5685 }
5687 /*
5688 * This routine is only called from AHCI_ATTACH or phyrdy change
5689 * case. It first calls software reset, then stop the port and try to
5690 * read PxSIG register to find the type of device attached to the port.
5691 *
5692 * The caller should make sure a valid device exists on specified port and
5693 * physical communication has been established so that the signature could
5694 * be retrieved by software reset.
5695 *
5696 * NOTE: The port interrupts should be disabled before the function is called.
5697 */
5698 static void
5701 {
5702 ahci_addr_t dev_addr;
5711 /*
5712 * If the HBA doesn't support port multiplier, then the driver
5713 * doesn't need to bother to check port multiplier device.
5714 *
5715 * The second port of ICH7 on ASUS P5W DH deluxe motherboard is
5716 * connected to Silicon Image 4723, to which the two sata drives
5717 * attached can be set with RAID1, RAID0 or Spanning mode.
5718 *
5719 * We found software reset will get failure if port multiplier address
5720 * 0xf is used by software reset, so just ignore the check since
5721 * ICH7 doesn't support port multiplier device at all.
5722 */
5728 /*
5729 * NOTE: when the ahci address is a HBA port, we do not know
5730 * it is a device or a port multiplier that attached. we need
5731 * try a software reset at port multiplier address (0xf
5732 * pmport)
5733 */
5740 }
5742 /* Assume it is unknown. */
5745 /* Issue a software reset to get the signature */
5749 /*
5750 * Try to do software reset again with pmport set with 0 if
5751 * the controller is set with AHCI_CAP_SRST_NO_HOSTPORT and
5752 * the original pmport is set with SATA_PMULT_HOSTPORT (0xf)
5753 */
5759 }
5763 "ahci_find_dev_signature: software reset failed "
5768 SATA_PSTATE_FAILED);
5770 }
5771 }
5773 /*
5774 * ahci_software_reset has started the port, so we need manually stop
5775 * the port again.
5776 */
5782 port);
5785 }
5786 }
5788 /* Now we can make sure that a valid signature is received. */
5800 }
5802 /* NOTE: Only support ATAPI device at controller port. */
5821 /* Port Multiplier cannot recursively attached. */
5832 }
5833 }
5835 /*
5836 * According to the spec, to reliably detect hot plug removals, software
5837 * must disable interface power management. Software should perform the
5838 * following initialization on a port after a device is attached:
5839 * Set PxSCTL.IPM to 3h to disable interface state transitions
5840 * Set PxCMD.ALPE to '0' to disable aggressive power management
5841 * Disable device initiated interface power management by SET FEATURE
5842 *
5843 * We can ignore the last item because by default the feature is disabled
5844 */
5845 static void
5847 {
5861 }
5863 /*
5864 * Start the port - set PxCMD.ST to 1, if PxCMD.FRE is not set
5865 * to 1, then set it firstly.
5866 *
5867 * Each port contains two major DMA engines. One DMA engine walks through
5868 * the command list, and is controlled by PxCMD.ST. The second DMA engine
5869 * copies received FISes into system memory, and is controlled by PxCMD.FRE.
5870 *
5871 * Software shall not set PxCMD.ST to '1' until it verifies that PxCMD.CR
5872 * is '0' and has set PxCMD.FRE is '1'. And software shall not clear
5873 * PxCMD.FRE while PxCMD.ST or PxCMD.CR is set '1'.
5874 *
5875 * Software shall not set PxCMD.ST to '1' unless a functional device is
5876 * present on the port(as determined by PxTFD.STS.BSY = '0',
5877 * PxTFD.STS.DRQ = '0', and PxSSTS.DET = 3h).
5878 */
5879 static int
5881 {
5893 }
5899 }
5901 /* First to set PxCMD.FRE before setting PxCMD.ST. */
5909 port_cmd_status);
5910 }
5919 port_cmd_status);
5927 }
5929 /*
5930 * Setup PxCLB, PxCLBU, PxFB, and PxFBU for particular port. First, we need
5931 * to make sure PxCMD.ST, PxCMD.CR, PxCMD.FRE, and PxCMD.FR are all cleared.
5932 * Then set PxCLB, PxCLBU, PxFB, and PxFBU.
5933 */
5934 static int
5936 {
5943 /* Step 1: Make sure both PxCMD.ST and PxCMD.CR are cleared. */
5951 }
5953 /* Step 2: Make sure both PxCMD.FRE and PxCMD.FR are cleared. */
5957 /* Clear PxCMD.FRE */
5961 port_cmd_status);
5963 /* Wait until PxCMD.FR is cleared */
5965 port_cmd_status =
5974 "ahci_setup_port_base_addresses: cannot "
5977 /*
5978 * We are effectively timing out after 0.5 sec.
5979 * This value is specified in AHCI spec.
5980 */
5982 }
5984 /* Wait for 1 millisec */
5986 }
5987 }
5989 /* Step 3: Config Port Command List Base Address */
5998 /* Step 4: Config Port Received FIS Base Address */
6008 }
6010 /*
6011 * Allocate the ahci_port_t including Received FIS and Command List.
6012 * The argument - port is the physical port number, and not logical
6013 * port number seen by the SATA framework.
6014 */
6015 static int
6017 {
6024 ahci_portp =
6030 /* Initialize the port condition variable */
6033 /* Initialize the port mutex */
6039 /*
6040 * Allocate memory for received FIS structure and
6041 * command list for this port
6042 */
6045 }
6049 }
6051 /* Setup PxCMD.CLB, PxCMD.CLBU, PxCMD.FB, and PxCMD.FBU */
6053 AHCI_SUCCESS) {
6055 }
6061 /* Create the taskq for the port */
6067 }
6069 /* Allocate the argument for the taskq */
6079 /* Initialize the done queue */
6088 err_case4:
6091 err_case3:
6094 err_case2:
6097 err_case1:
6105 }
6107 /*
6108 * Reverse of ahci_alloc_port_state().
6109 */
6110 static void
6112 {
6136 }
6138 /*
6139 * Allocates memory for the Received FIS Structure
6140 */
6141 static int
6143 {
6146 uint_t cookie_count;
6152 /* allocate rcvd FIS dma handle. */
6155 DDI_DMA_SLEEP,
6156 NULL,
6158 DDI_SUCCESS) {
6163 }
6166 rcvd_fis_size,
6168 DDI_DMA_CONSISTENT,
6169 DDI_DMA_SLEEP,
6170 NULL,
6177 /* error.. free the dma handle. */
6180 }
6183 NULL,
6185 rcvd_fis_size,
6187 DDI_DMA_SLEEP,
6188 NULL,
6194 /* error.. free the dma handle & free the memory. */
6198 }
6208 }
6210 /*
6211 * Deallocates the Received FIS Structure
6212 */
6213 static void
6215 {
6218 /* Unbind the cmd list dma handle first. */
6221 /* Then free the underlying memory. */
6224 /* Now free the handle itself. */
6226 }
6228 /*
6229 * Allocates memory for the Command List, which contains up to 32 entries.
6230 * Each entry contains a command header, which is a 32-byte structure that
6231 * includes the pointer to the command table.
6232 */
6233 static int
6235 {
6238 uint_t cookie_count;
6242 cmd_list_size =
6245 /* allocate cmd list dma handle. */
6248 DDI_DMA_SLEEP,
6249 NULL,
6255 }
6258 cmd_list_size,
6260 DDI_DMA_CONSISTENT,
6261 DDI_DMA_SLEEP,
6262 NULL,
6269 /* error.. free the dma handle. */
6272 }
6275 NULL,
6277 cmd_list_size,
6279 DDI_DMA_SLEEP,
6280 NULL,
6286 /* error.. free the dma handle & free the memory. */
6290 }
6302 }
6306 err_out:
6307 /* Unbind the cmd list dma handle first. */
6310 /* Then free the underlying memory. */
6313 /* Now free the handle itself. */
6317 }
6319 /*
6320 * Deallocates the Command List
6321 */
6322 static void
6324 {
6327 /* First dealloc command table */
6330 /* Unbind the cmd list dma handle first. */
6333 /* Then free the underlying memory. */
6336 /* Now free the handle itself. */
6338 }
6340 /*
6341 * Allocates memory for all Command Tables, which contains Command FIS,
6342 * ATAPI Command and Physical Region Descriptor Table.
6343 */
6344 static int
6346 {
6348 ddi_dma_cookie_t cmd_table_dma_cookie;
6349 uint_t cookie_count;
6359 /* Allocate cmd table dma handle. */
6362 DDI_DMA_SLEEP,
6363 NULL,
6365 DDI_SUCCESS) {
6371 }
6375 ahci_cmd_table_size,
6377 DDI_DMA_CONSISTENT,
6378 DDI_DMA_SLEEP,
6379 NULL,
6388 /* error.. free the dma handle. */
6392 }
6396 NULL,
6398 ahci_cmd_table_size,
6400 DDI_DMA_SLEEP,
6401 NULL,
6407 /* error.. free the dma handle & free the memory. */
6413 }
6416 ahci_cmd_table_size);
6418 /* Config Port Command Table Base Address */
6423 #ifndef __lock_lint
6427 #endif
6428 }
6431 err_out:
6434 /* Unbind the cmd table dma handle first */
6438 /* Then free the underlying memory */
6442 /* Now free the handle itself */
6445 }
6448 }
6450 /*
6451 * Deallocates memory for all Command Tables.
6452 */
6453 static void
6455 {
6465 /* Unbind the cmd table dma handle first. */
6469 /* Then free the underlying memory. */
6473 /* Now free the handle itself. */
6476 }
6477 }
6479 /*
6480 * Update SATA registers at controller ports
6481 */
6482 static void
6485 {
6500 }
6502 /*
6503 * For poll mode, ahci_port_intr will be called to emulate the interrupt
6504 */
6505 static void
6507 {
6516 /* For SATA_OPMODE_POLLING commands */
6517 port_intr_enable =
6519 AHCI_INTR_STATUS_PSS |
6520 AHCI_INTR_STATUS_SDBS |
6521 AHCI_INTR_STATUS_UFS |
6522 AHCI_INTR_STATUS_PCS |
6523 AHCI_INTR_STATUS_PRCS |
6524 AHCI_INTR_STATUS_OFS |
6525 AHCI_INTR_STATUS_INFS |
6526 AHCI_INTR_STATUS_IFS |
6527 AHCI_INTR_STATUS_HBDS |
6528 AHCI_INTR_STATUS_HBFS |
6529 AHCI_INTR_STATUS_TFES);
6531 /*
6532 * port_intr_enable indicates that the corresponding interrrupt
6533 * reporting is enabled.
6534 */
6537 }
6539 /* IPMS error in port reset should be ignored according AHCI spec. */
6544 /*
6545 * port_intr_stats indicates that the corresponding interrupt
6546 * condition is active.
6547 */
6552 "ahci_port_intr: port %d, port_intr_status = 0x%x, "
6558 /*
6559 * Pending interrupt events are indicated by the PxIS register.
6560 * Make sure we don't miss any event.
6561 */
6564 DDI_SERVICE_UNAFFECTED);
6566 DDI_FME_VERSION);
6568 }
6570 /* First clear the port interrupts status */
6573 port_intr_status);
6575 /* Check the completed non-queued commands */
6577 AHCI_INTR_STATUS_PSS)) {
6580 }
6582 /* Check the completed queued commands */
6586 }
6588 /* Check the port connect change status interrupt bit */
6592 }
6594 /* Check the device mechanical presence status interrupt bit */
6598 }
6600 /* Check the PhyRdy change status interrupt bit */
6603 port);
6604 }
6606 /*
6607 * Check the non-fatal error interrupt bits, there are four
6608 * kinds of non-fatal errors at the time being:
6609 *
6610 * PxIS.UFS - Unknown FIS Error
6611 * PxIS.OFS - Overflow Error
6612 * PxIS.INFS - Interface Non-Fatal Error
6613 * PxIS.IPMS - Incorrect Port Multiplier Status Error
6614 *
6615 * For these non-fatal errors, the HBA can continue to operate,
6616 * so the driver just log the error messages.
6617 */
6619 AHCI_INTR_STATUS_OFS |
6620 AHCI_INTR_STATUS_IPMS |
6621 AHCI_INTR_STATUS_INFS)) {
6624 }
6626 /*
6627 * Check the fatal error interrupt bits, there are four kinds
6628 * of fatal errors for AHCI controllers:
6629 *
6630 * PxIS.HBFS - Host Bus Fatal Error
6631 * PxIS.HBDS - Host Bus Data Error
6632 * PxIS.IFS - Interface Fatal Error
6633 * PxIS.TFES - Task File Error
6634 *
6635 * The fatal error means the HBA can not recover from it by
6636 * itself, and it will try to abort the transfer, and the software
6637 * must intervene to restart the port.
6638 */
6640 AHCI_INTR_STATUS_HBDS |
6641 AHCI_INTR_STATUS_HBFS |
6642 AHCI_INTR_STATUS_TFES))
6646 /* Check the cold port detect interrupt bit */
6649 }
6651 /* Second clear the corresponding bit in IS.IPS */
6655 /* Try to recover at the end of the interrupt handler. */
6657 DDI_FM_OK) {
6659 DDI_SERVICE_UNAFFECTED);
6661 DDI_FME_VERSION);
6662 }
6663 }
6665 /*
6666 * Interrupt service handler
6667 */
6668 static uint_t
6670 {
6671 #ifndef __lock_lint
6673 #endif
6674 /* LINTED */
6680 /*
6681 * global_intr_status indicates that the corresponding port has
6682 * an interrupt pending.
6683 */
6688 /* The interrupt is not ours */
6690 }
6692 /*
6693 * Check the handle after reading global_intr_status - we don't want
6694 * to miss any port with pending interrupts.
6695 */
6697 DDI_FM_OK) {
6699 DDI_SERVICE_UNAFFECTED);
6701 DDI_FME_VERSION);
6703 }
6705 /* Loop for all the ports */
6709 }
6712 }
6716 /* Call ahci_port_intr */
6718 }
6721 }
6723 /*
6724 * For non-queued commands, when the corresponding bit in the PxCI register
6725 * is cleared, it means the command is completed successfully. And according
6726 * to the HBA state machine, there are three conditions which possibly will
6727 * try to clear the PxCI register bit.
6728 * 1. Receive one D2H Register FIS which is with 'I' bit set
6729 * 2. Update PIO Setup FIS
6730 * 3. Transmit a command and receive R_OK if CTBA.C is set (software reset)
6731 *
6732 * Process completed non-queued commands when the interrupt status bit -
6733 * AHCI_INTR_STATUS_DHRS or AHCI_INTR_STATUS_PSS is set.
6734 *
6735 * AHCI_INTR_STATUS_DHRS means a D2H Register FIS has been received
6736 * with the 'I' bit set. And the following commands will send thus
6737 * FIS with 'I' bit set upon the successful completion:
6738 * 1. Non-data commands
6739 * 2. DMA data-in command
6740 * 3. DMA data-out command
6741 * 4. PIO data-out command
6742 * 5. PACKET non-data commands
6743 * 6. PACKET PIO data-in command
6744 * 7. PACKET PIO data-out command
6745 * 8. PACKET DMA data-in command
6746 * 9. PACKET DMA data-out command
6747 *
6748 * AHCI_INTR_STATUS_PSS means a PIO Setup FIS has been received
6749 * with the 'I' bit set. And the following commands will send this
6750 * FIS upon the successful completion:
6751 * 1. PIO data-in command
6752 */
6753 static int
6756 {
6762 #if AHCI_DEBUG
6765 #endif
6772 /*
6773 * Spurious interrupt. Nothing to be done.
6774 */
6777 }
6782 /* If the PxCI corrupts, don't complete the commmands. */
6787 }
6790 /* Slot 0 is always used during error recovery */
6793 "ahci_intr_cmd_cmplt: port %d the sata pkt for error "
6799 "ahci_intr_cmd_cmplt: port %d the sata pkt for r/w "
6807 }
6810 "ahci_intr_cmd_cmplt: pending_tags = 0x%x, "
6813 finished_tags);
6821 "ahci_intr_cmd_cmplt: sending up pkt 0x%p "
6826 }
6834 "ahci_intr_cmd_cmplt: sending up pkt 0x%p "
6837 /* READ PORTMULT need copy out FIS content. */
6840 ahcirf_d2h_register_fis);
6844 }
6848 }
6854 }
6858 #if AHCI_DEBUG
6859 /*
6860 * For non-native queued commands, the PRD byte count field
6861 * shall contain an accurate count of the number of bytes
6862 * transferred for the command before the PxCI bit is cleared
6863 * to '0' for the command.
6864 *
6865 * The purpose of this field is to let software know how many
6866 * bytes transferred for a given operation in order to
6867 * determine if underflow occurred. When issuing native command
6868 * queuing commands, this field should not be used and is not
6869 * required to be valid since in this case underflow is always
6870 * illegal.
6871 *
6872 * For data reads, the HBA will update its PRD byte count with
6873 * the total number of bytes received from the last FIS, and
6874 * may be able to continue normally. For data writes, the
6875 * device will detect an error, and HBA most likely will get
6876 * a fatal error.
6877 *
6878 * Therefore, here just put code to debug part. And please
6879 * refer to the comment above ahci_intr_fatal_error for the
6880 * definition of underflow error.
6881 */
6882 cmd_dmacount =
6885 cmd_header =
6888 "ahci_intr_cmd_cmplt: port %d, "
6889 "PRD Byte Count = 0x%x, "
6892 cmd_dmacount);
6896 "ahci_intr_cmd_cmplt: port %d, "
6898 }
6899 }
6900 #endif
6902 /*
6903 * For SATAC_SMART command with SATA_SMART_RETURN_STATUS
6904 * feature, sata_special_regs flag will be set, and the
6905 * driver should copy the status and the other corresponding
6906 * register values in the D2H Register FIS received (It's
6907 * working on Non-data protocol) from the device back to
6908 * the sata_cmd.
6909 *
6910 * For every AHCI port, there is only one Received FIS
6911 * structure, which contains the FISes received from the
6912 * device, So we're trying to copy the content of D2H
6913 * Register FIS in the Received FIS structure back to
6914 * the sata_cmd.
6915 */
6918 ahcirf_d2h_register_fis);
6922 }
6925 "ahci_intr_cmd_cmplt: sending up pkt 0x%p "
6933 }
6934 out:
6944 }
6946 /*
6947 * AHCI_INTR_STATUS_SDBS means a Set Device Bits FIS has been received
6948 * with the 'I' bit set and has been copied into system memory. It will
6949 * be sent under the following situations:
6950 *
6951 * 1. NCQ command is completed
6952 *
6953 * The completion of NCQ commands (READ/WRITE FPDMA QUEUED) is performed
6954 * via the Set Device Bits FIS. When such event is generated, the software
6955 * needs to read PxSACT register and compares the current value to the
6956 * list of commands previously issue by software. ahciport_pending_ncq_tags
6957 * keeps the tags of previously issued commands.
6958 *
6959 * 2. Asynchronous Notification
6960 *
6961 * Asynchronous Notification is a feature in SATA spec 2.6.
6962 *
6963 * 1) ATAPI device will send a signal to the host when media is inserted or
6964 * removed and avoids polling the device for media changes. The signal
6965 * sent to the host is a Set Device Bits FIS with the 'I' and 'N' bits
6966 * set to '1'. At the moment, it's not supported yet.
6967 *
6968 * 2) Port multiplier will send a signal to the host when a hot plug event
6969 * has occured on a port multiplier port. It is used when command based
6970 * switching is employed. This is handled by ahci_intr_pmult_sntf_events()
6971 */
6972 static int
6975 {
6976 ahci_addr_t addr;
6981 /* Initialize HBA port address */
6984 /* NCQ plug handler */
6987 /* Check port multiplier's asynchronous notification events */
6991 }
6993 /* ATAPI events is not supported yet */
6996 }
6997 /*
6998 * NCQ interrupt handler. Called upon a NCQ command is completed.
6999 * Only be called from ahci_intr_set_device_bits().
7000 */
7001 static int
7004 {
7021 }
7023 /*
7024 * First the handler got which commands are finished by checking
7025 * PxSACT register
7026 */
7034 "ahci_intr_set_device_bits: port %d pending_ncq_tags = 0x%x "
7041 /*
7042 * For NCQ commands, the software can determine which command has
7043 * already been transmitted to the device by checking PxCI register.
7044 */
7051 /* If the PxSACT/PxCI corrupts, don't complete the NCQ commmands. */
7056 }
7059 "ahci_intr_set_device_bits: port %d pending_tags = 0x%x "
7066 /*
7067 * Clear ahciport_pending_tags bit when the corresponding command
7068 * is already sent down to the device.
7069 */
7074 }
7077 }
7079 next:
7084 }
7086 /* The command is certainly transmitted to the device */
7094 "ahci_intr_set_device_bits: sending up pkt 0x%p "
7102 }
7103 out:
7105 "ahci_intr_set_device_bits: port %d "
7115 }
7117 /*
7118 * Port multiplier asynchronous notification event handler. Called upon a
7119 * device is hot plugged/pulled.
7120 *
7121 * The async-notification event will only be recorded by ahcipmi_snotif_tags
7122 * here and will be handled by ahci_probe_pmult().
7123 *
7124 * NOTE: called only from ahci_port_intr().
7125 */
7126 static int
7129 {
7130 sata_device_t sdevice;
7135 /* no hot-plug while attaching process */
7140 }
7147 }
7156 AHCI_SNOTIF_CLEAR_ALL);
7161 }
7163 /* Port Multiplier sub-device hot-plug handler */
7167 }
7170 /* Not allowed to re-enter. */
7173 }
7177 /*
7178 * NOTE:
7179 * Even if Asynchronous Notification is supported (and enabled) by
7180 * both controller and the port multiplier, the content of PxSNTF
7181 * register is always set to 0x8000 by async notification event. We
7182 * need to check GSCR[32] on the port multiplier to find out the
7183 * owner of this event.
7184 * This is not accord with SATA spec 2.6 and needs further
7185 * clarification.
7186 */
7187 /* hot-plug will not reported while reseting. */
7194 }
7200 /*
7201 * Now we need do some necessary operation and inform SATA framework
7202 * that link/device events has happened.
7203 */
7211 /* Just reject packets, do not stop that port. */
7218 SATA_EVNT_PMULT_LINK_CHANGED);
7225 }
7227 /*
7228 * 1=Change in Current Connect Status. 0=No change in Current Connect Status.
7229 * This bit reflects the state of PxSERR.DIAG.X. This bit is only cleared
7230 * when PxSERR.DIAG.X is cleared. When PxSERR.DIAG.X is set to one, it
7231 * indicates a COMINIT signal was received.
7232 *
7233 * Hot plug insertion is detected by reception of a COMINIT signal from the
7234 * device. On reception of unsolicited COMINIT, the HBA shall generate a
7235 * COMRESET. If the COMINIT is in responce to a COMRESET, then the HBA shall
7236 * begin the normal communication negotiation sequence as outlined in the
7237 * Serial ATA 1.0a specification. When a COMRESET is sent to the device the
7238 * PxSSTS.DET field shall be cleared to 0h. When a COMINIT is received, the
7239 * PxSSTS.DET field shall be set to 1h. When the communication negotiation
7240 * sequence is complete and PhyRdy is true the PxSSTS.DET field shall be set
7241 * to 3h. Therefore, at the moment the ahci driver is going to check PhyRdy
7242 * to handle hot plug insertion. In this interrupt handler, just do nothing
7243 * but print some log message and clear the bit.
7244 */
7245 static int
7248 {
7249 #if AHCI_DEBUG
7251 #endif
7255 #if AHCI_DEBUG
7260 "ahci_intr_port_connect_change: port %d, "
7262 #endif
7264 /* Clear PxSERR.DIAG.X to clear the interrupt bit */
7267 SERROR_EXCHANGED_ERR);
7272 }
7274 /*
7275 * Hot Plug Operation for platforms that support Mechanical Presence
7276 * Switches.
7277 *
7278 * When set, it indicates that a mechanical presence switch attached to this
7279 * port has been opened or closed, which may lead to a change in the connection
7280 * state of the device. This bit is only valid if both CAP.SMPS and PxCMD.MPSP
7281 * are set to '1'.
7282 *
7283 * At the moment, this interrupt is not needed and disabled and we just log
7284 * the debug message.
7285 */
7286 static int
7289 {
7293 "ahci_intr_device_mechanical_presence_status enter, "
7306 "CAP.SMPS or PxCMD.MPSP is not set, so just ignore "
7307 "the interrupt: cap_status = 0x%x, "
7312 }
7314 #if AHCI_DEBUG
7317 "The mechanical presence switch is open: "
7322 "The mechanical presence switch is close: "
7325 }
7326 #endif
7331 }
7333 /*
7334 * Native Hot Plug Support.
7335 *
7336 * When set, it indicates that the internal PHYRDY signal changed state.
7337 * This bit reflects the state of PxSERR.DIAG.N.
7338 *
7339 * There are three kinds of conditions to generate this interrupt event:
7340 * 1. a device is inserted
7341 * 2. a device is disconnected
7342 * 3. when the link enters/exits a Partial or Slumber interface power
7343 * management state
7344 *
7345 * If inteface power management is enabled for a port, the PxSERR.DIAG.N
7346 * bit may be set due to the link entering the Partial or Slumber power
7347 * management state, rather than due to a hot plug insertion or removal
7348 * event. So far, the interface power management is disabled, so the
7349 * driver can reliably get removal detection notification via the
7350 * PxSERR.DIAG.N bit.
7351 */
7352 static int
7355 {
7357 sata_device_t sdevice;
7360 ahci_addr_t port_addr;
7365 /* Clear PxSERR.DIAG.N to clear the interrupt bit */
7369 SERROR_PHY_RDY_CHG);
7375 /* The whole controller setup is not yet done. */
7378 }
7383 /* SStatus tells the presence of device. */
7389 }
7393 }
7398 "ahci_intr_phyrdy_change: port %d "
7402 }
7416 /* Things are fine now. The loss was temporary. */
7418 "ahci_intr_phyrdy_change port %d "
7430 "ahci_intr_phyrdy_change: port %d "
7433 /*
7434 * A new device has been detected. The new device
7435 * might be a port multiplier instead of a drive, so
7436 * we cannot update the signature directly.
7437 */
7441 /* Try to start the port */
7446 "ahci_intr_phyrdy_change: port %d failed "
7448 }
7450 /* Clear the max queue depth for inserted device */
7457 SATA_EVNT_LINK_ESTABLISHED);
7460 }
7465 "ahci_intr_phyrdy_change: port %d "
7473 SATA_DTYPE_PMULT) {
7475 }
7477 /* An existing device is lost. */
7485 SATA_EVNT_LINK_LOST);
7487 }
7488 }
7494 }
7496 /*
7497 * PxIS.UFS - Unknown FIS Error
7498 *
7499 * This interrupt event means an unknown FIS was received and has been
7500 * copied into system memory. An unknown FIS is not considered an illegal
7501 * FIS, unless the length received is more than 64 bytes. If an unknown
7502 * FIS arrives with length <= 64 bytes, it is posted and the HBA continues
7503 * normal operation. If the unknown FIS is more than 64 bytes, then it
7504 * won't be posted to memory and PxSERR.ERR.P will be set, which is then
7505 * a fatal error.
7506 *
7507 * PxIS.IPMS - Incorrect Port Multiplier Status
7508 *
7509 * IPMS Indicates that the HBA received a FIS from a device that did not
7510 * have a command outstanding. The IPMS bit may be set during enumeration
7511 * of devices on a Port Multiplier due to the normal Port Multiplier
7512 * enumeration process. It is recommended that IPMS only be used after
7513 * enumeration is complete on the Port Multiplier (copied from spec).
7514 *
7515 * PxIS.OFS - Overflow Error
7516 *
7517 * Command list overflow is defined as software building a command table
7518 * that has fewer total bytes than the transaction given to the device.
7519 * On device writes, the HBA will run out of data, and on reads, there
7520 * will be no room to put the data.
7521 *
7522 * For an overflow on data read, either PIO or DMA, the HBA will set
7523 * PxIS.OFS, and the HBA will do a best effort to continue, and it's a
7524 * non-fatal error when the HBA can continues. Sometimes, it will cause
7525 * a fatal error and need the software to do something.
7526 *
7527 * For an overflow on data write, setting PxIS.OFS is optional for both
7528 * DMA and PIO, and it's a fatal error, and a COMRESET is required by
7529 * software to clean up from this serious error.
7530 *
7531 * PxIS.INFS - Interface Non-Fatal Error
7532 *
7533 * This interrupt event indicates that the HBA encountered an error on
7534 * the Serial ATA interface but was able to continue operation. The kind
7535 * of error usually occurred during a non-Data FIS, and under this condition
7536 * the FIS will be re-transmitted by HBA automatically.
7537 *
7538 * When the FMA is implemented, there should be a stat structure to
7539 * record how many every kind of error happens.
7540 */
7541 static int
7544 {
7546 #if AHCI_DEBUG
7555 #endif
7563 "ahci_intr_non_fatal_error: port %d, "
7572 /* Clear the interrupt bit by clearing PxSERR.DIAG.F */
7575 SERROR_FIS_TYPE);
7576 }
7578 #if AHCI_DEBUG
7582 }
7587 }
7592 }
7594 /*
7595 * Record the error occurred command's slot.
7596 */
7603 AHCI_CMD_STATUS_CCS_SHIFT;
7611 }
7615 "ahci_intr_non_fatal_error: pending_tags = 0x%x "
7620 "ahci_intr_non_fatal_error: port %d, "
7624 /*
7625 * PRD Byte Count field of command header is not
7626 * required to reflect the total number of bytes
7627 * transferred when an overflow occurs, so here
7628 * just log the value.
7629 */
7630 cmd_dmacount =
7636 "ahci_intr_non_fatal_error: port %d, "
7637 "PRD Byte Count = 0x%x, "
7640 cmd_dmacount);
7641 }
7642 }
7644 /*
7645 * For queued command, list those command which have already
7646 * been transmitted to the device and still not completed.
7647 */
7655 "ahci_intr_non_fatal_error: pending_ncq_tags = 0x%x "
7668 }
7673 "port %d, satapkt 0x%p is outstanding when "
7677 }
7678 }
7679 out:
7680 #endif
7684 }
7686 /*
7687 * According to the AHCI spec, the error types include system memory
7688 * errors, interface errors, port multiplier errors, device errors,
7689 * command list overflow, command list underflow, native command
7690 * queuing tag errors and pio data transfer errors.
7691 *
7692 * System memory errors such as target abort, master abort, and parity
7693 * may cause the host to stop, and they are serious errors and needed
7694 * to be recovered with software intervention. When system software
7695 * has given a pointer to the HBA that doesn't exist in physical memory,
7696 * a master/target abort error occurs, and PxIS.HBFS will be set. A
7697 * data error such as CRC or parity occurs, the HBA aborts the transfer
7698 * (if necessary) and PxIS.HBDS will be set.
7699 *
7700 * Interface errors are errors that occur due to electrical issues on
7701 * the interface, or protocol miscommunication between the device and
7702 * HBA, and the respective PxSERR register bit will be set. And PxIS.IFS
7703 * (fatal) or PxIS.INFS (non-fatal) will be set. The conditions that
7704 * causes PxIS.IFS/PxIS.INFS to be set are
7705 * 1. in PxSERR.ERR, P bit is set to '1'
7706 * 2. in PxSERR.DIAG, C or H bit is set to '1'
7707 * 3. PhyRdy drop unexpectly, N bit is set to '1'
7708 * If the error occurred during a non-data FIS, the FIS must be
7709 * retransmitted, and the error is non-fatal and PxIS.INFS is set. If
7710 * the error occurred during a data FIS, the transfer will stop, so
7711 * the error is fatal and PxIS.IFS is set.
7712 *
7713 * When a FIS arrives that updates the taskfile, the HBA checks to see
7714 * if PxTFD.STS.ERR is set. If yes, PxIS.TFES will be set and the HBA
7715 * stops processing any more commands.
7716 *
7717 * Command list overflow is defined as software building a command table
7718 * that has fewer total bytes than the transaction given to the device.
7719 * On device writes, the HBA will run out of data, and on reads, there
7720 * will be no room to put the data. For an overflow on data read, either
7721 * PIO or DMA, the HBA will set PxIS.OFS, and it's a non-fatal error.
7722 * For an overflow on data write, setting PxIS.OFS is optional for both
7723 * DMA and PIO, and a COMRESET is required by software to clean up from
7724 * this serious error.
7725 *
7726 * Command list underflow is defined as software building a command
7727 * table that has more total bytes than the transaction given to the
7728 * device. For data writes, both PIO and DMA, the device will detect
7729 * an error and end the transfer. And these errors are most likely going
7730 * to be fatal errors that will cause the port to be restarted. For
7731 * data reads, the HBA updates its PRD byte count, and may be
7732 * able to continue normally, but is not required to. And The HBA is
7733 * not required to detect underflow conditions for native command
7734 * queuing command.
7735 *
7736 * The HBA does not actively check incoming DMA Setup FISes to ensure
7737 * that the PxSACT register bit for that slot is set. Existing error
7738 * mechanisms, such as host bus failure, or bad protocol, are used to
7739 * recover from this case.
7740 *
7741 * In accordance with Serial ATA 1.0a, DATA FISes prior to the final
7742 * DATA FIS must be an integral number of Dwords. If the HBA receives
7743 * a request which is not an integral number of Dwords, the HBA
7744 * set PxSERR.ERR.P to '1', set PxIS.IFS to '1' and stop running until
7745 * software restarts the port. And the HBA ensures that the size
7746 * of the DATA FIS received during a PIO command matches the size in
7747 * the Transfer Cound field of the preceding PIO Setup FIS, if not, the
7748 * HBA sets PxSERR.ERR.P to '1', set PxIS.IFS to '1', and then
7749 * stop running until software restarts the port.
7750 */
7751 /*
7752 * the fatal errors include PxIS.IFS, PxIS.HBDS, PxIS.HBFS and PxIS.TFES.
7753 *
7754 * PxIS.IFS indicates that the hba encountered an error on the serial ata
7755 * interface which caused the transfer to stop.
7756 *
7757 * PxIS.HBDS indicates that the hba encountered a data error
7758 * (uncorrectable ecc/parity) when reading from or writing to system memory.
7759 *
7760 * PxIS.HBFS indicates that the hba encountered a host bus error that it
7761 * cannot recover from, such as a bad software pointer.
7762 *
7763 * PxIS.TFES is set whenever the status register is updated by the device
7764 * and the error bit (bit 0) is set.
7765 */
7766 static int
7769 {
7784 /*
7785 * ahci_intr_phyrdy_change() may have rendered it to
7786 * SATA_DTYPE_NONE.
7787 */
7790 "ahci_intr_fatal_error: port %d no device attached, "
7793 }
7799 "ahci_intr_fatal_error: port %d "
7807 }
7809 /*
7810 * Here we just log the fatal error info in interrupt context.
7811 * Misc recovery processing will be handled in task queue.
7812 */
7815 /*
7816 * Read PxCMD.CCS to determine the slot that the HBA
7817 * was processing when the error occurred.
7818 */
7823 AHCI_CMD_STATUS_CCS_SHIFT;
7828 "ahci_intr_fatal_error: spkt 0x%p is being "
7832 /*
7833 * Won't emit the error message if it is an IDENTIFY
7834 * DEVICE command sent to an ATAPI device.
7835 */
7838 SATAC_ID_DEVICE) &&
7842 /*
7843 * Won't emit the error message if it is an ATAPI PACKET
7844 * command
7845 */
7856 }
7857 }
7859 /* print the fatal error type */
7866 /* print PxSERR related error message */
7869 /* print task file register value */
7877 }
7878 }
7880 out1:
7881 /* Prepare the argument for the taskq */
7888 /* Start the taskq to handle error recovery */
7890 ahci_events_handler,
7895 }
7896 out0:
7900 }
7902 /*
7903 * Hot Plug Operation for platforms that support Cold Presence Detect.
7904 *
7905 * When set, a device status has changed as detected by the cold presence
7906 * detect logic. This bit can either be set due to a non-connected port
7907 * receiving a device, or a connected port having its device removed.
7908 * This bit is only valid if the port supports cold presence detect as
7909 * indicated by PxCMD.CPD set to '1'.
7910 *
7911 * At the moment, this interrupt is not needed and disabled and we just
7912 * log the debug message.
7913 */
7914 static int
7917 {
7919 sata_device_t sdevice;
7930 "port %d does not support cold presence detect, so "
7934 }
7952 SATA_EVNT_DEVICE_ATTACHED);
7962 SATA_EVNT_DEVICE_DETACHED);
7964 }
7969 }
7971 /*
7972 * Enable the interrupts for a particular port.
7973 */
7974 static void
7976 {
7982 /*
7983 * Clear port interrupt status before enabling interrupt
7984 */
7987 AHCI_PORT_INTR_MASK);
7989 /*
7990 * Clear the pending bit from IS.IPS
7991 */
7995 /*
7996 * Enable the following interrupts:
7997 * Device to Host Register FIS Interrupt (DHRS)
7998 * PIO Setup FIS Interrupt (PSS)
7999 * Set Device Bits Interrupt (SDBS)
8000 * Unknown FIS Interrupt (UFS)
8001 * Port Connect Change Status (PCS)
8002 * PhyRdy Change Status (PRCS)
8003 * Overflow Status (OFS)
8004 * Interface Non-fatal Error Status (INFS)
8005 * Interface Fatal Error Status (IFS)
8006 * Host Bus Data Error Status (HBDS)
8007 * Host Bus Fatal Error Status (HBFS)
8008 * Task File Error Status (TFES)
8009 */
8013 AHCI_INTR_STATUS_PSS |
8014 AHCI_INTR_STATUS_SDBS |
8015 AHCI_INTR_STATUS_UFS |
8016 AHCI_INTR_STATUS_DPS |
8017 AHCI_INTR_STATUS_PCS |
8018 AHCI_INTR_STATUS_PRCS |
8019 AHCI_INTR_STATUS_OFS |
8020 AHCI_INTR_STATUS_INFS |
8021 AHCI_INTR_STATUS_IFS |
8022 AHCI_INTR_STATUS_HBDS |
8023 AHCI_INTR_STATUS_HBFS |
8024 AHCI_INTR_STATUS_TFES));
8025 }
8027 /*
8028 * Enable interrupts for all the ports.
8029 */
8030 static void
8032 {
8046 }
8048 /*
8049 * Disable interrupts for a particular port.
8050 */
8051 static void
8053 {
8062 }
8064 /*
8065 * Disable interrupts for the whole HBA.
8066 *
8067 * The global bit is cleared, then all interrupt sources from all
8068 * ports are disabled.
8069 */
8070 static void
8072 {
8079 NULL);
8088 }
8090 /*
8091 * Handle FIXED or MSI interrupts.
8092 */
8093 /*
8094 * According to AHCI spec, the HBA may support several interrupt modes:
8095 * * pin based interrupts (FIXED)
8096 * * single MSI message interrupts
8097 * * multiple MSI based message interrupts
8098 *
8099 * For pin based interrupts, the software interrupt handler need to check IS
8100 * register to find out which port has pending interrupts. And then check
8101 * PxIS register to find out which interrupt events happened on that port.
8102 *
8103 * For single MSI message interrupts, MSICAP.MC.MSIE is set with '1', and
8104 * MSICAP.MC.MME is set with '0'. This mode is similar to pin based interrupts
8105 * in that software interrupt handler need to check IS register to determine
8106 * which port triggered the interrupts since it uses a single message for all
8107 * port interrupts.
8108 *
8109 * HBA may optionally support multiple MSI message for better performance. In
8110 * this mode, each port may have its own interrupt message, and thus generation
8111 * of interrupts is no longer controlled through the IS register. MSICAP.MC.MMC
8112 * represents a power-of-2 wrapper on the number of implemented ports, and
8113 * the mapping of ports to interrupts is done in a 1-1 relationship, up to the
8114 * maximum number of assigned interrupts. When the number of MSI messages
8115 * allocated is less than the number requested, then hardware may have two
8116 * implementation behaviors:
8117 * * assign each ports its own interrupt and then force all additional
8118 * ports to share the last interrupt message, and this condition is
8119 * indicated by clearing GHC.MRSM to '0'
8120 * * revert to single MSI mode, indicated by setting GHC.MRSM to '1'
8121 * When multiple-message MSI is enabled, hardware will still set IS register
8122 * as single message case. And this IS register may be used by software when
8123 * fewer than the requested number of messages is granted in order to determine
8124 * which port had the interrupt.
8125 *
8126 * Note: The current ahci driver only supports the first two interrupt modes:
8127 * pin based interrupts and single MSI message interrupts, and the reason
8128 * is indicated in below code.
8129 */
8130 static int
8132 {
8140 /* get number of interrupts. */
8144 "ddi_intr_get_nintrs() failed, "
8147 }
8149 /* get number of available interrupts. */
8153 "ddi_intr_get_navail() failed, "
8156 }
8158 #if AHCI_DEBUG
8163 }
8164 #endif
8166 /*
8167 * Note: So far Solaris restricts the maximum number of messages for
8168 * x86 to 2, that is avail is 2, so here we set the count with 1 to
8169 * force the driver to use single MSI message interrupt. In future if
8170 * Solaris remove the restriction, then we need to delete the below
8171 * code and try to use multiple interrupt routine to gain better
8172 * performance.
8173 */
8176 "force to use one interrupt routine though the "
8179 }
8181 /* Allocate an array of interrupt handles. */
8186 /* call ddi_intr_alloc(). */
8192 "ddi_intr_alloc() failed, rc %d count %d actual %d "
8197 }
8199 /* use interrupt count returned */
8200 #if AHCI_DEBUG
8204 }
8205 #endif
8209 /*
8210 * Get priority for first, assume remaining are all the same.
8211 */
8217 /* Free already allocated intr. */
8220 }
8225 }
8227 /* Test for high level interrupt. */
8232 /* Free already allocated intr. */
8235 }
8241 }
8243 /* Call ddi_intr_add_handler(). */
8250 /* Free already allocated intr. */
8254 }
8259 }
8260 }
8267 /* Free already allocated intr. */
8271 }
8276 }
8279 /* Call ddi_intr_block_enable() for MSI. */
8283 /* Call ddi_intr_enable() for FIXED or MSI non block enable. */
8287 }
8288 }
8291 }
8293 /*
8294 * Removes the registered interrupts irrespective of whether they
8295 * were legacy or MSI.
8296 *
8297 * NOTE: The controller interrupts must be disabled before calling
8298 * this routine.
8299 */
8300 static void
8302 {
8307 /* Disable all interrupts. */
8310 /* Call ddi_intr_block_disable(). */
8317 }
8318 }
8320 /* Call ddi_intr_remove_handler(). */
8325 }
8328 }
8330 /*
8331 * This routine tries to put port into P:NotRunning state by clearing
8332 * PxCMD.ST. HBA will clear PxCI to 0h, PxSACT to 0h, PxCMD.CCS to 0h
8333 * and PxCMD.CR to '0'.
8334 */
8335 static int
8338 {
8355 /* Wait until PxCMD.CR is cleared */
8358 port_cmd_status =
8364 "clearing port %d CMD.CR timeout, "
8366 port_cmd_status);
8367 /*
8368 * We are effectively timing out after 0.5 sec.
8369 * This value is specified in AHCI spec.
8370 */
8372 }
8374 /* Wait for 10 millisec */
8382 "ahci_put_port_into_notrunning_state: failed to clear "
8383 "PxCMD.CR to '0' after loop count: %d, and "
8388 "ahci_put_port_into_notrunning_state: succeeded to clear "
8389 "PxCMD.CR to '0' after loop count: %d, and "
8392 }
8393 }
8395 /*
8396 * First clear PxCMD.ST, and then check PxTFD. If both PxTFD.STS.BSY
8397 * and PxTFD.STS.DRQ cleared to '0', it means the device is in a
8398 * stable state, then set PxCMD.ST to '1' to start the port directly.
8399 * If PxTFD.STS.BSY or PxTFD.STS.DRQ is set to '1', then issue a
8400 * COMRESET to the device to put it in an idle state.
8401 *
8402 * The fifth argument returns whether the port reset is involved during
8403 * the process.
8404 *
8405 * The routine will be called under following scenarios:
8406 * + To reset the HBA
8407 * + To abort the packet(s)
8408 * + To reset the port
8409 * + To activate the port
8410 * + Fatal error recovery
8411 * + To abort the timeout packet(s)
8412 *
8413 * NOTES!!! During this procedure, PxSERR register will be cleared, and
8414 * according to the spec, the clearance of three bits will also clear
8415 * three interrupt status bits.
8416 * 1. PxSERR.DIAG.F will clear PxIS.UFS
8417 * 2. PxSERR.DIAG.X will clear PxIS.PCS
8418 * 3. PxSERR.DIAG.N will clear PxIS.PRCS
8419 *
8420 * Among these three interrupt events, the driver needs to take care of
8421 * PxIS.PRCS, which is the hot plug event. When the driver found out
8422 * a device was unplugged, it will call the interrupt handler.
8423 */
8424 static int
8427 {
8430 sata_device_t sdevice;
8432 ahci_addr_t addr_port;
8450 /* First clear PxCMD.ST */
8452 port);
8454 /*
8455 * If PxCMD.CR does not clear within a reasonable time, it
8456 * may assume the interface is in a hung condition and may
8457 * continue with issuing the port reset.
8458 */
8461 /* Then clear PxSERR */
8464 AHCI_SERROR_CLEAR_ALL);
8466 /* Then get PxTFD */
8470 /*
8471 * Check whether the device is in a stable status, if yes,
8472 * then start the port directly. However for ahci_tran_reset_dport,
8473 * we may have to perform a port reset.
8474 */
8479 reset:
8480 /*
8481 * If PxTFD.STS.BSY or PxTFD.STS.DRQ is set to '1', then issue
8482 * a COMRESET to the device
8483 */
8488 #ifdef AHCI_DEBUG
8492 port);
8493 #endif
8498 /* Indicate to the framework that a reset has happened. */
8502 /* Set the reset in progress flag */
8512 SATA_DSTATE_PWR_ACTIVE;
8518 SATA_EVNT_DEVICE_RESET);
8520 }
8526 }
8528 out:
8531 /* SStatus tells the presence of device. */
8537 }
8542 /* Check whether a hot plug event happened */
8545 "ahci_restart_port_wait_till_ready: port %d "
8549 "ahci_restart_port_wait_till_ready: port %d "
8556 }
8559 /* 0/1 -> 1 : device may change */
8560 /*
8561 * May be called by ahci_fatal_error_recovery_handler, so
8562 * don't issue software if the previous device is ATAPI.
8563 */
8567 /*
8568 * The COMRESET will make port multiplier enter legacy mode.
8569 * Issue a software reset to make it work again.
8570 */
8575 /*
8576 * Following codes are specific for the port multiplier
8577 */
8580 /* in case previous_dev_type is corrupt */
8584 }
8586 /* Device change: PMult -> Non-PMult */
8589 /*
8590 * This might happen because
8591 * 1. Software reset failed. Port multiplier is not correctly
8592 * enumerated.
8593 * 2. Another non-port-multiplier device is attached. Perhaps
8594 * the port multiplier was replaced by another device by
8595 * whatever reason, but AHCI driver missed hot-plug event.
8596 *
8597 * Now that the port has been initialized, we just need to
8598 * update the port structure according new device, then report
8599 * and wait SATA framework to probe new device.
8600 */
8602 /* Force to release pmult resource */
8613 SATA_DSTATE_PWR_ACTIVE;
8619 SATA_EVNT_DEVICE_RESET);
8628 }
8630 /* Device change: Non-PMult -> PMult */
8633 /* NOTE: The PxCMD.PMA may be cleared by HBA reset. */
8637 }
8641 /* Device (may) change: PMult -> PMult */
8642 /*
8643 * First initialize port multiplier. Set state to READY and wait for
8644 * probe entry point to initialize it
8645 */
8648 /*
8649 * It's a little complicated while target is a port multiplier. we
8650 * need to COMRESET all pmports behind that PMult otherwise those
8651 * sub-links between the PMult and the sub-devices will be in an
8652 * inactive state (indicated by PSCR0/PxSSTS) and the following access
8653 * to those sub-devices will be rejected by Link-Fatal-Error.
8654 */
8655 /*
8656 * The PxSNTF will be set soon after the pmult is plugged. While the
8657 * pmult itself is attaching, sata_hba_event_notfiy will fail. so we
8658 * simply mark every sub-port as 'unknown', then ahci_probe_pmport
8659 * will initialized it.
8660 */
8664 /* Report reset event. */
8673 SATA_EVNT_DEVICE_RESET);
8676 }
8678 /*
8679 * This routine may be called under four scenarios:
8680 * a) do the recovery from fatal error
8681 * b) or we need to timeout some commands
8682 * c) or we need to abort some commands
8683 * d) or we need reset device/port/controller
8684 *
8685 * In all these scenarios, we need to send any pending unfinished
8686 * commands up to sata framework.
8687 */
8688 static void
8696 {
8712 "ahci_mop_commands: failed_tags: 0x%x, "
8713 "timeout_tags: 0x%x aborted_tags: 0x%x, "
8717 #ifdef AHCI_DEBUG
8724 else
8726 }
8733 }
8734 #endif
8759 /*
8760 * When AHCI_PORT_FLAG_RQSENSE or AHCI_PORT_FLAG_RDLOGEXT is
8761 * set, it means REQUEST SENSE or READ LOG EXT command doesn't
8762 * complete successfully due to one of the following three
8763 * conditions:
8764 *
8765 * 1. Fatal error - failed_tags includes its slot
8766 * 2. Timed out - timeout_tags includes its slot
8767 * 3. Aborted when hot unplug - aborted_tags includes its
8768 * slot
8769 *
8770 * Please note that the command is always sent down in Slot 0
8771 */
8774 "ahci_mop_commands is called for port %d while "
8775 "REQUEST SENSE or READ LOG EXT for error retrieval "
8783 "ahci_mop_commands is called for port %d while "
8788 }
8790 #ifdef AHCI_DEBUG
8792 "ahci_mop_commands: finished_tags: 0x%x, "
8794 #endif
8796 /* Send up finished packets with SATA_PKT_COMPLETED */
8801 }
8810 /*
8811 * Cannot fetch the return register content since the port
8812 * was restarted, so the corresponding tag will be set to
8813 * aborted tags.
8814 */
8819 }
8823 tmp_slot);
8829 }
8831 /* Send up failed packets with SATA_PKT_DEV_ERROR. */
8843 }
8848 "ahci_mop_commands: sending up "
8853 }
8858 }
8869 tmp_slot);
8875 }
8877 /* Send up timeout packets with SATA_PKT_TIMEOUT. */
8889 }
8894 "ahci_mop_commands: sending up "
8899 }
8904 }
8915 tmp_slot);
8921 }
8923 /* Send up aborted packets with SATA_PKT_ABORTED */
8935 }
8941 "ahci_mop_commands: sending up "
8946 }
8951 }
8962 tmp_slot);
8968 }
8970 /* Send up reset packets with SATA_PKT_RESET. */
8977 "ahci_mop_commands: sending up "
8982 }
8987 }
8998 tmp_slot);
9004 }
9006 /* Send up unfinished packets with SATA_PKT_RESET */
9011 }
9022 tmp_slot);
9028 }
9037 }
9039 /*
9040 * This routine is going to first request a READ LOG EXT sata pkt from sata
9041 * module, and then deliver it to the HBA to get the ncq failure context.
9042 * The return value is the exactly failed tags.
9043 */
9044 static uint32_t
9047 {
9048 sata_device_t sdevice;
9050 ddi_dma_handle_t buf_dma_handle;
9051 ahci_addr_t addr;
9061 /* Prepare the sdevice data */
9068 /* Translate sata_device.satadev_addr -> ahci_addr */
9071 /*
9072 * Call the sata hba interface to get a rdlog spkt
9073 */
9075 loop:
9080 /* Sleep for a while */
9083 }
9084 /* Timed out after 1s */
9088 }
9092 /*
9093 * This flag is used to handle the specific error recovery when the
9094 * READ LOG EXT command gets a failure (fatal error or time-out).
9095 */
9098 /*
9099 * This start is not supposed to fail because after port is restarted,
9100 * the whole command list is empty.
9101 */
9106 /* Remove the flag after READ LOG EXT command is completed */
9110 /* Update the request log data */
9114 DDI_DMA_SYNC_FORKERNEL);
9116 ncq_err_page =
9120 /* Get the failed tag */
9123 "ahci_get_rdlogext_data: port %d "
9129 }
9140 }
9144 /* Fill out the error context */
9146 ncq_err_page);
9149 }
9150 }
9151 out:
9155 }
9157 /*
9158 * This routine is going to first request a REQUEST SENSE sata pkt from sata
9159 * module, and then deliver it to the HBA to get the sense data and copy
9160 * the sense data back to the orignal failed sata pkt, and free the REQUEST
9161 * SENSE sata pkt later.
9162 */
9163 static void
9166 {
9167 sata_device_t sdevice;
9170 ddi_dma_handle_t buf_dma_handle;
9171 ahci_addr_t addr;
9173 #if AHCI_DEBUG
9175 #endif
9180 /* Prepare the sdevice data */
9187 /* Translate sata_device.satadev_addr -> ahci_addr */
9192 /*
9193 * Call the sata hba interface to get a rs spkt
9194 */
9196 loop:
9201 /* Sleep for a while */
9205 }
9206 /* Timed out after 1s */
9210 }
9214 /*
9215 * This flag is used to handle the specific error recovery when the
9216 * REQUEST SENSE command gets a faiure (fatal error or time-out).
9217 */
9220 /*
9221 * This start is not supposed to fail because after port is restarted,
9222 * the whole command list is empty.
9223 */
9228 /* Remove the flag after REQUEST SENSE command is completed */
9232 /* Update the request sense data */
9236 DDI_DMA_SYNC_FORKERNEL);
9237 /* Copy the request sense data */
9241 SATA_ATAPI_MIN_RQSENSE_LEN);
9242 #if AHCI_DEBUG
9246 /* Dump the sense data */
9252 " es_code 0x%x es_class 0x%x "
9253 "es_key 0x%x es_add_code 0x%x "
9258 #endif
9259 }
9262 }
9264 /*
9265 * Fatal errors will cause the HBA to enter the ERR: Fatal state. To recover,
9266 * the port must be restarted. When the HBA detects thus error, it may try
9267 * to abort a transfer. And if the transfer was aborted, the device is
9268 * expected to send a D2H Register FIS with PxTFD.STS.ERR set to '1' and both
9269 * PxTFD.STS.BSY and PxTFD.STS.DRQ cleared to '0'. Then system software knows
9270 * that the device is in a stable status and transfers may be restarted without
9271 * issuing a COMRESET to the device. If PxTFD.STS.BSY or PxTFD.STS.DRQ is set,
9272 * then the software will send the COMRESET to do the port reset.
9273 *
9274 * Software should perform the appropriate error recovery actions based on
9275 * whether non-queued commands were being issued or natived command queuing
9276 * commands were being issued.
9277 *
9278 * And software will complete the command that had the error with error mark
9279 * to higher level software.
9280 *
9281 * Fatal errors include the following:
9282 * PxIS.IFS - Interface Fatal Error Status
9283 * PxIS.HBDS - Host Bus Data Error Status
9284 * PxIS.HBFS - Host Bus Fatal Error Status
9285 * PxIS.TFES - Task File Error Status
9286 */
9287 static void
9290 {
9299 #if AHCI_DEBUG
9301 #endif
9311 /* Port multiplier error */
9313 /* FBS code is neither completed nor tested. */
9317 /* Force a port reset */
9319 }
9324 /* Read PxCI to see which commands are still outstanding */
9328 /*
9329 * Read PxCMD.CCS to determine the slot that the HBA
9330 * was processing when the error occurred.
9331 */
9335 AHCI_CMD_STATUS_CCS_SHIFT;
9343 /* May happen when interface errors occur? */
9345 }
9346 }
9348 #if AHCI_DEBUG
9349 /*
9350 * Debugging purpose...
9351 */
9353 cmd_header =
9356 "ahci_fatal_error_recovery_handler: port %d, "
9357 "PRD Byte Count = 0x%x, "
9361 }
9362 #endif
9366 /* Fill out the status and error registers for PxIS.TFES */
9369 ahcirf_d2h_register_fis);
9371 /* Copy the error context back to the sata_cmd */
9373 }
9375 /* The failed command must be one of the outstanding commands */
9379 /* Update the sata registers, especially PxSERR register */
9384 /* Read PxSACT to see which commands are still outstanding */
9387 }
9388 next:
9390 #if AHCI_DEBUG
9391 /*
9392 * When AHCI_PORT_FLAG_RQSENSE or AHCI_PORT_FLAG_RDLOGEXT flag is
9393 * set, it means a fatal error happened after REQUEST SENSE command
9394 * or READ LOG EXT command is delivered to the HBA during the error
9395 * recovery process. At this time, the only outstanding command is
9396 * supposed to be REQUEST SENSE command or READ LOG EXT command.
9397 */
9400 "ahci_fatal_error_recovery_handler: port %d REQUEST SENSE "
9401 "command or READ LOG EXT command for error data retrieval "
9406 SCMD_REQUEST_SENSE ||
9408 SATAC_READ_LOG_EXT);
9409 }
9410 #endif
9423 else
9426 }
9428 /*
9429 * Won't retrieve error information:
9430 * 1. Port reset was involved to recover
9431 * 2. Device is gone
9432 * 3. IDENTIFY DEVICE command sent to ATAPI device
9433 * 4. REQUEST SENSE or READ LOG EXT command during error recovery
9434 */
9441 /*
9442 * Deliver READ LOG EXT to gather information about the error when
9443 * a COMRESET has not been performed as part of the error recovery
9444 * during NCQ command processing.
9445 */
9450 }
9452 /*
9453 * Deliver REQUEST SENSE for ATAPI command to gather information about
9454 * the error when a COMRESET has not been performed as part of the
9455 * error recovery.
9456 */
9459 out:
9461 "ahci_fatal_error_recovery_handler: port %d fatal error "
9462 "occurred slot_status = 0x%x, pending_tags = 0x%x, "
9468 ahci_portp,
9469 slot_status,
9474 }
9476 /*
9477 * Used to recovery a PMULT pmport fatal error under FIS-based switching.
9478 * 1. device specific.PxFBS.SDE=1
9479 * 2. Non-Deivce specific.
9480 * Nothing will be done when Command-based switching is employed.
9481 *
9482 * Currently code is neither completed nor tested.
9483 */
9484 static void
9487 {
9488 #ifndef __lock_lint
9490 #endif
9493 ahci_addr_t addr;
9497 /* Nothing will be done under Command-based switching. */
9505 /* FBS is not enabled. */
9508 /* Problem's getting complicated now. */
9509 /*
9510 * If FIS-based switching is used, we need to check
9511 * the PxFBS to see the error type.
9512 */
9516 /* Refer to spec(v1.2) 9.3.6.1 */
9520 /*
9521 * Controller has paused commands for all other
9522 * sub-devices until PxFBS.DEC is set.
9523 */
9531 /*
9532 * Wait controller clear PxFBS.DEC,
9533 * then we can continue.
9534 */
9542 /*
9543 * Esclate the error. Follow
9544 * non-device specific error
9545 * procedure.
9546 */
9552 /*
9553 * Issue a software reset to ensure drive is in
9554 * a known state.
9555 */
9561 /* Process Non-Device Specific Error. */
9562 /* This will be handled later on. */
9564 }
9565 }
9566 /*
9567 * Handle events - fatal error recovery
9568 */
9569 static void
9571 {
9593 /*
9594 * ahci_intr_phyrdy_change() may have rendered it to
9595 * SATA_DTYPE_NONE.
9596 */
9599 "ahci_events_handler: port %d no device attached, "
9607 }
9610 }
9613 AHCI_INTR_STATUS_HBDS |
9614 AHCI_INTR_STATUS_HBFS |
9615 AHCI_INTR_STATUS_TFES))
9619 out:
9621 }
9623 /*
9624 * ahci_watchdog_handler() and ahci_do_sync_start will call us if they
9625 * detect there are some commands which are timed out.
9626 */
9627 static void
9630 {
9643 /* Read PxCI to see which commands are still outstanding */
9647 /* Read PxSACT to see which commands are still outstanding */
9650 }
9652 #if AHCI_DEBUG
9653 /*
9654 * When AHCI_PORT_FLAG_RQSENSE or AHCI_PORT_FLAG_RDLOGEXT flag is
9655 * set, it means a fatal error happened after REQUEST SENSE command
9656 * or READ LOG EXT command is delivered to the HBA during the error
9657 * recovery process. At this time, the only outstanding command is
9658 * supposed to be REQUEST SENSE command or READ LOG EXT command.
9659 */
9662 "ahci_timeout_pkts called while REQUEST SENSE "
9663 "command or READ LOG EXT command for error recovery "
9664 "timed out timeout_tags = 0x%x, slot_status = 0x%x, "
9672 "ahci_timeout_pkts called while executing R/W PMULT "
9676 }
9677 #endif
9685 /*
9686 * Re-identify timeout tags because some previously checked commands
9687 * could already complete.
9688 */
9695 "ahci_timeout_pkts: port %d, finished_tags = 0x%x, "
9696 "timeout_tags = 0x%x, port_cmd_issue = 0x%x, "
9706 "ahci_timeout_pkts: port %d, finished_tags = 0x%x, "
9707 "timeout_tags = 0x%x, port_sactive = 0x%x, "
9714 }
9717 ahci_portp,
9718 slot_status,
9725 }
9727 /*
9728 * Watchdog handler kicks in every 5 seconds to timeout any commands pending
9729 * for long time.
9730 */
9731 static void
9733 {
9754 }
9762 }
9764 /* Skip the check for those ports in error recovery */
9769 }
9780 current_slot =
9782 AHCI_CMD_STATUS_CCS_SHIFT;
9792 }
9799 }
9805 else
9810 /*
9811 * If a packet has survived for more than it's
9812 * max life cycles, it is a candidate for time
9813 * out.
9814 */
9816 ahci_watchdog_timeout;
9822 #if AHCI_DEBUG
9831 }
9832 #endif
9834 /*
9835 * We need to check whether the HBA has
9836 * begun to execute the command, if not,
9837 * then re-set the timer of the command.
9838 */
9843 ahci_portp->ahciport_slot_timeout \
9850 }
9851 }
9852 next:
9854 }
9863 }
9866 }
9868 /* Re-install the watchdog timeout handler */
9873 }
9876 }
9878 /*
9879 * Fill the error context into sata_cmd for non-queued command error.
9880 */
9881 static void
9883 {
9897 }
9898 }
9900 /*
9901 * Fill the ncq error page into sata_cmd for queued command error.
9902 */
9903 static void
9906 {
9918 }
9920 /*
9921 * Put the respective register value to sata_cmd_t for satacmd_flags.
9922 */
9923 static void
9925 {
9946 }
9948 static void
9951 {
9972 }
9974 static void
9977 {
9981 sata_cmd_t cmd;
9990 }
9997 "features_reg = 0x%x sec_count_msb = 0x%x "
9998 "lba_low_msb = 0x%x lba_mid_msb = 0x%x "
9999 "lba_high_msb = 0x%x sec_count_lsb = 0x%x "
10000 "lba_low_lsb = 0x%x lba_mid_lsb = 0x%x "
10001 "lba_high_lsb = 0x%x device_reg = 0x%x "
10012 }
10013 }
10015 /*
10016 * Dump the serror message to the log.
10017 */
10018 static void
10021 {
10032 }
10037 }
10042 }
10047 }
10051 }
10055 }
10059 }
10063 }
10067 }
10071 }
10075 }
10079 }
10083 }
10087 }
10092 }
10096 }
10100 }
10114 /* sata trace debug */
10121 /* sata trace debug */
10123 }
10124 }
10126 /*
10127 * Translate the sata_address_t type into the ahci_addr_t type.
10128 * sata_device.satadev_addr structure is used as source.
10129 */
10130 static void
10133 {
10154 /* something went wrong */
10157 }
10158 }
10160 /*
10161 * This routine is to calculate the total number of ports implemented
10162 * by the HBA.
10163 */
10164 static int
10166 {
10172 num++;
10173 }
10176 }
10178 #if AHCI_DEBUG
10179 static void
10181 {
10193 }
10201 }
10202 #endif
10204 /*
10205 * quiesce(9E) entry point.
10206 *
10207 * This function is called when the system is single-threaded at high
10208 * PIL with preemption disabled. Therefore, this function must not be
10209 * blocked.
10210 *
10211 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
10212 * DDI_FAILURE indicates an error condition and should almost never happen.
10213 */
10214 static int
10216 {
10227 #if AHCI_DEBUG
10229 #endif
10233 /* disable all the interrupts. */
10239 }
10243 /*
10244 * Stop the port by clearing PxCMD.ST
10245 *
10246 * Here we must disable the port interrupt because
10247 * ahci_disable_all_intrs only clear GHC.IE, and IS
10248 * register will be still set if PxIE is enabled.
10249 * When ahci shares one IRQ with other drivers, the
10250 * intr handler may claim the intr mistakenly.
10251 */
10255 }
10260 }
10262 /*
10263 * The function will add a sata packet to the done queue.
10264 */
10265 static void
10267 {
10271 /* set the reason for all packets */
10277 /*
10278 * only add to queue when mode is not synch and there is
10279 * completion callback
10280 */
10288 /*
10289 * for sync/non-poll mode, just call cv_broadcast
10290 */
10292 }
10294 /*
10295 * The function will call completion callback of sata packet on the
10296 * completed queue
10297 */
10298 static void
10300 {
10318 /* Call the callback */
10322 }
10325 }
10326 }