2 * ahci.c - AHCI SATA support
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
8 * Copyright 2004-2005 Red Hat, Inc.
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
26 * libata documentation is available via 'make {ps|pdf}docs',
27 * as Documentation/DocBook/libata.*
29 * AHCI hardware documentation:
30 * http://www.intel.com/technology/serialata/pdf/rev1_0.pdf
31 * http://www.intel.com/technology/serialata/pdf/rev1_1.pdf
35 #include <linux/kernel.h>
36 #include <linux/module.h>
37 #include <linux/pci.h>
38 #include <linux/init.h>
39 #include <linux/blkdev.h>
40 #include <linux/delay.h>
41 #include <linux/interrupt.h>
42 #include <linux/dma-mapping.h>
43 #include <linux/device.h>
44 #include <linux/dmi.h>
45 #include <scsi/scsi_host.h>
46 #include <scsi/scsi_cmnd.h>
47 #include <linux/libata.h>
49 #define DRV_NAME "ahci"
50 #define DRV_VERSION "3.0"
52 /* Enclosure Management Control */
53 #define EM_CTRL_MSG_TYPE 0x000f0000
55 /* Enclosure Management LED Message Type */
56 #define EM_MSG_LED_HBA_PORT 0x0000000f
57 #define EM_MSG_LED_PMP_SLOT 0x0000ff00
58 #define EM_MSG_LED_VALUE 0xffff0000
59 #define EM_MSG_LED_VALUE_ACTIVITY 0x00070000
60 #define EM_MSG_LED_VALUE_OFF 0xfff80000
61 #define EM_MSG_LED_VALUE_ON 0x00010000
63 static int ahci_skip_host_reset
;
64 static int ahci_ignore_sss
;
66 module_param_named(skip_host_reset
, ahci_skip_host_reset
, int, 0444);
67 MODULE_PARM_DESC(skip_host_reset
, "skip global host reset (0=don't skip, 1=skip)");
69 module_param_named(ignore_sss
, ahci_ignore_sss
, int, 0444);
70 MODULE_PARM_DESC(ignore_sss
, "Ignore staggered spinup flag (0=don't ignore, 1=ignore)");
72 static int ahci_enable_alpm(struct ata_port
*ap
,
74 static void ahci_disable_alpm(struct ata_port
*ap
);
75 static ssize_t
ahci_led_show(struct ata_port
*ap
, char *buf
);
76 static ssize_t
ahci_led_store(struct ata_port
*ap
, const char *buf
,
78 static ssize_t
ahci_transmit_led_message(struct ata_port
*ap
, u32 state
,
84 AHCI_MAX_SG
= 168, /* hardware max is 64K */
85 AHCI_DMA_BOUNDARY
= 0xffffffff,
88 AHCI_CMD_SLOT_SZ
= AHCI_MAX_CMDS
* AHCI_CMD_SZ
,
90 AHCI_CMD_TBL_CDB
= 0x40,
91 AHCI_CMD_TBL_HDR_SZ
= 0x80,
92 AHCI_CMD_TBL_SZ
= AHCI_CMD_TBL_HDR_SZ
+ (AHCI_MAX_SG
* 16),
93 AHCI_CMD_TBL_AR_SZ
= AHCI_CMD_TBL_SZ
* AHCI_MAX_CMDS
,
94 AHCI_PORT_PRIV_DMA_SZ
= AHCI_CMD_SLOT_SZ
+ AHCI_CMD_TBL_AR_SZ
+
96 AHCI_IRQ_ON_SG
= (1 << 31),
97 AHCI_CMD_ATAPI
= (1 << 5),
98 AHCI_CMD_WRITE
= (1 << 6),
99 AHCI_CMD_PREFETCH
= (1 << 7),
100 AHCI_CMD_RESET
= (1 << 8),
101 AHCI_CMD_CLR_BUSY
= (1 << 10),
103 RX_FIS_D2H_REG
= 0x40, /* offset of D2H Register FIS data */
104 RX_FIS_SDB
= 0x58, /* offset of SDB FIS data */
105 RX_FIS_UNK
= 0x60, /* offset of Unknown FIS data */
108 board_ahci_vt8251
= 1,
109 board_ahci_ign_iferr
= 2,
110 board_ahci_sb600
= 3,
112 board_ahci_sb700
= 5, /* for SB700 and SB800 */
113 board_ahci_mcp65
= 6,
114 board_ahci_nopmp
= 7,
115 board_ahci_yesncq
= 8,
117 /* global controller registers */
118 HOST_CAP
= 0x00, /* host capabilities */
119 HOST_CTL
= 0x04, /* global host control */
120 HOST_IRQ_STAT
= 0x08, /* interrupt status */
121 HOST_PORTS_IMPL
= 0x0c, /* bitmap of implemented ports */
122 HOST_VERSION
= 0x10, /* AHCI spec. version compliancy */
123 HOST_EM_LOC
= 0x1c, /* Enclosure Management location */
124 HOST_EM_CTL
= 0x20, /* Enclosure Management Control */
125 HOST_CAP2
= 0x24, /* host capabilities, extended */
128 HOST_RESET
= (1 << 0), /* reset controller; self-clear */
129 HOST_IRQ_EN
= (1 << 1), /* global IRQ enable */
130 HOST_AHCI_EN
= (1 << 31), /* AHCI enabled */
133 HOST_CAP_SXS
= (1 << 5), /* Supports External SATA */
134 HOST_CAP_EMS
= (1 << 6), /* Enclosure Management support */
135 HOST_CAP_CCC
= (1 << 7), /* Command Completion Coalescing */
136 HOST_CAP_PART
= (1 << 13), /* Partial state capable */
137 HOST_CAP_SSC
= (1 << 14), /* Slumber state capable */
138 HOST_CAP_PIO_MULTI
= (1 << 15), /* PIO multiple DRQ support */
139 HOST_CAP_FBS
= (1 << 16), /* FIS-based switching support */
140 HOST_CAP_PMP
= (1 << 17), /* Port Multiplier support */
141 HOST_CAP_ONLY
= (1 << 18), /* Supports AHCI mode only */
142 HOST_CAP_CLO
= (1 << 24), /* Command List Override support */
143 HOST_CAP_LED
= (1 << 25), /* Supports activity LED */
144 HOST_CAP_ALPM
= (1 << 26), /* Aggressive Link PM support */
145 HOST_CAP_SSS
= (1 << 27), /* Staggered Spin-up */
146 HOST_CAP_MPS
= (1 << 28), /* Mechanical presence switch */
147 HOST_CAP_SNTF
= (1 << 29), /* SNotification register */
148 HOST_CAP_NCQ
= (1 << 30), /* Native Command Queueing */
149 HOST_CAP_64
= (1 << 31), /* PCI DAC (64-bit DMA) support */
152 HOST_CAP2_BOH
= (1 << 0), /* BIOS/OS handoff supported */
153 HOST_CAP2_NVMHCI
= (1 << 1), /* NVMHCI supported */
154 HOST_CAP2_APST
= (1 << 2), /* Automatic partial to slumber */
156 /* registers for each SATA port */
157 PORT_LST_ADDR
= 0x00, /* command list DMA addr */
158 PORT_LST_ADDR_HI
= 0x04, /* command list DMA addr hi */
159 PORT_FIS_ADDR
= 0x08, /* FIS rx buf addr */
160 PORT_FIS_ADDR_HI
= 0x0c, /* FIS rx buf addr hi */
161 PORT_IRQ_STAT
= 0x10, /* interrupt status */
162 PORT_IRQ_MASK
= 0x14, /* interrupt enable/disable mask */
163 PORT_CMD
= 0x18, /* port command */
164 PORT_TFDATA
= 0x20, /* taskfile data */
165 PORT_SIG
= 0x24, /* device TF signature */
166 PORT_CMD_ISSUE
= 0x38, /* command issue */
167 PORT_SCR_STAT
= 0x28, /* SATA phy register: SStatus */
168 PORT_SCR_CTL
= 0x2c, /* SATA phy register: SControl */
169 PORT_SCR_ERR
= 0x30, /* SATA phy register: SError */
170 PORT_SCR_ACT
= 0x34, /* SATA phy register: SActive */
171 PORT_SCR_NTF
= 0x3c, /* SATA phy register: SNotification */
173 /* PORT_IRQ_{STAT,MASK} bits */
174 PORT_IRQ_COLD_PRES
= (1 << 31), /* cold presence detect */
175 PORT_IRQ_TF_ERR
= (1 << 30), /* task file error */
176 PORT_IRQ_HBUS_ERR
= (1 << 29), /* host bus fatal error */
177 PORT_IRQ_HBUS_DATA_ERR
= (1 << 28), /* host bus data error */
178 PORT_IRQ_IF_ERR
= (1 << 27), /* interface fatal error */
179 PORT_IRQ_IF_NONFATAL
= (1 << 26), /* interface non-fatal error */
180 PORT_IRQ_OVERFLOW
= (1 << 24), /* xfer exhausted available S/G */
181 PORT_IRQ_BAD_PMP
= (1 << 23), /* incorrect port multiplier */
183 PORT_IRQ_PHYRDY
= (1 << 22), /* PhyRdy changed */
184 PORT_IRQ_DEV_ILCK
= (1 << 7), /* device interlock */
185 PORT_IRQ_CONNECT
= (1 << 6), /* port connect change status */
186 PORT_IRQ_SG_DONE
= (1 << 5), /* descriptor processed */
187 PORT_IRQ_UNK_FIS
= (1 << 4), /* unknown FIS rx'd */
188 PORT_IRQ_SDB_FIS
= (1 << 3), /* Set Device Bits FIS rx'd */
189 PORT_IRQ_DMAS_FIS
= (1 << 2), /* DMA Setup FIS rx'd */
190 PORT_IRQ_PIOS_FIS
= (1 << 1), /* PIO Setup FIS rx'd */
191 PORT_IRQ_D2H_REG_FIS
= (1 << 0), /* D2H Register FIS rx'd */
193 PORT_IRQ_FREEZE
= PORT_IRQ_HBUS_ERR
|
199 PORT_IRQ_ERROR
= PORT_IRQ_FREEZE
|
201 PORT_IRQ_HBUS_DATA_ERR
,
202 DEF_PORT_IRQ
= PORT_IRQ_ERROR
| PORT_IRQ_SG_DONE
|
203 PORT_IRQ_SDB_FIS
| PORT_IRQ_DMAS_FIS
|
204 PORT_IRQ_PIOS_FIS
| PORT_IRQ_D2H_REG_FIS
,
207 PORT_CMD_ASP
= (1 << 27), /* Aggressive Slumber/Partial */
208 PORT_CMD_ALPE
= (1 << 26), /* Aggressive Link PM enable */
209 PORT_CMD_ATAPI
= (1 << 24), /* Device is ATAPI */
210 PORT_CMD_PMP
= (1 << 17), /* PMP attached */
211 PORT_CMD_LIST_ON
= (1 << 15), /* cmd list DMA engine running */
212 PORT_CMD_FIS_ON
= (1 << 14), /* FIS DMA engine running */
213 PORT_CMD_FIS_RX
= (1 << 4), /* Enable FIS receive DMA engine */
214 PORT_CMD_CLO
= (1 << 3), /* Command list override */
215 PORT_CMD_POWER_ON
= (1 << 2), /* Power up device */
216 PORT_CMD_SPIN_UP
= (1 << 1), /* Spin up device */
217 PORT_CMD_START
= (1 << 0), /* Enable port DMA engine */
219 PORT_CMD_ICC_MASK
= (0xf << 28), /* i/f ICC state mask */
220 PORT_CMD_ICC_ACTIVE
= (0x1 << 28), /* Put i/f in active state */
221 PORT_CMD_ICC_PARTIAL
= (0x2 << 28), /* Put i/f in partial state */
222 PORT_CMD_ICC_SLUMBER
= (0x6 << 28), /* Put i/f in slumber state */
224 /* hpriv->flags bits */
225 AHCI_HFLAG_NO_NCQ
= (1 << 0),
226 AHCI_HFLAG_IGN_IRQ_IF_ERR
= (1 << 1), /* ignore IRQ_IF_ERR */
227 AHCI_HFLAG_IGN_SERR_INTERNAL
= (1 << 2), /* ignore SERR_INTERNAL */
228 AHCI_HFLAG_32BIT_ONLY
= (1 << 3), /* force 32bit */
229 AHCI_HFLAG_MV_PATA
= (1 << 4), /* PATA port */
230 AHCI_HFLAG_NO_MSI
= (1 << 5), /* no PCI MSI */
231 AHCI_HFLAG_NO_PMP
= (1 << 6), /* no PMP */
232 AHCI_HFLAG_NO_HOTPLUG
= (1 << 7), /* ignore PxSERR.DIAG.N */
233 AHCI_HFLAG_SECT255
= (1 << 8), /* max 255 sectors */
234 AHCI_HFLAG_YES_NCQ
= (1 << 9), /* force NCQ cap on */
235 AHCI_HFLAG_NO_SUSPEND
= (1 << 10), /* don't suspend */
236 AHCI_HFLAG_SRST_TOUT_IS_OFFLINE
= (1 << 11), /* treat SRST timeout as
241 AHCI_FLAG_COMMON
= ATA_FLAG_SATA
| ATA_FLAG_NO_LEGACY
|
242 ATA_FLAG_MMIO
| ATA_FLAG_PIO_DMA
|
243 ATA_FLAG_ACPI_SATA
| ATA_FLAG_AN
|
246 ICH_MAP
= 0x90, /* ICH MAP register */
253 EM_CTL_RST
= (1 << 9), /* Reset */
254 EM_CTL_TM
= (1 << 8), /* Transmit Message */
255 EM_CTL_ALHD
= (1 << 26), /* Activity LED */
258 struct ahci_cmd_hdr
{
273 struct ahci_em_priv
{
274 enum sw_activity blink_policy
;
275 struct timer_list timer
;
276 unsigned long saved_activity
;
277 unsigned long activity
;
278 unsigned long led_state
;
281 struct ahci_host_priv
{
282 unsigned int flags
; /* AHCI_HFLAG_* */
283 u32 cap
; /* cap to use */
284 u32 cap2
; /* cap2 to use */
285 u32 port_map
; /* port map to use */
286 u32 saved_cap
; /* saved initial cap */
287 u32 saved_cap2
; /* saved initial cap2 */
288 u32 saved_port_map
; /* saved initial port_map */
289 u32 em_loc
; /* enclosure management location */
292 struct ahci_port_priv
{
293 struct ata_link
*active_link
;
294 struct ahci_cmd_hdr
*cmd_slot
;
295 dma_addr_t cmd_slot_dma
;
297 dma_addr_t cmd_tbl_dma
;
299 dma_addr_t rx_fis_dma
;
300 /* for NCQ spurious interrupt analysis */
301 unsigned int ncq_saw_d2h
:1;
302 unsigned int ncq_saw_dmas
:1;
303 unsigned int ncq_saw_sdb
:1;
304 u32 intr_mask
; /* interrupts to enable */
305 /* enclosure management info per PM slot */
306 struct ahci_em_priv em_priv
[EM_MAX_SLOTS
];
309 static int ahci_scr_read(struct ata_link
*link
, unsigned int sc_reg
, u32
*val
);
310 static int ahci_scr_write(struct ata_link
*link
, unsigned int sc_reg
, u32 val
);
311 static int ahci_init_one(struct pci_dev
*pdev
, const struct pci_device_id
*ent
);
312 static unsigned int ahci_qc_issue(struct ata_queued_cmd
*qc
);
313 static bool ahci_qc_fill_rtf(struct ata_queued_cmd
*qc
);
314 static int ahci_port_start(struct ata_port
*ap
);
315 static void ahci_port_stop(struct ata_port
*ap
);
316 static void ahci_qc_prep(struct ata_queued_cmd
*qc
);
317 static void ahci_freeze(struct ata_port
*ap
);
318 static void ahci_thaw(struct ata_port
*ap
);
319 static void ahci_pmp_attach(struct ata_port
*ap
);
320 static void ahci_pmp_detach(struct ata_port
*ap
);
321 static int ahci_softreset(struct ata_link
*link
, unsigned int *class,
322 unsigned long deadline
);
323 static int ahci_sb600_softreset(struct ata_link
*link
, unsigned int *class,
324 unsigned long deadline
);
325 static int ahci_hardreset(struct ata_link
*link
, unsigned int *class,
326 unsigned long deadline
);
327 static int ahci_vt8251_hardreset(struct ata_link
*link
, unsigned int *class,
328 unsigned long deadline
);
329 static int ahci_p5wdh_hardreset(struct ata_link
*link
, unsigned int *class,
330 unsigned long deadline
);
331 static void ahci_postreset(struct ata_link
*link
, unsigned int *class);
332 static void ahci_error_handler(struct ata_port
*ap
);
333 static void ahci_post_internal_cmd(struct ata_queued_cmd
*qc
);
334 static int ahci_port_resume(struct ata_port
*ap
);
335 static void ahci_dev_config(struct ata_device
*dev
);
336 static void ahci_fill_cmd_slot(struct ahci_port_priv
*pp
, unsigned int tag
,
339 static int ahci_port_suspend(struct ata_port
*ap
, pm_message_t mesg
);
340 static int ahci_pci_device_suspend(struct pci_dev
*pdev
, pm_message_t mesg
);
341 static int ahci_pci_device_resume(struct pci_dev
*pdev
);
343 static ssize_t
ahci_activity_show(struct ata_device
*dev
, char *buf
);
344 static ssize_t
ahci_activity_store(struct ata_device
*dev
,
345 enum sw_activity val
);
346 static void ahci_init_sw_activity(struct ata_link
*link
);
348 static ssize_t
ahci_show_host_caps(struct device
*dev
,
349 struct device_attribute
*attr
, char *buf
);
350 static ssize_t
ahci_show_host_cap2(struct device
*dev
,
351 struct device_attribute
*attr
, char *buf
);
352 static ssize_t
ahci_show_host_version(struct device
*dev
,
353 struct device_attribute
*attr
, char *buf
);
354 static ssize_t
ahci_show_port_cmd(struct device
*dev
,
355 struct device_attribute
*attr
, char *buf
);
357 DEVICE_ATTR(ahci_host_caps
, S_IRUGO
, ahci_show_host_caps
, NULL
);
358 DEVICE_ATTR(ahci_host_cap2
, S_IRUGO
, ahci_show_host_cap2
, NULL
);
359 DEVICE_ATTR(ahci_host_version
, S_IRUGO
, ahci_show_host_version
, NULL
);
360 DEVICE_ATTR(ahci_port_cmd
, S_IRUGO
, ahci_show_port_cmd
, NULL
);
362 static struct device_attribute
*ahci_shost_attrs
[] = {
363 &dev_attr_link_power_management_policy
,
364 &dev_attr_em_message_type
,
365 &dev_attr_em_message
,
366 &dev_attr_ahci_host_caps
,
367 &dev_attr_ahci_host_cap2
,
368 &dev_attr_ahci_host_version
,
369 &dev_attr_ahci_port_cmd
,
373 static struct device_attribute
*ahci_sdev_attrs
[] = {
374 &dev_attr_sw_activity
,
375 &dev_attr_unload_heads
,
379 static struct scsi_host_template ahci_sht
= {
380 ATA_NCQ_SHT(DRV_NAME
),
381 .can_queue
= AHCI_MAX_CMDS
- 1,
382 .sg_tablesize
= AHCI_MAX_SG
,
383 .dma_boundary
= AHCI_DMA_BOUNDARY
,
384 .shost_attrs
= ahci_shost_attrs
,
385 .sdev_attrs
= ahci_sdev_attrs
,
388 static struct ata_port_operations ahci_ops
= {
389 .inherits
= &sata_pmp_port_ops
,
391 .qc_defer
= sata_pmp_qc_defer_cmd_switch
,
392 .qc_prep
= ahci_qc_prep
,
393 .qc_issue
= ahci_qc_issue
,
394 .qc_fill_rtf
= ahci_qc_fill_rtf
,
396 .freeze
= ahci_freeze
,
398 .softreset
= ahci_softreset
,
399 .hardreset
= ahci_hardreset
,
400 .postreset
= ahci_postreset
,
401 .pmp_softreset
= ahci_softreset
,
402 .error_handler
= ahci_error_handler
,
403 .post_internal_cmd
= ahci_post_internal_cmd
,
404 .dev_config
= ahci_dev_config
,
406 .scr_read
= ahci_scr_read
,
407 .scr_write
= ahci_scr_write
,
408 .pmp_attach
= ahci_pmp_attach
,
409 .pmp_detach
= ahci_pmp_detach
,
411 .enable_pm
= ahci_enable_alpm
,
412 .disable_pm
= ahci_disable_alpm
,
413 .em_show
= ahci_led_show
,
414 .em_store
= ahci_led_store
,
415 .sw_activity_show
= ahci_activity_show
,
416 .sw_activity_store
= ahci_activity_store
,
418 .port_suspend
= ahci_port_suspend
,
419 .port_resume
= ahci_port_resume
,
421 .port_start
= ahci_port_start
,
422 .port_stop
= ahci_port_stop
,
425 static struct ata_port_operations ahci_vt8251_ops
= {
426 .inherits
= &ahci_ops
,
427 .hardreset
= ahci_vt8251_hardreset
,
430 static struct ata_port_operations ahci_p5wdh_ops
= {
431 .inherits
= &ahci_ops
,
432 .hardreset
= ahci_p5wdh_hardreset
,
435 static struct ata_port_operations ahci_sb600_ops
= {
436 .inherits
= &ahci_ops
,
437 .softreset
= ahci_sb600_softreset
,
438 .pmp_softreset
= ahci_sb600_softreset
,
441 #define AHCI_HFLAGS(flags) .private_data = (void *)(flags)
443 static const struct ata_port_info ahci_port_info
[] = {
446 .flags
= AHCI_FLAG_COMMON
,
447 .pio_mask
= ATA_PIO4
,
448 .udma_mask
= ATA_UDMA6
,
449 .port_ops
= &ahci_ops
,
451 [board_ahci_vt8251
] =
453 AHCI_HFLAGS (AHCI_HFLAG_NO_NCQ
| AHCI_HFLAG_NO_PMP
),
454 .flags
= AHCI_FLAG_COMMON
,
455 .pio_mask
= ATA_PIO4
,
456 .udma_mask
= ATA_UDMA6
,
457 .port_ops
= &ahci_vt8251_ops
,
459 [board_ahci_ign_iferr
] =
461 AHCI_HFLAGS (AHCI_HFLAG_IGN_IRQ_IF_ERR
),
462 .flags
= AHCI_FLAG_COMMON
,
463 .pio_mask
= ATA_PIO4
,
464 .udma_mask
= ATA_UDMA6
,
465 .port_ops
= &ahci_ops
,
469 AHCI_HFLAGS (AHCI_HFLAG_IGN_SERR_INTERNAL
|
470 AHCI_HFLAG_NO_MSI
| AHCI_HFLAG_SECT255
|
471 AHCI_HFLAG_32BIT_ONLY
),
472 .flags
= AHCI_FLAG_COMMON
,
473 .pio_mask
= ATA_PIO4
,
474 .udma_mask
= ATA_UDMA6
,
475 .port_ops
= &ahci_sb600_ops
,
479 AHCI_HFLAGS (AHCI_HFLAG_NO_NCQ
| AHCI_HFLAG_NO_MSI
|
480 AHCI_HFLAG_MV_PATA
| AHCI_HFLAG_NO_PMP
),
481 .flags
= ATA_FLAG_SATA
| ATA_FLAG_NO_LEGACY
|
482 ATA_FLAG_MMIO
| ATA_FLAG_PIO_DMA
,
483 .pio_mask
= ATA_PIO4
,
484 .udma_mask
= ATA_UDMA6
,
485 .port_ops
= &ahci_ops
,
487 [board_ahci_sb700
] = /* for SB700 and SB800 */
489 AHCI_HFLAGS (AHCI_HFLAG_IGN_SERR_INTERNAL
),
490 .flags
= AHCI_FLAG_COMMON
,
491 .pio_mask
= ATA_PIO4
,
492 .udma_mask
= ATA_UDMA6
,
493 .port_ops
= &ahci_sb600_ops
,
497 AHCI_HFLAGS (AHCI_HFLAG_YES_NCQ
),
498 .flags
= AHCI_FLAG_COMMON
,
499 .pio_mask
= ATA_PIO4
,
500 .udma_mask
= ATA_UDMA6
,
501 .port_ops
= &ahci_ops
,
505 AHCI_HFLAGS (AHCI_HFLAG_NO_PMP
),
506 .flags
= AHCI_FLAG_COMMON
,
507 .pio_mask
= ATA_PIO4
,
508 .udma_mask
= ATA_UDMA6
,
509 .port_ops
= &ahci_ops
,
511 /* board_ahci_yesncq */
513 AHCI_HFLAGS (AHCI_HFLAG_YES_NCQ
),
514 .flags
= AHCI_FLAG_COMMON
,
515 .pio_mask
= ATA_PIO4
,
516 .udma_mask
= ATA_UDMA6
,
517 .port_ops
= &ahci_ops
,
521 static const struct pci_device_id ahci_pci_tbl
[] = {
523 { PCI_VDEVICE(INTEL
, 0x2652), board_ahci
}, /* ICH6 */
524 { PCI_VDEVICE(INTEL
, 0x2653), board_ahci
}, /* ICH6M */
525 { PCI_VDEVICE(INTEL
, 0x27c1), board_ahci
}, /* ICH7 */
526 { PCI_VDEVICE(INTEL
, 0x27c5), board_ahci
}, /* ICH7M */
527 { PCI_VDEVICE(INTEL
, 0x27c3), board_ahci
}, /* ICH7R */
528 { PCI_VDEVICE(AL
, 0x5288), board_ahci_ign_iferr
}, /* ULi M5288 */
529 { PCI_VDEVICE(INTEL
, 0x2681), board_ahci
}, /* ESB2 */
530 { PCI_VDEVICE(INTEL
, 0x2682), board_ahci
}, /* ESB2 */
531 { PCI_VDEVICE(INTEL
, 0x2683), board_ahci
}, /* ESB2 */
532 { PCI_VDEVICE(INTEL
, 0x27c6), board_ahci
}, /* ICH7-M DH */
533 { PCI_VDEVICE(INTEL
, 0x2821), board_ahci
}, /* ICH8 */
534 { PCI_VDEVICE(INTEL
, 0x2822), board_ahci
}, /* ICH8 */
535 { PCI_VDEVICE(INTEL
, 0x2824), board_ahci
}, /* ICH8 */
536 { PCI_VDEVICE(INTEL
, 0x2829), board_ahci
}, /* ICH8M */
537 { PCI_VDEVICE(INTEL
, 0x282a), board_ahci
}, /* ICH8M */
538 { PCI_VDEVICE(INTEL
, 0x2922), board_ahci
}, /* ICH9 */
539 { PCI_VDEVICE(INTEL
, 0x2923), board_ahci
}, /* ICH9 */
540 { PCI_VDEVICE(INTEL
, 0x2924), board_ahci
}, /* ICH9 */
541 { PCI_VDEVICE(INTEL
, 0x2925), board_ahci
}, /* ICH9 */
542 { PCI_VDEVICE(INTEL
, 0x2927), board_ahci
}, /* ICH9 */
543 { PCI_VDEVICE(INTEL
, 0x2929), board_ahci
}, /* ICH9M */
544 { PCI_VDEVICE(INTEL
, 0x292a), board_ahci
}, /* ICH9M */
545 { PCI_VDEVICE(INTEL
, 0x292b), board_ahci
}, /* ICH9M */
546 { PCI_VDEVICE(INTEL
, 0x292c), board_ahci
}, /* ICH9M */
547 { PCI_VDEVICE(INTEL
, 0x292f), board_ahci
}, /* ICH9M */
548 { PCI_VDEVICE(INTEL
, 0x294d), board_ahci
}, /* ICH9 */
549 { PCI_VDEVICE(INTEL
, 0x294e), board_ahci
}, /* ICH9M */
550 { PCI_VDEVICE(INTEL
, 0x502a), board_ahci
}, /* Tolapai */
551 { PCI_VDEVICE(INTEL
, 0x502b), board_ahci
}, /* Tolapai */
552 { PCI_VDEVICE(INTEL
, 0x3a05), board_ahci
}, /* ICH10 */
553 { PCI_VDEVICE(INTEL
, 0x3a22), board_ahci
}, /* ICH10 */
554 { PCI_VDEVICE(INTEL
, 0x3a25), board_ahci
}, /* ICH10 */
555 { PCI_VDEVICE(INTEL
, 0x3b22), board_ahci
}, /* PCH AHCI */
556 { PCI_VDEVICE(INTEL
, 0x3b23), board_ahci
}, /* PCH AHCI */
557 { PCI_VDEVICE(INTEL
, 0x3b24), board_ahci
}, /* PCH RAID */
558 { PCI_VDEVICE(INTEL
, 0x3b25), board_ahci
}, /* PCH RAID */
559 { PCI_VDEVICE(INTEL
, 0x3b29), board_ahci
}, /* PCH AHCI */
560 { PCI_VDEVICE(INTEL
, 0x3b2b), board_ahci
}, /* PCH RAID */
561 { PCI_VDEVICE(INTEL
, 0x3b2c), board_ahci
}, /* PCH RAID */
562 { PCI_VDEVICE(INTEL
, 0x3b2f), board_ahci
}, /* PCH AHCI */
564 /* JMicron 360/1/3/5/6, match class to avoid IDE function */
565 { PCI_VENDOR_ID_JMICRON
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
,
566 PCI_CLASS_STORAGE_SATA_AHCI
, 0xffffff, board_ahci_ign_iferr
},
569 { PCI_VDEVICE(ATI
, 0x4380), board_ahci_sb600
}, /* ATI SB600 */
570 { PCI_VDEVICE(ATI
, 0x4390), board_ahci_sb700
}, /* ATI SB700/800 */
571 { PCI_VDEVICE(ATI
, 0x4391), board_ahci_sb700
}, /* ATI SB700/800 */
572 { PCI_VDEVICE(ATI
, 0x4392), board_ahci_sb700
}, /* ATI SB700/800 */
573 { PCI_VDEVICE(ATI
, 0x4393), board_ahci_sb700
}, /* ATI SB700/800 */
574 { PCI_VDEVICE(ATI
, 0x4394), board_ahci_sb700
}, /* ATI SB700/800 */
575 { PCI_VDEVICE(ATI
, 0x4395), board_ahci_sb700
}, /* ATI SB700/800 */
578 { PCI_VDEVICE(AMD
, 0x7800), board_ahci
}, /* AMD SB900 */
579 /* AMD is using RAID class only for ahci controllers */
580 { PCI_VENDOR_ID_AMD
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
,
581 PCI_CLASS_STORAGE_RAID
<< 8, 0xffffff, board_ahci
},
584 { PCI_VDEVICE(VIA
, 0x3349), board_ahci_vt8251
}, /* VIA VT8251 */
585 { PCI_VDEVICE(VIA
, 0x6287), board_ahci_vt8251
}, /* VIA VT8251 */
588 { PCI_VDEVICE(NVIDIA
, 0x044c), board_ahci_mcp65
}, /* MCP65 */
589 { PCI_VDEVICE(NVIDIA
, 0x044d), board_ahci_mcp65
}, /* MCP65 */
590 { PCI_VDEVICE(NVIDIA
, 0x044e), board_ahci_mcp65
}, /* MCP65 */
591 { PCI_VDEVICE(NVIDIA
, 0x044f), board_ahci_mcp65
}, /* MCP65 */
592 { PCI_VDEVICE(NVIDIA
, 0x045c), board_ahci_mcp65
}, /* MCP65 */
593 { PCI_VDEVICE(NVIDIA
, 0x045d), board_ahci_mcp65
}, /* MCP65 */
594 { PCI_VDEVICE(NVIDIA
, 0x045e), board_ahci_mcp65
}, /* MCP65 */
595 { PCI_VDEVICE(NVIDIA
, 0x045f), board_ahci_mcp65
}, /* MCP65 */
596 { PCI_VDEVICE(NVIDIA
, 0x0550), board_ahci_yesncq
}, /* MCP67 */
597 { PCI_VDEVICE(NVIDIA
, 0x0551), board_ahci_yesncq
}, /* MCP67 */
598 { PCI_VDEVICE(NVIDIA
, 0x0552), board_ahci_yesncq
}, /* MCP67 */
599 { PCI_VDEVICE(NVIDIA
, 0x0553), board_ahci_yesncq
}, /* MCP67 */
600 { PCI_VDEVICE(NVIDIA
, 0x0554), board_ahci_yesncq
}, /* MCP67 */
601 { PCI_VDEVICE(NVIDIA
, 0x0555), board_ahci_yesncq
}, /* MCP67 */
602 { PCI_VDEVICE(NVIDIA
, 0x0556), board_ahci_yesncq
}, /* MCP67 */
603 { PCI_VDEVICE(NVIDIA
, 0x0557), board_ahci_yesncq
}, /* MCP67 */
604 { PCI_VDEVICE(NVIDIA
, 0x0558), board_ahci_yesncq
}, /* MCP67 */
605 { PCI_VDEVICE(NVIDIA
, 0x0559), board_ahci_yesncq
}, /* MCP67 */
606 { PCI_VDEVICE(NVIDIA
, 0x055a), board_ahci_yesncq
}, /* MCP67 */
607 { PCI_VDEVICE(NVIDIA
, 0x055b), board_ahci_yesncq
}, /* MCP67 */
608 { PCI_VDEVICE(NVIDIA
, 0x07f0), board_ahci_yesncq
}, /* MCP73 */
609 { PCI_VDEVICE(NVIDIA
, 0x07f1), board_ahci_yesncq
}, /* MCP73 */
610 { PCI_VDEVICE(NVIDIA
, 0x07f2), board_ahci_yesncq
}, /* MCP73 */
611 { PCI_VDEVICE(NVIDIA
, 0x07f3), board_ahci_yesncq
}, /* MCP73 */
612 { PCI_VDEVICE(NVIDIA
, 0x07f4), board_ahci_yesncq
}, /* MCP73 */
613 { PCI_VDEVICE(NVIDIA
, 0x07f5), board_ahci_yesncq
}, /* MCP73 */
614 { PCI_VDEVICE(NVIDIA
, 0x07f6), board_ahci_yesncq
}, /* MCP73 */
615 { PCI_VDEVICE(NVIDIA
, 0x07f7), board_ahci_yesncq
}, /* MCP73 */
616 { PCI_VDEVICE(NVIDIA
, 0x07f8), board_ahci_yesncq
}, /* MCP73 */
617 { PCI_VDEVICE(NVIDIA
, 0x07f9), board_ahci_yesncq
}, /* MCP73 */
618 { PCI_VDEVICE(NVIDIA
, 0x07fa), board_ahci_yesncq
}, /* MCP73 */
619 { PCI_VDEVICE(NVIDIA
, 0x07fb), board_ahci_yesncq
}, /* MCP73 */
620 { PCI_VDEVICE(NVIDIA
, 0x0ad0), board_ahci
}, /* MCP77 */
621 { PCI_VDEVICE(NVIDIA
, 0x0ad1), board_ahci
}, /* MCP77 */
622 { PCI_VDEVICE(NVIDIA
, 0x0ad2), board_ahci
}, /* MCP77 */
623 { PCI_VDEVICE(NVIDIA
, 0x0ad3), board_ahci
}, /* MCP77 */
624 { PCI_VDEVICE(NVIDIA
, 0x0ad4), board_ahci
}, /* MCP77 */
625 { PCI_VDEVICE(NVIDIA
, 0x0ad5), board_ahci
}, /* MCP77 */
626 { PCI_VDEVICE(NVIDIA
, 0x0ad6), board_ahci
}, /* MCP77 */
627 { PCI_VDEVICE(NVIDIA
, 0x0ad7), board_ahci
}, /* MCP77 */
628 { PCI_VDEVICE(NVIDIA
, 0x0ad8), board_ahci
}, /* MCP77 */
629 { PCI_VDEVICE(NVIDIA
, 0x0ad9), board_ahci
}, /* MCP77 */
630 { PCI_VDEVICE(NVIDIA
, 0x0ada), board_ahci
}, /* MCP77 */
631 { PCI_VDEVICE(NVIDIA
, 0x0adb), board_ahci
}, /* MCP77 */
632 { PCI_VDEVICE(NVIDIA
, 0x0ab4), board_ahci
}, /* MCP79 */
633 { PCI_VDEVICE(NVIDIA
, 0x0ab5), board_ahci
}, /* MCP79 */
634 { PCI_VDEVICE(NVIDIA
, 0x0ab6), board_ahci
}, /* MCP79 */
635 { PCI_VDEVICE(NVIDIA
, 0x0ab7), board_ahci
}, /* MCP79 */
636 { PCI_VDEVICE(NVIDIA
, 0x0ab8), board_ahci
}, /* MCP79 */
637 { PCI_VDEVICE(NVIDIA
, 0x0ab9), board_ahci
}, /* MCP79 */
638 { PCI_VDEVICE(NVIDIA
, 0x0aba), board_ahci
}, /* MCP79 */
639 { PCI_VDEVICE(NVIDIA
, 0x0abb), board_ahci
}, /* MCP79 */
640 { PCI_VDEVICE(NVIDIA
, 0x0abc), board_ahci
}, /* MCP79 */
641 { PCI_VDEVICE(NVIDIA
, 0x0abd), board_ahci
}, /* MCP79 */
642 { PCI_VDEVICE(NVIDIA
, 0x0abe), board_ahci
}, /* MCP79 */
643 { PCI_VDEVICE(NVIDIA
, 0x0abf), board_ahci
}, /* MCP79 */
644 { PCI_VDEVICE(NVIDIA
, 0x0d84), board_ahci
}, /* MCP89 */
645 { PCI_VDEVICE(NVIDIA
, 0x0d85), board_ahci
}, /* MCP89 */
646 { PCI_VDEVICE(NVIDIA
, 0x0d86), board_ahci
}, /* MCP89 */
647 { PCI_VDEVICE(NVIDIA
, 0x0d87), board_ahci
}, /* MCP89 */
648 { PCI_VDEVICE(NVIDIA
, 0x0d88), board_ahci
}, /* MCP89 */
649 { PCI_VDEVICE(NVIDIA
, 0x0d89), board_ahci
}, /* MCP89 */
650 { PCI_VDEVICE(NVIDIA
, 0x0d8a), board_ahci
}, /* MCP89 */
651 { PCI_VDEVICE(NVIDIA
, 0x0d8b), board_ahci
}, /* MCP89 */
652 { PCI_VDEVICE(NVIDIA
, 0x0d8c), board_ahci
}, /* MCP89 */
653 { PCI_VDEVICE(NVIDIA
, 0x0d8d), board_ahci
}, /* MCP89 */
654 { PCI_VDEVICE(NVIDIA
, 0x0d8e), board_ahci
}, /* MCP89 */
655 { PCI_VDEVICE(NVIDIA
, 0x0d8f), board_ahci
}, /* MCP89 */
658 { PCI_VDEVICE(SI
, 0x1184), board_ahci
}, /* SiS 966 */
659 { PCI_VDEVICE(SI
, 0x1185), board_ahci
}, /* SiS 968 */
660 { PCI_VDEVICE(SI
, 0x0186), board_ahci
}, /* SiS 968 */
663 { PCI_VDEVICE(MARVELL
, 0x6145), board_ahci_mv
}, /* 6145 */
664 { PCI_VDEVICE(MARVELL
, 0x6121), board_ahci_mv
}, /* 6121 */
667 { PCI_VDEVICE(PROMISE
, 0x3f20), board_ahci
}, /* PDC42819 */
669 /* Generic, PCI class code for AHCI */
670 { PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
,
671 PCI_CLASS_STORAGE_SATA_AHCI
, 0xffffff, board_ahci
},
673 { } /* terminate list */
677 static struct pci_driver ahci_pci_driver
= {
679 .id_table
= ahci_pci_tbl
,
680 .probe
= ahci_init_one
,
681 .remove
= ata_pci_remove_one
,
683 .suspend
= ahci_pci_device_suspend
,
684 .resume
= ahci_pci_device_resume
,
688 static int ahci_em_messages
= 1;
689 module_param(ahci_em_messages
, int, 0444);
690 /* add other LED protocol types when they become supported */
691 MODULE_PARM_DESC(ahci_em_messages
,
692 "Set AHCI Enclosure Management Message type (0 = disabled, 1 = LED");
694 #if defined(CONFIG_PATA_MARVELL) || defined(CONFIG_PATA_MARVELL_MODULE)
695 static int marvell_enable
;
697 static int marvell_enable
= 1;
699 module_param(marvell_enable
, int, 0644);
700 MODULE_PARM_DESC(marvell_enable
, "Marvell SATA via AHCI (1 = enabled)");
703 static inline int ahci_nr_ports(u32 cap
)
705 return (cap
& 0x1f) + 1;
708 static inline void __iomem
*__ahci_port_base(struct ata_host
*host
,
709 unsigned int port_no
)
711 void __iomem
*mmio
= host
->iomap
[AHCI_PCI_BAR
];
713 return mmio
+ 0x100 + (port_no
* 0x80);
716 static inline void __iomem
*ahci_port_base(struct ata_port
*ap
)
718 return __ahci_port_base(ap
->host
, ap
->port_no
);
721 static void ahci_enable_ahci(void __iomem
*mmio
)
726 /* turn on AHCI_EN */
727 tmp
= readl(mmio
+ HOST_CTL
);
728 if (tmp
& HOST_AHCI_EN
)
731 /* Some controllers need AHCI_EN to be written multiple times.
732 * Try a few times before giving up.
734 for (i
= 0; i
< 5; i
++) {
736 writel(tmp
, mmio
+ HOST_CTL
);
737 tmp
= readl(mmio
+ HOST_CTL
); /* flush && sanity check */
738 if (tmp
& HOST_AHCI_EN
)
746 static ssize_t
ahci_show_host_caps(struct device
*dev
,
747 struct device_attribute
*attr
, char *buf
)
749 struct Scsi_Host
*shost
= class_to_shost(dev
);
750 struct ata_port
*ap
= ata_shost_to_port(shost
);
751 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
753 return sprintf(buf
, "%x\n", hpriv
->cap
);
756 static ssize_t
ahci_show_host_cap2(struct device
*dev
,
757 struct device_attribute
*attr
, char *buf
)
759 struct Scsi_Host
*shost
= class_to_shost(dev
);
760 struct ata_port
*ap
= ata_shost_to_port(shost
);
761 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
763 return sprintf(buf
, "%x\n", hpriv
->cap2
);
766 static ssize_t
ahci_show_host_version(struct device
*dev
,
767 struct device_attribute
*attr
, char *buf
)
769 struct Scsi_Host
*shost
= class_to_shost(dev
);
770 struct ata_port
*ap
= ata_shost_to_port(shost
);
771 void __iomem
*mmio
= ap
->host
->iomap
[AHCI_PCI_BAR
];
773 return sprintf(buf
, "%x\n", readl(mmio
+ HOST_VERSION
));
776 static ssize_t
ahci_show_port_cmd(struct device
*dev
,
777 struct device_attribute
*attr
, char *buf
)
779 struct Scsi_Host
*shost
= class_to_shost(dev
);
780 struct ata_port
*ap
= ata_shost_to_port(shost
);
781 void __iomem
*port_mmio
= ahci_port_base(ap
);
783 return sprintf(buf
, "%x\n", readl(port_mmio
+ PORT_CMD
));
787 * ahci_save_initial_config - Save and fixup initial config values
788 * @pdev: target PCI device
789 * @hpriv: host private area to store config values
791 * Some registers containing configuration info might be setup by
792 * BIOS and might be cleared on reset. This function saves the
793 * initial values of those registers into @hpriv such that they
794 * can be restored after controller reset.
796 * If inconsistent, config values are fixed up by this function.
801 static void ahci_save_initial_config(struct pci_dev
*pdev
,
802 struct ahci_host_priv
*hpriv
)
804 void __iomem
*mmio
= pcim_iomap_table(pdev
)[AHCI_PCI_BAR
];
805 u32 cap
, cap2
, vers
, port_map
;
809 /* make sure AHCI mode is enabled before accessing CAP */
810 ahci_enable_ahci(mmio
);
812 /* Values prefixed with saved_ are written back to host after
813 * reset. Values without are used for driver operation.
815 hpriv
->saved_cap
= cap
= readl(mmio
+ HOST_CAP
);
816 hpriv
->saved_port_map
= port_map
= readl(mmio
+ HOST_PORTS_IMPL
);
818 /* CAP2 register is only defined for AHCI 1.2 and later */
819 vers
= readl(mmio
+ HOST_VERSION
);
820 if ((vers
>> 16) > 1 ||
821 ((vers
>> 16) == 1 && (vers
& 0xFFFF) >= 0x200))
822 hpriv
->saved_cap2
= cap2
= readl(mmio
+ HOST_CAP2
);
824 hpriv
->saved_cap2
= cap2
= 0;
826 /* some chips have errata preventing 64bit use */
827 if ((cap
& HOST_CAP_64
) && (hpriv
->flags
& AHCI_HFLAG_32BIT_ONLY
)) {
828 dev_printk(KERN_INFO
, &pdev
->dev
,
829 "controller can't do 64bit DMA, forcing 32bit\n");
833 if ((cap
& HOST_CAP_NCQ
) && (hpriv
->flags
& AHCI_HFLAG_NO_NCQ
)) {
834 dev_printk(KERN_INFO
, &pdev
->dev
,
835 "controller can't do NCQ, turning off CAP_NCQ\n");
836 cap
&= ~HOST_CAP_NCQ
;
839 if (!(cap
& HOST_CAP_NCQ
) && (hpriv
->flags
& AHCI_HFLAG_YES_NCQ
)) {
840 dev_printk(KERN_INFO
, &pdev
->dev
,
841 "controller can do NCQ, turning on CAP_NCQ\n");
845 if ((cap
& HOST_CAP_PMP
) && (hpriv
->flags
& AHCI_HFLAG_NO_PMP
)) {
846 dev_printk(KERN_INFO
, &pdev
->dev
,
847 "controller can't do PMP, turning off CAP_PMP\n");
848 cap
&= ~HOST_CAP_PMP
;
851 if (pdev
->vendor
== PCI_VENDOR_ID_JMICRON
&& pdev
->device
== 0x2361 &&
853 dev_printk(KERN_INFO
, &pdev
->dev
,
854 "JMB361 has only one port, port_map 0x%x -> 0x%x\n",
860 * Temporary Marvell 6145 hack: PATA port presence
861 * is asserted through the standard AHCI port
862 * presence register, as bit 4 (counting from 0)
864 if (hpriv
->flags
& AHCI_HFLAG_MV_PATA
) {
865 if (pdev
->device
== 0x6121)
869 dev_printk(KERN_ERR
, &pdev
->dev
,
870 "MV_AHCI HACK: port_map %x -> %x\n",
873 dev_printk(KERN_ERR
, &pdev
->dev
,
874 "Disabling your PATA port. Use the boot option 'ahci.marvell_enable=0' to avoid this.\n");
879 /* cross check port_map and cap.n_ports */
883 for (i
= 0; i
< AHCI_MAX_PORTS
; i
++)
884 if (port_map
& (1 << i
))
887 /* If PI has more ports than n_ports, whine, clear
888 * port_map and let it be generated from n_ports.
890 if (map_ports
> ahci_nr_ports(cap
)) {
891 dev_printk(KERN_WARNING
, &pdev
->dev
,
892 "implemented port map (0x%x) contains more "
893 "ports than nr_ports (%u), using nr_ports\n",
894 port_map
, ahci_nr_ports(cap
));
899 /* fabricate port_map from cap.nr_ports */
901 port_map
= (1 << ahci_nr_ports(cap
)) - 1;
902 dev_printk(KERN_WARNING
, &pdev
->dev
,
903 "forcing PORTS_IMPL to 0x%x\n", port_map
);
905 /* write the fixed up value to the PI register */
906 hpriv
->saved_port_map
= port_map
;
909 /* record values to use during operation */
912 hpriv
->port_map
= port_map
;
916 * ahci_restore_initial_config - Restore initial config
917 * @host: target ATA host
919 * Restore initial config stored by ahci_save_initial_config().
924 static void ahci_restore_initial_config(struct ata_host
*host
)
926 struct ahci_host_priv
*hpriv
= host
->private_data
;
927 void __iomem
*mmio
= host
->iomap
[AHCI_PCI_BAR
];
929 writel(hpriv
->saved_cap
, mmio
+ HOST_CAP
);
930 if (hpriv
->saved_cap2
)
931 writel(hpriv
->saved_cap2
, mmio
+ HOST_CAP2
);
932 writel(hpriv
->saved_port_map
, mmio
+ HOST_PORTS_IMPL
);
933 (void) readl(mmio
+ HOST_PORTS_IMPL
); /* flush */
936 static unsigned ahci_scr_offset(struct ata_port
*ap
, unsigned int sc_reg
)
938 static const int offset
[] = {
939 [SCR_STATUS
] = PORT_SCR_STAT
,
940 [SCR_CONTROL
] = PORT_SCR_CTL
,
941 [SCR_ERROR
] = PORT_SCR_ERR
,
942 [SCR_ACTIVE
] = PORT_SCR_ACT
,
943 [SCR_NOTIFICATION
] = PORT_SCR_NTF
,
945 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
947 if (sc_reg
< ARRAY_SIZE(offset
) &&
948 (sc_reg
!= SCR_NOTIFICATION
|| (hpriv
->cap
& HOST_CAP_SNTF
)))
949 return offset
[sc_reg
];
953 static int ahci_scr_read(struct ata_link
*link
, unsigned int sc_reg
, u32
*val
)
955 void __iomem
*port_mmio
= ahci_port_base(link
->ap
);
956 int offset
= ahci_scr_offset(link
->ap
, sc_reg
);
959 *val
= readl(port_mmio
+ offset
);
965 static int ahci_scr_write(struct ata_link
*link
, unsigned int sc_reg
, u32 val
)
967 void __iomem
*port_mmio
= ahci_port_base(link
->ap
);
968 int offset
= ahci_scr_offset(link
->ap
, sc_reg
);
971 writel(val
, port_mmio
+ offset
);
977 static void ahci_start_engine(struct ata_port
*ap
)
979 void __iomem
*port_mmio
= ahci_port_base(ap
);
983 tmp
= readl(port_mmio
+ PORT_CMD
);
984 tmp
|= PORT_CMD_START
;
985 writel(tmp
, port_mmio
+ PORT_CMD
);
986 readl(port_mmio
+ PORT_CMD
); /* flush */
989 static int ahci_stop_engine(struct ata_port
*ap
)
991 void __iomem
*port_mmio
= ahci_port_base(ap
);
994 tmp
= readl(port_mmio
+ PORT_CMD
);
996 /* check if the HBA is idle */
997 if ((tmp
& (PORT_CMD_START
| PORT_CMD_LIST_ON
)) == 0)
1000 /* setting HBA to idle */
1001 tmp
&= ~PORT_CMD_START
;
1002 writel(tmp
, port_mmio
+ PORT_CMD
);
1004 /* wait for engine to stop. This could be as long as 500 msec */
1005 tmp
= ata_wait_register(port_mmio
+ PORT_CMD
,
1006 PORT_CMD_LIST_ON
, PORT_CMD_LIST_ON
, 1, 500);
1007 if (tmp
& PORT_CMD_LIST_ON
)
1013 static void ahci_start_fis_rx(struct ata_port
*ap
)
1015 void __iomem
*port_mmio
= ahci_port_base(ap
);
1016 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1017 struct ahci_port_priv
*pp
= ap
->private_data
;
1020 /* set FIS registers */
1021 if (hpriv
->cap
& HOST_CAP_64
)
1022 writel((pp
->cmd_slot_dma
>> 16) >> 16,
1023 port_mmio
+ PORT_LST_ADDR_HI
);
1024 writel(pp
->cmd_slot_dma
& 0xffffffff, port_mmio
+ PORT_LST_ADDR
);
1026 if (hpriv
->cap
& HOST_CAP_64
)
1027 writel((pp
->rx_fis_dma
>> 16) >> 16,
1028 port_mmio
+ PORT_FIS_ADDR_HI
);
1029 writel(pp
->rx_fis_dma
& 0xffffffff, port_mmio
+ PORT_FIS_ADDR
);
1031 /* enable FIS reception */
1032 tmp
= readl(port_mmio
+ PORT_CMD
);
1033 tmp
|= PORT_CMD_FIS_RX
;
1034 writel(tmp
, port_mmio
+ PORT_CMD
);
1037 readl(port_mmio
+ PORT_CMD
);
1040 static int ahci_stop_fis_rx(struct ata_port
*ap
)
1042 void __iomem
*port_mmio
= ahci_port_base(ap
);
1045 /* disable FIS reception */
1046 tmp
= readl(port_mmio
+ PORT_CMD
);
1047 tmp
&= ~PORT_CMD_FIS_RX
;
1048 writel(tmp
, port_mmio
+ PORT_CMD
);
1050 /* wait for completion, spec says 500ms, give it 1000 */
1051 tmp
= ata_wait_register(port_mmio
+ PORT_CMD
, PORT_CMD_FIS_ON
,
1052 PORT_CMD_FIS_ON
, 10, 1000);
1053 if (tmp
& PORT_CMD_FIS_ON
)
1059 static void ahci_power_up(struct ata_port
*ap
)
1061 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1062 void __iomem
*port_mmio
= ahci_port_base(ap
);
1065 cmd
= readl(port_mmio
+ PORT_CMD
) & ~PORT_CMD_ICC_MASK
;
1067 /* spin up device */
1068 if (hpriv
->cap
& HOST_CAP_SSS
) {
1069 cmd
|= PORT_CMD_SPIN_UP
;
1070 writel(cmd
, port_mmio
+ PORT_CMD
);
1074 writel(cmd
| PORT_CMD_ICC_ACTIVE
, port_mmio
+ PORT_CMD
);
1077 static void ahci_disable_alpm(struct ata_port
*ap
)
1079 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1080 void __iomem
*port_mmio
= ahci_port_base(ap
);
1082 struct ahci_port_priv
*pp
= ap
->private_data
;
1084 /* IPM bits should be disabled by libata-core */
1085 /* get the existing command bits */
1086 cmd
= readl(port_mmio
+ PORT_CMD
);
1088 /* disable ALPM and ASP */
1089 cmd
&= ~PORT_CMD_ASP
;
1090 cmd
&= ~PORT_CMD_ALPE
;
1092 /* force the interface back to active */
1093 cmd
|= PORT_CMD_ICC_ACTIVE
;
1095 /* write out new cmd value */
1096 writel(cmd
, port_mmio
+ PORT_CMD
);
1097 cmd
= readl(port_mmio
+ PORT_CMD
);
1099 /* wait 10ms to be sure we've come out of any low power state */
1102 /* clear out any PhyRdy stuff from interrupt status */
1103 writel(PORT_IRQ_PHYRDY
, port_mmio
+ PORT_IRQ_STAT
);
1105 /* go ahead and clean out PhyRdy Change from Serror too */
1106 ahci_scr_write(&ap
->link
, SCR_ERROR
, ((1 << 16) | (1 << 18)));
1109 * Clear flag to indicate that we should ignore all PhyRdy
1112 hpriv
->flags
&= ~AHCI_HFLAG_NO_HOTPLUG
;
1115 * Enable interrupts on Phy Ready.
1117 pp
->intr_mask
|= PORT_IRQ_PHYRDY
;
1118 writel(pp
->intr_mask
, port_mmio
+ PORT_IRQ_MASK
);
1121 * don't change the link pm policy - we can be called
1122 * just to turn of link pm temporarily
1126 static int ahci_enable_alpm(struct ata_port
*ap
,
1127 enum link_pm policy
)
1129 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1130 void __iomem
*port_mmio
= ahci_port_base(ap
);
1132 struct ahci_port_priv
*pp
= ap
->private_data
;
1135 /* Make sure the host is capable of link power management */
1136 if (!(hpriv
->cap
& HOST_CAP_ALPM
))
1140 case MAX_PERFORMANCE
:
1143 * if we came here with NOT_AVAILABLE,
1144 * it just means this is the first time we
1145 * have tried to enable - default to max performance,
1146 * and let the user go to lower power modes on request.
1148 ahci_disable_alpm(ap
);
1151 /* configure HBA to enter SLUMBER */
1155 /* configure HBA to enter PARTIAL */
1163 * Disable interrupts on Phy Ready. This keeps us from
1164 * getting woken up due to spurious phy ready interrupts
1165 * TBD - Hot plug should be done via polling now, is
1166 * that even supported?
1168 pp
->intr_mask
&= ~PORT_IRQ_PHYRDY
;
1169 writel(pp
->intr_mask
, port_mmio
+ PORT_IRQ_MASK
);
1172 * Set a flag to indicate that we should ignore all PhyRdy
1173 * state changes since these can happen now whenever we
1176 hpriv
->flags
|= AHCI_HFLAG_NO_HOTPLUG
;
1178 /* get the existing command bits */
1179 cmd
= readl(port_mmio
+ PORT_CMD
);
1182 * Set ASP based on Policy
1187 * Setting this bit will instruct the HBA to aggressively
1188 * enter a lower power link state when it's appropriate and
1189 * based on the value set above for ASP
1191 cmd
|= PORT_CMD_ALPE
;
1193 /* write out new cmd value */
1194 writel(cmd
, port_mmio
+ PORT_CMD
);
1195 cmd
= readl(port_mmio
+ PORT_CMD
);
1197 /* IPM bits should be set by libata-core */
1202 static void ahci_power_down(struct ata_port
*ap
)
1204 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1205 void __iomem
*port_mmio
= ahci_port_base(ap
);
1208 if (!(hpriv
->cap
& HOST_CAP_SSS
))
1211 /* put device into listen mode, first set PxSCTL.DET to 0 */
1212 scontrol
= readl(port_mmio
+ PORT_SCR_CTL
);
1214 writel(scontrol
, port_mmio
+ PORT_SCR_CTL
);
1216 /* then set PxCMD.SUD to 0 */
1217 cmd
= readl(port_mmio
+ PORT_CMD
) & ~PORT_CMD_ICC_MASK
;
1218 cmd
&= ~PORT_CMD_SPIN_UP
;
1219 writel(cmd
, port_mmio
+ PORT_CMD
);
1223 static void ahci_start_port(struct ata_port
*ap
)
1225 struct ahci_port_priv
*pp
= ap
->private_data
;
1226 struct ata_link
*link
;
1227 struct ahci_em_priv
*emp
;
1231 /* enable FIS reception */
1232 ahci_start_fis_rx(ap
);
1235 ahci_start_engine(ap
);
1238 if (ap
->flags
& ATA_FLAG_EM
) {
1239 ata_for_each_link(link
, ap
, EDGE
) {
1240 emp
= &pp
->em_priv
[link
->pmp
];
1242 /* EM Transmit bit maybe busy during init */
1243 for (i
= 0; i
< EM_MAX_RETRY
; i
++) {
1244 rc
= ahci_transmit_led_message(ap
,
1255 if (ap
->flags
& ATA_FLAG_SW_ACTIVITY
)
1256 ata_for_each_link(link
, ap
, EDGE
)
1257 ahci_init_sw_activity(link
);
1261 static int ahci_deinit_port(struct ata_port
*ap
, const char **emsg
)
1266 rc
= ahci_stop_engine(ap
);
1268 *emsg
= "failed to stop engine";
1272 /* disable FIS reception */
1273 rc
= ahci_stop_fis_rx(ap
);
1275 *emsg
= "failed stop FIS RX";
1282 static int ahci_reset_controller(struct ata_host
*host
)
1284 struct pci_dev
*pdev
= to_pci_dev(host
->dev
);
1285 struct ahci_host_priv
*hpriv
= host
->private_data
;
1286 void __iomem
*mmio
= host
->iomap
[AHCI_PCI_BAR
];
1289 /* we must be in AHCI mode, before using anything
1290 * AHCI-specific, such as HOST_RESET.
1292 ahci_enable_ahci(mmio
);
1294 /* global controller reset */
1295 if (!ahci_skip_host_reset
) {
1296 tmp
= readl(mmio
+ HOST_CTL
);
1297 if ((tmp
& HOST_RESET
) == 0) {
1298 writel(tmp
| HOST_RESET
, mmio
+ HOST_CTL
);
1299 readl(mmio
+ HOST_CTL
); /* flush */
1303 * to perform host reset, OS should set HOST_RESET
1304 * and poll until this bit is read to be "0".
1305 * reset must complete within 1 second, or
1306 * the hardware should be considered fried.
1308 tmp
= ata_wait_register(mmio
+ HOST_CTL
, HOST_RESET
,
1309 HOST_RESET
, 10, 1000);
1311 if (tmp
& HOST_RESET
) {
1312 dev_printk(KERN_ERR
, host
->dev
,
1313 "controller reset failed (0x%x)\n", tmp
);
1317 /* turn on AHCI mode */
1318 ahci_enable_ahci(mmio
);
1320 /* Some registers might be cleared on reset. Restore
1323 ahci_restore_initial_config(host
);
1325 dev_printk(KERN_INFO
, host
->dev
,
1326 "skipping global host reset\n");
1328 if (pdev
->vendor
== PCI_VENDOR_ID_INTEL
) {
1332 pci_read_config_word(pdev
, 0x92, &tmp16
);
1333 if ((tmp16
& hpriv
->port_map
) != hpriv
->port_map
) {
1334 tmp16
|= hpriv
->port_map
;
1335 pci_write_config_word(pdev
, 0x92, tmp16
);
1342 static void ahci_sw_activity(struct ata_link
*link
)
1344 struct ata_port
*ap
= link
->ap
;
1345 struct ahci_port_priv
*pp
= ap
->private_data
;
1346 struct ahci_em_priv
*emp
= &pp
->em_priv
[link
->pmp
];
1348 if (!(link
->flags
& ATA_LFLAG_SW_ACTIVITY
))
1352 if (!timer_pending(&emp
->timer
))
1353 mod_timer(&emp
->timer
, jiffies
+ msecs_to_jiffies(10));
1356 static void ahci_sw_activity_blink(unsigned long arg
)
1358 struct ata_link
*link
= (struct ata_link
*)arg
;
1359 struct ata_port
*ap
= link
->ap
;
1360 struct ahci_port_priv
*pp
= ap
->private_data
;
1361 struct ahci_em_priv
*emp
= &pp
->em_priv
[link
->pmp
];
1362 unsigned long led_message
= emp
->led_state
;
1363 u32 activity_led_state
;
1364 unsigned long flags
;
1366 led_message
&= EM_MSG_LED_VALUE
;
1367 led_message
|= ap
->port_no
| (link
->pmp
<< 8);
1369 /* check to see if we've had activity. If so,
1370 * toggle state of LED and reset timer. If not,
1371 * turn LED to desired idle state.
1373 spin_lock_irqsave(ap
->lock
, flags
);
1374 if (emp
->saved_activity
!= emp
->activity
) {
1375 emp
->saved_activity
= emp
->activity
;
1376 /* get the current LED state */
1377 activity_led_state
= led_message
& EM_MSG_LED_VALUE_ON
;
1379 if (activity_led_state
)
1380 activity_led_state
= 0;
1382 activity_led_state
= 1;
1384 /* clear old state */
1385 led_message
&= ~EM_MSG_LED_VALUE_ACTIVITY
;
1388 led_message
|= (activity_led_state
<< 16);
1389 mod_timer(&emp
->timer
, jiffies
+ msecs_to_jiffies(100));
1391 /* switch to idle */
1392 led_message
&= ~EM_MSG_LED_VALUE_ACTIVITY
;
1393 if (emp
->blink_policy
== BLINK_OFF
)
1394 led_message
|= (1 << 16);
1396 spin_unlock_irqrestore(ap
->lock
, flags
);
1397 ahci_transmit_led_message(ap
, led_message
, 4);
1400 static void ahci_init_sw_activity(struct ata_link
*link
)
1402 struct ata_port
*ap
= link
->ap
;
1403 struct ahci_port_priv
*pp
= ap
->private_data
;
1404 struct ahci_em_priv
*emp
= &pp
->em_priv
[link
->pmp
];
1406 /* init activity stats, setup timer */
1407 emp
->saved_activity
= emp
->activity
= 0;
1408 setup_timer(&emp
->timer
, ahci_sw_activity_blink
, (unsigned long)link
);
1410 /* check our blink policy and set flag for link if it's enabled */
1411 if (emp
->blink_policy
)
1412 link
->flags
|= ATA_LFLAG_SW_ACTIVITY
;
1415 static int ahci_reset_em(struct ata_host
*host
)
1417 void __iomem
*mmio
= host
->iomap
[AHCI_PCI_BAR
];
1420 em_ctl
= readl(mmio
+ HOST_EM_CTL
);
1421 if ((em_ctl
& EM_CTL_TM
) || (em_ctl
& EM_CTL_RST
))
1424 writel(em_ctl
| EM_CTL_RST
, mmio
+ HOST_EM_CTL
);
1428 static ssize_t
ahci_transmit_led_message(struct ata_port
*ap
, u32 state
,
1431 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1432 struct ahci_port_priv
*pp
= ap
->private_data
;
1433 void __iomem
*mmio
= ap
->host
->iomap
[AHCI_PCI_BAR
];
1435 u32 message
[] = {0, 0};
1436 unsigned long flags
;
1438 struct ahci_em_priv
*emp
;
1440 /* get the slot number from the message */
1441 pmp
= (state
& EM_MSG_LED_PMP_SLOT
) >> 8;
1442 if (pmp
< EM_MAX_SLOTS
)
1443 emp
= &pp
->em_priv
[pmp
];
1447 spin_lock_irqsave(ap
->lock
, flags
);
1450 * if we are still busy transmitting a previous message,
1453 em_ctl
= readl(mmio
+ HOST_EM_CTL
);
1454 if (em_ctl
& EM_CTL_TM
) {
1455 spin_unlock_irqrestore(ap
->lock
, flags
);
1460 * create message header - this is all zero except for
1461 * the message size, which is 4 bytes.
1463 message
[0] |= (4 << 8);
1465 /* ignore 0:4 of byte zero, fill in port info yourself */
1466 message
[1] = ((state
& ~EM_MSG_LED_HBA_PORT
) | ap
->port_no
);
1468 /* write message to EM_LOC */
1469 writel(message
[0], mmio
+ hpriv
->em_loc
);
1470 writel(message
[1], mmio
+ hpriv
->em_loc
+4);
1472 /* save off new led state for port/slot */
1473 emp
->led_state
= state
;
1476 * tell hardware to transmit the message
1478 writel(em_ctl
| EM_CTL_TM
, mmio
+ HOST_EM_CTL
);
1480 spin_unlock_irqrestore(ap
->lock
, flags
);
1484 static ssize_t
ahci_led_show(struct ata_port
*ap
, char *buf
)
1486 struct ahci_port_priv
*pp
= ap
->private_data
;
1487 struct ata_link
*link
;
1488 struct ahci_em_priv
*emp
;
1491 ata_for_each_link(link
, ap
, EDGE
) {
1492 emp
= &pp
->em_priv
[link
->pmp
];
1493 rc
+= sprintf(buf
, "%lx\n", emp
->led_state
);
1498 static ssize_t
ahci_led_store(struct ata_port
*ap
, const char *buf
,
1503 struct ahci_port_priv
*pp
= ap
->private_data
;
1504 struct ahci_em_priv
*emp
;
1506 state
= simple_strtoul(buf
, NULL
, 0);
1508 /* get the slot number from the message */
1509 pmp
= (state
& EM_MSG_LED_PMP_SLOT
) >> 8;
1510 if (pmp
< EM_MAX_SLOTS
)
1511 emp
= &pp
->em_priv
[pmp
];
1515 /* mask off the activity bits if we are in sw_activity
1516 * mode, user should turn off sw_activity before setting
1517 * activity led through em_message
1519 if (emp
->blink_policy
)
1520 state
&= ~EM_MSG_LED_VALUE_ACTIVITY
;
1522 return ahci_transmit_led_message(ap
, state
, size
);
1525 static ssize_t
ahci_activity_store(struct ata_device
*dev
, enum sw_activity val
)
1527 struct ata_link
*link
= dev
->link
;
1528 struct ata_port
*ap
= link
->ap
;
1529 struct ahci_port_priv
*pp
= ap
->private_data
;
1530 struct ahci_em_priv
*emp
= &pp
->em_priv
[link
->pmp
];
1531 u32 port_led_state
= emp
->led_state
;
1533 /* save the desired Activity LED behavior */
1536 link
->flags
&= ~(ATA_LFLAG_SW_ACTIVITY
);
1538 /* set the LED to OFF */
1539 port_led_state
&= EM_MSG_LED_VALUE_OFF
;
1540 port_led_state
|= (ap
->port_no
| (link
->pmp
<< 8));
1541 ahci_transmit_led_message(ap
, port_led_state
, 4);
1543 link
->flags
|= ATA_LFLAG_SW_ACTIVITY
;
1544 if (val
== BLINK_OFF
) {
1545 /* set LED to ON for idle */
1546 port_led_state
&= EM_MSG_LED_VALUE_OFF
;
1547 port_led_state
|= (ap
->port_no
| (link
->pmp
<< 8));
1548 port_led_state
|= EM_MSG_LED_VALUE_ON
; /* check this */
1549 ahci_transmit_led_message(ap
, port_led_state
, 4);
1552 emp
->blink_policy
= val
;
1556 static ssize_t
ahci_activity_show(struct ata_device
*dev
, char *buf
)
1558 struct ata_link
*link
= dev
->link
;
1559 struct ata_port
*ap
= link
->ap
;
1560 struct ahci_port_priv
*pp
= ap
->private_data
;
1561 struct ahci_em_priv
*emp
= &pp
->em_priv
[link
->pmp
];
1563 /* display the saved value of activity behavior for this
1566 return sprintf(buf
, "%d\n", emp
->blink_policy
);
1569 static void ahci_port_init(struct pci_dev
*pdev
, struct ata_port
*ap
,
1570 int port_no
, void __iomem
*mmio
,
1571 void __iomem
*port_mmio
)
1573 const char *emsg
= NULL
;
1577 /* make sure port is not active */
1578 rc
= ahci_deinit_port(ap
, &emsg
);
1580 dev_printk(KERN_WARNING
, &pdev
->dev
,
1581 "%s (%d)\n", emsg
, rc
);
1584 tmp
= readl(port_mmio
+ PORT_SCR_ERR
);
1585 VPRINTK("PORT_SCR_ERR 0x%x\n", tmp
);
1586 writel(tmp
, port_mmio
+ PORT_SCR_ERR
);
1588 /* clear port IRQ */
1589 tmp
= readl(port_mmio
+ PORT_IRQ_STAT
);
1590 VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp
);
1592 writel(tmp
, port_mmio
+ PORT_IRQ_STAT
);
1594 writel(1 << port_no
, mmio
+ HOST_IRQ_STAT
);
1597 static void ahci_init_controller(struct ata_host
*host
)
1599 struct ahci_host_priv
*hpriv
= host
->private_data
;
1600 struct pci_dev
*pdev
= to_pci_dev(host
->dev
);
1601 void __iomem
*mmio
= host
->iomap
[AHCI_PCI_BAR
];
1603 void __iomem
*port_mmio
;
1607 if (hpriv
->flags
& AHCI_HFLAG_MV_PATA
) {
1608 if (pdev
->device
== 0x6121)
1612 port_mmio
= __ahci_port_base(host
, mv
);
1614 writel(0, port_mmio
+ PORT_IRQ_MASK
);
1616 /* clear port IRQ */
1617 tmp
= readl(port_mmio
+ PORT_IRQ_STAT
);
1618 VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp
);
1620 writel(tmp
, port_mmio
+ PORT_IRQ_STAT
);
1623 for (i
= 0; i
< host
->n_ports
; i
++) {
1624 struct ata_port
*ap
= host
->ports
[i
];
1626 port_mmio
= ahci_port_base(ap
);
1627 if (ata_port_is_dummy(ap
))
1630 ahci_port_init(pdev
, ap
, i
, mmio
, port_mmio
);
1633 tmp
= readl(mmio
+ HOST_CTL
);
1634 VPRINTK("HOST_CTL 0x%x\n", tmp
);
1635 writel(tmp
| HOST_IRQ_EN
, mmio
+ HOST_CTL
);
1636 tmp
= readl(mmio
+ HOST_CTL
);
1637 VPRINTK("HOST_CTL 0x%x\n", tmp
);
1640 static void ahci_dev_config(struct ata_device
*dev
)
1642 struct ahci_host_priv
*hpriv
= dev
->link
->ap
->host
->private_data
;
1644 if (hpriv
->flags
& AHCI_HFLAG_SECT255
) {
1645 dev
->max_sectors
= 255;
1646 ata_dev_printk(dev
, KERN_INFO
,
1647 "SB600 AHCI: limiting to 255 sectors per cmd\n");
1651 static unsigned int ahci_dev_classify(struct ata_port
*ap
)
1653 void __iomem
*port_mmio
= ahci_port_base(ap
);
1654 struct ata_taskfile tf
;
1657 tmp
= readl(port_mmio
+ PORT_SIG
);
1658 tf
.lbah
= (tmp
>> 24) & 0xff;
1659 tf
.lbam
= (tmp
>> 16) & 0xff;
1660 tf
.lbal
= (tmp
>> 8) & 0xff;
1661 tf
.nsect
= (tmp
) & 0xff;
1663 return ata_dev_classify(&tf
);
1666 static void ahci_fill_cmd_slot(struct ahci_port_priv
*pp
, unsigned int tag
,
1669 dma_addr_t cmd_tbl_dma
;
1671 cmd_tbl_dma
= pp
->cmd_tbl_dma
+ tag
* AHCI_CMD_TBL_SZ
;
1673 pp
->cmd_slot
[tag
].opts
= cpu_to_le32(opts
);
1674 pp
->cmd_slot
[tag
].status
= 0;
1675 pp
->cmd_slot
[tag
].tbl_addr
= cpu_to_le32(cmd_tbl_dma
& 0xffffffff);
1676 pp
->cmd_slot
[tag
].tbl_addr_hi
= cpu_to_le32((cmd_tbl_dma
>> 16) >> 16);
1679 static int ahci_kick_engine(struct ata_port
*ap
)
1681 void __iomem
*port_mmio
= ahci_port_base(ap
);
1682 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1683 u8 status
= readl(port_mmio
+ PORT_TFDATA
) & 0xFF;
1688 rc
= ahci_stop_engine(ap
);
1693 * always do CLO if PMP is attached (AHCI-1.3 9.2)
1695 busy
= status
& (ATA_BUSY
| ATA_DRQ
);
1696 if (!busy
&& !sata_pmp_attached(ap
)) {
1701 if (!(hpriv
->cap
& HOST_CAP_CLO
)) {
1707 tmp
= readl(port_mmio
+ PORT_CMD
);
1708 tmp
|= PORT_CMD_CLO
;
1709 writel(tmp
, port_mmio
+ PORT_CMD
);
1712 tmp
= ata_wait_register(port_mmio
+ PORT_CMD
,
1713 PORT_CMD_CLO
, PORT_CMD_CLO
, 1, 500);
1714 if (tmp
& PORT_CMD_CLO
)
1717 /* restart engine */
1719 ahci_start_engine(ap
);
1723 static int ahci_exec_polled_cmd(struct ata_port
*ap
, int pmp
,
1724 struct ata_taskfile
*tf
, int is_cmd
, u16 flags
,
1725 unsigned long timeout_msec
)
1727 const u32 cmd_fis_len
= 5; /* five dwords */
1728 struct ahci_port_priv
*pp
= ap
->private_data
;
1729 void __iomem
*port_mmio
= ahci_port_base(ap
);
1730 u8
*fis
= pp
->cmd_tbl
;
1733 /* prep the command */
1734 ata_tf_to_fis(tf
, pmp
, is_cmd
, fis
);
1735 ahci_fill_cmd_slot(pp
, 0, cmd_fis_len
| flags
| (pmp
<< 12));
1738 writel(1, port_mmio
+ PORT_CMD_ISSUE
);
1741 tmp
= ata_wait_register(port_mmio
+ PORT_CMD_ISSUE
, 0x1, 0x1,
1744 ahci_kick_engine(ap
);
1748 readl(port_mmio
+ PORT_CMD_ISSUE
); /* flush */
1753 static int ahci_do_softreset(struct ata_link
*link
, unsigned int *class,
1754 int pmp
, unsigned long deadline
,
1755 int (*check_ready
)(struct ata_link
*link
))
1757 struct ata_port
*ap
= link
->ap
;
1758 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
1759 const char *reason
= NULL
;
1760 unsigned long now
, msecs
;
1761 struct ata_taskfile tf
;
1766 /* prepare for SRST (AHCI-1.1 10.4.1) */
1767 rc
= ahci_kick_engine(ap
);
1768 if (rc
&& rc
!= -EOPNOTSUPP
)
1769 ata_link_printk(link
, KERN_WARNING
,
1770 "failed to reset engine (errno=%d)\n", rc
);
1772 ata_tf_init(link
->device
, &tf
);
1774 /* issue the first D2H Register FIS */
1777 if (time_after(now
, deadline
))
1778 msecs
= jiffies_to_msecs(deadline
- now
);
1781 if (ahci_exec_polled_cmd(ap
, pmp
, &tf
, 0,
1782 AHCI_CMD_RESET
| AHCI_CMD_CLR_BUSY
, msecs
)) {
1784 reason
= "1st FIS failed";
1788 /* spec says at least 5us, but be generous and sleep for 1ms */
1791 /* issue the second D2H Register FIS */
1792 tf
.ctl
&= ~ATA_SRST
;
1793 ahci_exec_polled_cmd(ap
, pmp
, &tf
, 0, 0, 0);
1795 /* wait for link to become ready */
1796 rc
= ata_wait_after_reset(link
, deadline
, check_ready
);
1797 if (rc
== -EBUSY
&& hpriv
->flags
& AHCI_HFLAG_SRST_TOUT_IS_OFFLINE
) {
1799 * Workaround for cases where link online status can't
1800 * be trusted. Treat device readiness timeout as link
1803 ata_link_printk(link
, KERN_INFO
,
1804 "device not ready, treating as offline\n");
1805 *class = ATA_DEV_NONE
;
1807 /* link occupied, -ENODEV too is an error */
1808 reason
= "device not ready";
1811 *class = ahci_dev_classify(ap
);
1813 DPRINTK("EXIT, class=%u\n", *class);
1817 ata_link_printk(link
, KERN_ERR
, "softreset failed (%s)\n", reason
);
1821 static int ahci_check_ready(struct ata_link
*link
)
1823 void __iomem
*port_mmio
= ahci_port_base(link
->ap
);
1824 u8 status
= readl(port_mmio
+ PORT_TFDATA
) & 0xFF;
1826 return ata_check_ready(status
);
1829 static int ahci_softreset(struct ata_link
*link
, unsigned int *class,
1830 unsigned long deadline
)
1832 int pmp
= sata_srst_pmp(link
);
1836 return ahci_do_softreset(link
, class, pmp
, deadline
, ahci_check_ready
);
1839 static int ahci_sb600_check_ready(struct ata_link
*link
)
1841 void __iomem
*port_mmio
= ahci_port_base(link
->ap
);
1842 u8 status
= readl(port_mmio
+ PORT_TFDATA
) & 0xFF;
1843 u32 irq_status
= readl(port_mmio
+ PORT_IRQ_STAT
);
1846 * There is no need to check TFDATA if BAD PMP is found due to HW bug,
1847 * which can save timeout delay.
1849 if (irq_status
& PORT_IRQ_BAD_PMP
)
1852 return ata_check_ready(status
);
1855 static int ahci_sb600_softreset(struct ata_link
*link
, unsigned int *class,
1856 unsigned long deadline
)
1858 struct ata_port
*ap
= link
->ap
;
1859 void __iomem
*port_mmio
= ahci_port_base(ap
);
1860 int pmp
= sata_srst_pmp(link
);
1866 rc
= ahci_do_softreset(link
, class, pmp
, deadline
,
1867 ahci_sb600_check_ready
);
1870 * Soft reset fails on some ATI chips with IPMS set when PMP
1871 * is enabled but SATA HDD/ODD is connected to SATA port,
1872 * do soft reset again to port 0.
1875 irq_sts
= readl(port_mmio
+ PORT_IRQ_STAT
);
1876 if (irq_sts
& PORT_IRQ_BAD_PMP
) {
1877 ata_link_printk(link
, KERN_WARNING
,
1878 "applying SB600 PMP SRST workaround "
1880 rc
= ahci_do_softreset(link
, class, 0, deadline
,
1888 static int ahci_hardreset(struct ata_link
*link
, unsigned int *class,
1889 unsigned long deadline
)
1891 const unsigned long *timing
= sata_ehc_deb_timing(&link
->eh_context
);
1892 struct ata_port
*ap
= link
->ap
;
1893 struct ahci_port_priv
*pp
= ap
->private_data
;
1894 u8
*d2h_fis
= pp
->rx_fis
+ RX_FIS_D2H_REG
;
1895 struct ata_taskfile tf
;
1901 ahci_stop_engine(ap
);
1903 /* clear D2H reception area to properly wait for D2H FIS */
1904 ata_tf_init(link
->device
, &tf
);
1906 ata_tf_to_fis(&tf
, 0, 0, d2h_fis
);
1908 rc
= sata_link_hardreset(link
, timing
, deadline
, &online
,
1911 ahci_start_engine(ap
);
1914 *class = ahci_dev_classify(ap
);
1916 DPRINTK("EXIT, rc=%d, class=%u\n", rc
, *class);
1920 static int ahci_vt8251_hardreset(struct ata_link
*link
, unsigned int *class,
1921 unsigned long deadline
)
1923 struct ata_port
*ap
= link
->ap
;
1929 ahci_stop_engine(ap
);
1931 rc
= sata_link_hardreset(link
, sata_ehc_deb_timing(&link
->eh_context
),
1932 deadline
, &online
, NULL
);
1934 ahci_start_engine(ap
);
1936 DPRINTK("EXIT, rc=%d, class=%u\n", rc
, *class);
1938 /* vt8251 doesn't clear BSY on signature FIS reception,
1939 * request follow-up softreset.
1941 return online
? -EAGAIN
: rc
;
1944 static int ahci_p5wdh_hardreset(struct ata_link
*link
, unsigned int *class,
1945 unsigned long deadline
)
1947 struct ata_port
*ap
= link
->ap
;
1948 struct ahci_port_priv
*pp
= ap
->private_data
;
1949 u8
*d2h_fis
= pp
->rx_fis
+ RX_FIS_D2H_REG
;
1950 struct ata_taskfile tf
;
1954 ahci_stop_engine(ap
);
1956 /* clear D2H reception area to properly wait for D2H FIS */
1957 ata_tf_init(link
->device
, &tf
);
1959 ata_tf_to_fis(&tf
, 0, 0, d2h_fis
);
1961 rc
= sata_link_hardreset(link
, sata_ehc_deb_timing(&link
->eh_context
),
1962 deadline
, &online
, NULL
);
1964 ahci_start_engine(ap
);
1966 /* The pseudo configuration device on SIMG4726 attached to
1967 * ASUS P5W-DH Deluxe doesn't send signature FIS after
1968 * hardreset if no device is attached to the first downstream
1969 * port && the pseudo device locks up on SRST w/ PMP==0. To
1970 * work around this, wait for !BSY only briefly. If BSY isn't
1971 * cleared, perform CLO and proceed to IDENTIFY (achieved by
1972 * ATA_LFLAG_NO_SRST and ATA_LFLAG_ASSUME_ATA).
1974 * Wait for two seconds. Devices attached to downstream port
1975 * which can't process the following IDENTIFY after this will
1976 * have to be reset again. For most cases, this should
1977 * suffice while making probing snappish enough.
1980 rc
= ata_wait_after_reset(link
, jiffies
+ 2 * HZ
,
1983 ahci_kick_engine(ap
);
1988 static void ahci_postreset(struct ata_link
*link
, unsigned int *class)
1990 struct ata_port
*ap
= link
->ap
;
1991 void __iomem
*port_mmio
= ahci_port_base(ap
);
1994 ata_std_postreset(link
, class);
1996 /* Make sure port's ATAPI bit is set appropriately */
1997 new_tmp
= tmp
= readl(port_mmio
+ PORT_CMD
);
1998 if (*class == ATA_DEV_ATAPI
)
1999 new_tmp
|= PORT_CMD_ATAPI
;
2001 new_tmp
&= ~PORT_CMD_ATAPI
;
2002 if (new_tmp
!= tmp
) {
2003 writel(new_tmp
, port_mmio
+ PORT_CMD
);
2004 readl(port_mmio
+ PORT_CMD
); /* flush */
2008 static unsigned int ahci_fill_sg(struct ata_queued_cmd
*qc
, void *cmd_tbl
)
2010 struct scatterlist
*sg
;
2011 struct ahci_sg
*ahci_sg
= cmd_tbl
+ AHCI_CMD_TBL_HDR_SZ
;
2017 * Next, the S/G list.
2019 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
) {
2020 dma_addr_t addr
= sg_dma_address(sg
);
2021 u32 sg_len
= sg_dma_len(sg
);
2023 ahci_sg
[si
].addr
= cpu_to_le32(addr
& 0xffffffff);
2024 ahci_sg
[si
].addr_hi
= cpu_to_le32((addr
>> 16) >> 16);
2025 ahci_sg
[si
].flags_size
= cpu_to_le32(sg_len
- 1);
2031 static void ahci_qc_prep(struct ata_queued_cmd
*qc
)
2033 struct ata_port
*ap
= qc
->ap
;
2034 struct ahci_port_priv
*pp
= ap
->private_data
;
2035 int is_atapi
= ata_is_atapi(qc
->tf
.protocol
);
2038 const u32 cmd_fis_len
= 5; /* five dwords */
2039 unsigned int n_elem
;
2042 * Fill in command table information. First, the header,
2043 * a SATA Register - Host to Device command FIS.
2045 cmd_tbl
= pp
->cmd_tbl
+ qc
->tag
* AHCI_CMD_TBL_SZ
;
2047 ata_tf_to_fis(&qc
->tf
, qc
->dev
->link
->pmp
, 1, cmd_tbl
);
2049 memset(cmd_tbl
+ AHCI_CMD_TBL_CDB
, 0, 32);
2050 memcpy(cmd_tbl
+ AHCI_CMD_TBL_CDB
, qc
->cdb
, qc
->dev
->cdb_len
);
2054 if (qc
->flags
& ATA_QCFLAG_DMAMAP
)
2055 n_elem
= ahci_fill_sg(qc
, cmd_tbl
);
2058 * Fill in command slot information.
2060 opts
= cmd_fis_len
| n_elem
<< 16 | (qc
->dev
->link
->pmp
<< 12);
2061 if (qc
->tf
.flags
& ATA_TFLAG_WRITE
)
2062 opts
|= AHCI_CMD_WRITE
;
2064 opts
|= AHCI_CMD_ATAPI
| AHCI_CMD_PREFETCH
;
2066 ahci_fill_cmd_slot(pp
, qc
->tag
, opts
);
2069 static void ahci_error_intr(struct ata_port
*ap
, u32 irq_stat
)
2071 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
2072 struct ahci_port_priv
*pp
= ap
->private_data
;
2073 struct ata_eh_info
*host_ehi
= &ap
->link
.eh_info
;
2074 struct ata_link
*link
= NULL
;
2075 struct ata_queued_cmd
*active_qc
;
2076 struct ata_eh_info
*active_ehi
;
2079 /* determine active link */
2080 ata_for_each_link(link
, ap
, EDGE
)
2081 if (ata_link_active(link
))
2086 active_qc
= ata_qc_from_tag(ap
, link
->active_tag
);
2087 active_ehi
= &link
->eh_info
;
2089 /* record irq stat */
2090 ata_ehi_clear_desc(host_ehi
);
2091 ata_ehi_push_desc(host_ehi
, "irq_stat 0x%08x", irq_stat
);
2093 /* AHCI needs SError cleared; otherwise, it might lock up */
2094 ahci_scr_read(&ap
->link
, SCR_ERROR
, &serror
);
2095 ahci_scr_write(&ap
->link
, SCR_ERROR
, serror
);
2096 host_ehi
->serror
|= serror
;
2098 /* some controllers set IRQ_IF_ERR on device errors, ignore it */
2099 if (hpriv
->flags
& AHCI_HFLAG_IGN_IRQ_IF_ERR
)
2100 irq_stat
&= ~PORT_IRQ_IF_ERR
;
2102 if (irq_stat
& PORT_IRQ_TF_ERR
) {
2103 /* If qc is active, charge it; otherwise, the active
2104 * link. There's no active qc on NCQ errors. It will
2105 * be determined by EH by reading log page 10h.
2108 active_qc
->err_mask
|= AC_ERR_DEV
;
2110 active_ehi
->err_mask
|= AC_ERR_DEV
;
2112 if (hpriv
->flags
& AHCI_HFLAG_IGN_SERR_INTERNAL
)
2113 host_ehi
->serror
&= ~SERR_INTERNAL
;
2116 if (irq_stat
& PORT_IRQ_UNK_FIS
) {
2117 u32
*unk
= (u32
*)(pp
->rx_fis
+ RX_FIS_UNK
);
2119 active_ehi
->err_mask
|= AC_ERR_HSM
;
2120 active_ehi
->action
|= ATA_EH_RESET
;
2121 ata_ehi_push_desc(active_ehi
,
2122 "unknown FIS %08x %08x %08x %08x" ,
2123 unk
[0], unk
[1], unk
[2], unk
[3]);
2126 if (sata_pmp_attached(ap
) && (irq_stat
& PORT_IRQ_BAD_PMP
)) {
2127 active_ehi
->err_mask
|= AC_ERR_HSM
;
2128 active_ehi
->action
|= ATA_EH_RESET
;
2129 ata_ehi_push_desc(active_ehi
, "incorrect PMP");
2132 if (irq_stat
& (PORT_IRQ_HBUS_ERR
| PORT_IRQ_HBUS_DATA_ERR
)) {
2133 host_ehi
->err_mask
|= AC_ERR_HOST_BUS
;
2134 host_ehi
->action
|= ATA_EH_RESET
;
2135 ata_ehi_push_desc(host_ehi
, "host bus error");
2138 if (irq_stat
& PORT_IRQ_IF_ERR
) {
2139 host_ehi
->err_mask
|= AC_ERR_ATA_BUS
;
2140 host_ehi
->action
|= ATA_EH_RESET
;
2141 ata_ehi_push_desc(host_ehi
, "interface fatal error");
2144 if (irq_stat
& (PORT_IRQ_CONNECT
| PORT_IRQ_PHYRDY
)) {
2145 ata_ehi_hotplugged(host_ehi
);
2146 ata_ehi_push_desc(host_ehi
, "%s",
2147 irq_stat
& PORT_IRQ_CONNECT
?
2148 "connection status changed" : "PHY RDY changed");
2151 /* okay, let's hand over to EH */
2153 if (irq_stat
& PORT_IRQ_FREEZE
)
2154 ata_port_freeze(ap
);
2159 static void ahci_port_intr(struct ata_port
*ap
)
2161 void __iomem
*port_mmio
= ahci_port_base(ap
);
2162 struct ata_eh_info
*ehi
= &ap
->link
.eh_info
;
2163 struct ahci_port_priv
*pp
= ap
->private_data
;
2164 struct ahci_host_priv
*hpriv
= ap
->host
->private_data
;
2165 int resetting
= !!(ap
->pflags
& ATA_PFLAG_RESETTING
);
2166 u32 status
, qc_active
;
2169 status
= readl(port_mmio
+ PORT_IRQ_STAT
);
2170 writel(status
, port_mmio
+ PORT_IRQ_STAT
);
2172 /* ignore BAD_PMP while resetting */
2173 if (unlikely(resetting
))
2174 status
&= ~PORT_IRQ_BAD_PMP
;
2176 /* If we are getting PhyRdy, this is
2177 * just a power state change, we should
2178 * clear out this, plus the PhyRdy/Comm
2179 * Wake bits from Serror
2181 if ((hpriv
->flags
& AHCI_HFLAG_NO_HOTPLUG
) &&
2182 (status
& PORT_IRQ_PHYRDY
)) {
2183 status
&= ~PORT_IRQ_PHYRDY
;
2184 ahci_scr_write(&ap
->link
, SCR_ERROR
, ((1 << 16) | (1 << 18)));
2187 if (unlikely(status
& PORT_IRQ_ERROR
)) {
2188 ahci_error_intr(ap
, status
);
2192 if (status
& PORT_IRQ_SDB_FIS
) {
2193 /* If SNotification is available, leave notification
2194 * handling to sata_async_notification(). If not,
2195 * emulate it by snooping SDB FIS RX area.
2197 * Snooping FIS RX area is probably cheaper than
2198 * poking SNotification but some constrollers which
2199 * implement SNotification, ICH9 for example, don't
2200 * store AN SDB FIS into receive area.
2202 if (hpriv
->cap
& HOST_CAP_SNTF
)
2203 sata_async_notification(ap
);
2205 /* If the 'N' bit in word 0 of the FIS is set,
2206 * we just received asynchronous notification.
2207 * Tell libata about it.
2209 const __le32
*f
= pp
->rx_fis
+ RX_FIS_SDB
;
2210 u32 f0
= le32_to_cpu(f
[0]);
2213 sata_async_notification(ap
);
2217 /* pp->active_link is valid iff any command is in flight */
2218 if (ap
->qc_active
&& pp
->active_link
->sactive
)
2219 qc_active
= readl(port_mmio
+ PORT_SCR_ACT
);
2221 qc_active
= readl(port_mmio
+ PORT_CMD_ISSUE
);
2223 rc
= ata_qc_complete_multiple(ap
, qc_active
);
2225 /* while resetting, invalid completions are expected */
2226 if (unlikely(rc
< 0 && !resetting
)) {
2227 ehi
->err_mask
|= AC_ERR_HSM
;
2228 ehi
->action
|= ATA_EH_RESET
;
2229 ata_port_freeze(ap
);
2233 static irqreturn_t
ahci_interrupt(int irq
, void *dev_instance
)
2235 struct ata_host
*host
= dev_instance
;
2236 struct ahci_host_priv
*hpriv
;
2237 unsigned int i
, handled
= 0;
2239 u32 irq_stat
, irq_masked
;
2243 hpriv
= host
->private_data
;
2244 mmio
= host
->iomap
[AHCI_PCI_BAR
];
2246 /* sigh. 0xffffffff is a valid return from h/w */
2247 irq_stat
= readl(mmio
+ HOST_IRQ_STAT
);
2251 irq_masked
= irq_stat
& hpriv
->port_map
;
2253 spin_lock(&host
->lock
);
2255 for (i
= 0; i
< host
->n_ports
; i
++) {
2256 struct ata_port
*ap
;
2258 if (!(irq_masked
& (1 << i
)))
2261 ap
= host
->ports
[i
];
2264 VPRINTK("port %u\n", i
);
2266 VPRINTK("port %u (no irq)\n", i
);
2267 if (ata_ratelimit())
2268 dev_printk(KERN_WARNING
, host
->dev
,
2269 "interrupt on disabled port %u\n", i
);
2275 /* HOST_IRQ_STAT behaves as level triggered latch meaning that
2276 * it should be cleared after all the port events are cleared;
2277 * otherwise, it will raise a spurious interrupt after each
2278 * valid one. Please read section 10.6.2 of ahci 1.1 for more
2281 * Also, use the unmasked value to clear interrupt as spurious
2282 * pending event on a dummy port might cause screaming IRQ.
2284 writel(irq_stat
, mmio
+ HOST_IRQ_STAT
);
2286 spin_unlock(&host
->lock
);
2290 return IRQ_RETVAL(handled
);
2293 static unsigned int ahci_qc_issue(struct ata_queued_cmd
*qc
)
2295 struct ata_port
*ap
= qc
->ap
;
2296 void __iomem
*port_mmio
= ahci_port_base(ap
);
2297 struct ahci_port_priv
*pp
= ap
->private_data
;
2299 /* Keep track of the currently active link. It will be used
2300 * in completion path to determine whether NCQ phase is in
2303 pp
->active_link
= qc
->dev
->link
;
2305 if (qc
->tf
.protocol
== ATA_PROT_NCQ
)
2306 writel(1 << qc
->tag
, port_mmio
+ PORT_SCR_ACT
);
2307 writel(1 << qc
->tag
, port_mmio
+ PORT_CMD_ISSUE
);
2309 ahci_sw_activity(qc
->dev
->link
);
2314 static bool ahci_qc_fill_rtf(struct ata_queued_cmd
*qc
)
2316 struct ahci_port_priv
*pp
= qc
->ap
->private_data
;
2317 u8
*d2h_fis
= pp
->rx_fis
+ RX_FIS_D2H_REG
;
2319 ata_tf_from_fis(d2h_fis
, &qc
->result_tf
);
2323 static void ahci_freeze(struct ata_port
*ap
)
2325 void __iomem
*port_mmio
= ahci_port_base(ap
);
2328 writel(0, port_mmio
+ PORT_IRQ_MASK
);
2331 static void ahci_thaw(struct ata_port
*ap
)
2333 void __iomem
*mmio
= ap
->host
->iomap
[AHCI_PCI_BAR
];
2334 void __iomem
*port_mmio
= ahci_port_base(ap
);
2336 struct ahci_port_priv
*pp
= ap
->private_data
;
2339 tmp
= readl(port_mmio
+ PORT_IRQ_STAT
);
2340 writel(tmp
, port_mmio
+ PORT_IRQ_STAT
);
2341 writel(1 << ap
->port_no
, mmio
+ HOST_IRQ_STAT
);
2343 /* turn IRQ back on */
2344 writel(pp
->intr_mask
, port_mmio
+ PORT_IRQ_MASK
);
2347 static void ahci_error_handler(struct ata_port
*ap
)
2349 if (!(ap
->pflags
& ATA_PFLAG_FROZEN
)) {
2350 /* restart engine */
2351 ahci_stop_engine(ap
);
2352 ahci_start_engine(ap
);
2355 sata_pmp_error_handler(ap
);
2358 static void ahci_post_internal_cmd(struct ata_queued_cmd
*qc
)
2360 struct ata_port
*ap
= qc
->ap
;
2362 /* make DMA engine forget about the failed command */
2363 if (qc
->flags
& ATA_QCFLAG_FAILED
)
2364 ahci_kick_engine(ap
);
2367 static void ahci_pmp_attach(struct ata_port
*ap
)
2369 void __iomem
*port_mmio
= ahci_port_base(ap
);
2370 struct ahci_port_priv
*pp
= ap
->private_data
;
2373 cmd
= readl(port_mmio
+ PORT_CMD
);
2374 cmd
|= PORT_CMD_PMP
;
2375 writel(cmd
, port_mmio
+ PORT_CMD
);
2377 pp
->intr_mask
|= PORT_IRQ_BAD_PMP
;
2378 writel(pp
->intr_mask
, port_mmio
+ PORT_IRQ_MASK
);
2381 static void ahci_pmp_detach(struct ata_port
*ap
)
2383 void __iomem
*port_mmio
= ahci_port_base(ap
);
2384 struct ahci_port_priv
*pp
= ap
->private_data
;
2387 cmd
= readl(port_mmio
+ PORT_CMD
);
2388 cmd
&= ~PORT_CMD_PMP
;
2389 writel(cmd
, port_mmio
+ PORT_CMD
);
2391 pp
->intr_mask
&= ~PORT_IRQ_BAD_PMP
;
2392 writel(pp
->intr_mask
, port_mmio
+ PORT_IRQ_MASK
);
2395 static int ahci_port_resume(struct ata_port
*ap
)
2398 ahci_start_port(ap
);
2400 if (sata_pmp_attached(ap
))
2401 ahci_pmp_attach(ap
);
2403 ahci_pmp_detach(ap
);
2409 static int ahci_port_suspend(struct ata_port
*ap
, pm_message_t mesg
)
2411 const char *emsg
= NULL
;
2414 rc
= ahci_deinit_port(ap
, &emsg
);
2416 ahci_power_down(ap
);
2418 ata_port_printk(ap
, KERN_ERR
, "%s (%d)\n", emsg
, rc
);
2419 ahci_start_port(ap
);
2425 static int ahci_pci_device_suspend(struct pci_dev
*pdev
, pm_message_t mesg
)
2427 struct ata_host
*host
= dev_get_drvdata(&pdev
->dev
);
2428 struct ahci_host_priv
*hpriv
= host
->private_data
;
2429 void __iomem
*mmio
= host
->iomap
[AHCI_PCI_BAR
];
2432 if (mesg
.event
& PM_EVENT_SUSPEND
&&
2433 hpriv
->flags
& AHCI_HFLAG_NO_SUSPEND
) {
2434 dev_printk(KERN_ERR
, &pdev
->dev
,
2435 "BIOS update required for suspend/resume\n");
2439 if (mesg
.event
& PM_EVENT_SLEEP
) {
2440 /* AHCI spec rev1.1 section 8.3.3:
2441 * Software must disable interrupts prior to requesting a
2442 * transition of the HBA to D3 state.
2444 ctl
= readl(mmio
+ HOST_CTL
);
2445 ctl
&= ~HOST_IRQ_EN
;
2446 writel(ctl
, mmio
+ HOST_CTL
);
2447 readl(mmio
+ HOST_CTL
); /* flush */
2450 return ata_pci_device_suspend(pdev
, mesg
);
2453 static int ahci_pci_device_resume(struct pci_dev
*pdev
)
2455 struct ata_host
*host
= dev_get_drvdata(&pdev
->dev
);
2458 rc
= ata_pci_device_do_resume(pdev
);
2462 if (pdev
->dev
.power
.power_state
.event
== PM_EVENT_SUSPEND
) {
2463 rc
= ahci_reset_controller(host
);
2467 ahci_init_controller(host
);
2470 ata_host_resume(host
);
2476 static int ahci_port_start(struct ata_port
*ap
)
2478 struct device
*dev
= ap
->host
->dev
;
2479 struct ahci_port_priv
*pp
;
2483 pp
= devm_kzalloc(dev
, sizeof(*pp
), GFP_KERNEL
);
2487 mem
= dmam_alloc_coherent(dev
, AHCI_PORT_PRIV_DMA_SZ
, &mem_dma
,
2491 memset(mem
, 0, AHCI_PORT_PRIV_DMA_SZ
);
2494 * First item in chunk of DMA memory: 32-slot command table,
2495 * 32 bytes each in size
2498 pp
->cmd_slot_dma
= mem_dma
;
2500 mem
+= AHCI_CMD_SLOT_SZ
;
2501 mem_dma
+= AHCI_CMD_SLOT_SZ
;
2504 * Second item: Received-FIS area
2507 pp
->rx_fis_dma
= mem_dma
;
2509 mem
+= AHCI_RX_FIS_SZ
;
2510 mem_dma
+= AHCI_RX_FIS_SZ
;
2513 * Third item: data area for storing a single command
2514 * and its scatter-gather table
2517 pp
->cmd_tbl_dma
= mem_dma
;
2520 * Save off initial list of interrupts to be enabled.
2521 * This could be changed later
2523 pp
->intr_mask
= DEF_PORT_IRQ
;
2525 ap
->private_data
= pp
;
2527 /* engage engines, captain */
2528 return ahci_port_resume(ap
);
2531 static void ahci_port_stop(struct ata_port
*ap
)
2533 const char *emsg
= NULL
;
2536 /* de-initialize port */
2537 rc
= ahci_deinit_port(ap
, &emsg
);
2539 ata_port_printk(ap
, KERN_WARNING
, "%s (%d)\n", emsg
, rc
);
2542 static int ahci_configure_dma_masks(struct pci_dev
*pdev
, int using_dac
)
2547 !pci_set_dma_mask(pdev
, DMA_BIT_MASK(64))) {
2548 rc
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64));
2550 rc
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2552 dev_printk(KERN_ERR
, &pdev
->dev
,
2553 "64-bit DMA enable failed\n");
2558 rc
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2560 dev_printk(KERN_ERR
, &pdev
->dev
,
2561 "32-bit DMA enable failed\n");
2564 rc
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2566 dev_printk(KERN_ERR
, &pdev
->dev
,
2567 "32-bit consistent DMA enable failed\n");
2574 static void ahci_print_info(struct ata_host
*host
)
2576 struct ahci_host_priv
*hpriv
= host
->private_data
;
2577 struct pci_dev
*pdev
= to_pci_dev(host
->dev
);
2578 void __iomem
*mmio
= host
->iomap
[AHCI_PCI_BAR
];
2579 u32 vers
, cap
, cap2
, impl
, speed
;
2580 const char *speed_s
;
2584 vers
= readl(mmio
+ HOST_VERSION
);
2587 impl
= hpriv
->port_map
;
2589 speed
= (cap
>> 20) & 0xf;
2592 else if (speed
== 2)
2594 else if (speed
== 3)
2599 pci_read_config_word(pdev
, 0x0a, &cc
);
2600 if (cc
== PCI_CLASS_STORAGE_IDE
)
2602 else if (cc
== PCI_CLASS_STORAGE_SATA
)
2604 else if (cc
== PCI_CLASS_STORAGE_RAID
)
2609 dev_printk(KERN_INFO
, &pdev
->dev
,
2610 "AHCI %02x%02x.%02x%02x "
2611 "%u slots %u ports %s Gbps 0x%x impl %s mode\n"
2614 (vers
>> 24) & 0xff,
2615 (vers
>> 16) & 0xff,
2619 ((cap
>> 8) & 0x1f) + 1,
2625 dev_printk(KERN_INFO
, &pdev
->dev
,
2632 cap
& HOST_CAP_64
? "64bit " : "",
2633 cap
& HOST_CAP_NCQ
? "ncq " : "",
2634 cap
& HOST_CAP_SNTF
? "sntf " : "",
2635 cap
& HOST_CAP_MPS
? "ilck " : "",
2636 cap
& HOST_CAP_SSS
? "stag " : "",
2637 cap
& HOST_CAP_ALPM
? "pm " : "",
2638 cap
& HOST_CAP_LED
? "led " : "",
2639 cap
& HOST_CAP_CLO
? "clo " : "",
2640 cap
& HOST_CAP_ONLY
? "only " : "",
2641 cap
& HOST_CAP_PMP
? "pmp " : "",
2642 cap
& HOST_CAP_FBS
? "fbs " : "",
2643 cap
& HOST_CAP_PIO_MULTI
? "pio " : "",
2644 cap
& HOST_CAP_SSC
? "slum " : "",
2645 cap
& HOST_CAP_PART
? "part " : "",
2646 cap
& HOST_CAP_CCC
? "ccc " : "",
2647 cap
& HOST_CAP_EMS
? "ems " : "",
2648 cap
& HOST_CAP_SXS
? "sxs " : "",
2649 cap2
& HOST_CAP2_APST
? "apst " : "",
2650 cap2
& HOST_CAP2_NVMHCI
? "nvmp " : "",
2651 cap2
& HOST_CAP2_BOH
? "boh " : ""
2655 /* On ASUS P5W DH Deluxe, the second port of PCI device 00:1f.2 is
2656 * hardwired to on-board SIMG 4726. The chipset is ICH8 and doesn't
2657 * support PMP and the 4726 either directly exports the device
2658 * attached to the first downstream port or acts as a hardware storage
2659 * controller and emulate a single ATA device (can be RAID 0/1 or some
2660 * other configuration).
2662 * When there's no device attached to the first downstream port of the
2663 * 4726, "Config Disk" appears, which is a pseudo ATA device to
2664 * configure the 4726. However, ATA emulation of the device is very
2665 * lame. It doesn't send signature D2H Reg FIS after the initial
2666 * hardreset, pukes on SRST w/ PMP==0 and has bunch of other issues.
2668 * The following function works around the problem by always using
2669 * hardreset on the port and not depending on receiving signature FIS
2670 * afterward. If signature FIS isn't received soon, ATA class is
2671 * assumed without follow-up softreset.
2673 static void ahci_p5wdh_workaround(struct ata_host
*host
)
2675 static struct dmi_system_id sysids
[] = {
2677 .ident
= "P5W DH Deluxe",
2679 DMI_MATCH(DMI_SYS_VENDOR
,
2680 "ASUSTEK COMPUTER INC"),
2681 DMI_MATCH(DMI_PRODUCT_NAME
, "P5W DH Deluxe"),
2686 struct pci_dev
*pdev
= to_pci_dev(host
->dev
);
2688 if (pdev
->bus
->number
== 0 && pdev
->devfn
== PCI_DEVFN(0x1f, 2) &&
2689 dmi_check_system(sysids
)) {
2690 struct ata_port
*ap
= host
->ports
[1];
2692 dev_printk(KERN_INFO
, &pdev
->dev
, "enabling ASUS P5W DH "
2693 "Deluxe on-board SIMG4726 workaround\n");
2695 ap
->ops
= &ahci_p5wdh_ops
;
2696 ap
->link
.flags
|= ATA_LFLAG_NO_SRST
| ATA_LFLAG_ASSUME_ATA
;
2700 /* only some SB600 ahci controllers can do 64bit DMA */
2701 static bool ahci_sb600_enable_64bit(struct pci_dev
*pdev
)
2703 static const struct dmi_system_id sysids
[] = {
2705 * The oldest version known to be broken is 0901 and
2706 * working is 1501 which was released on 2007-10-26.
2707 * Enable 64bit DMA on 1501 and anything newer.
2709 * Please read bko#9412 for more info.
2712 .ident
= "ASUS M2A-VM",
2714 DMI_MATCH(DMI_BOARD_VENDOR
,
2715 "ASUSTeK Computer INC."),
2716 DMI_MATCH(DMI_BOARD_NAME
, "M2A-VM"),
2718 .driver_data
= "20071026", /* yyyymmdd */
2722 const struct dmi_system_id
*match
;
2723 int year
, month
, date
;
2726 match
= dmi_first_match(sysids
);
2727 if (pdev
->bus
->number
!= 0 || pdev
->devfn
!= PCI_DEVFN(0x12, 0) ||
2731 dmi_get_date(DMI_BIOS_DATE
, &year
, &month
, &date
);
2732 snprintf(buf
, sizeof(buf
), "%04d%02d%02d", year
, month
, date
);
2734 if (strcmp(buf
, match
->driver_data
) >= 0) {
2735 dev_printk(KERN_WARNING
, &pdev
->dev
, "%s: enabling 64bit DMA\n",
2739 dev_printk(KERN_WARNING
, &pdev
->dev
, "%s: BIOS too old, "
2740 "forcing 32bit DMA, update BIOS\n", match
->ident
);
2745 static bool ahci_broken_system_poweroff(struct pci_dev
*pdev
)
2747 static const struct dmi_system_id broken_systems
[] = {
2749 .ident
= "HP Compaq nx6310",
2751 DMI_MATCH(DMI_SYS_VENDOR
, "Hewlett-Packard"),
2752 DMI_MATCH(DMI_PRODUCT_NAME
, "HP Compaq nx6310"),
2754 /* PCI slot number of the controller */
2755 .driver_data
= (void *)0x1FUL
,
2758 .ident
= "HP Compaq 6720s",
2760 DMI_MATCH(DMI_SYS_VENDOR
, "Hewlett-Packard"),
2761 DMI_MATCH(DMI_PRODUCT_NAME
, "HP Compaq 6720s"),
2763 /* PCI slot number of the controller */
2764 .driver_data
= (void *)0x1FUL
,
2767 { } /* terminate list */
2769 const struct dmi_system_id
*dmi
= dmi_first_match(broken_systems
);
2772 unsigned long slot
= (unsigned long)dmi
->driver_data
;
2773 /* apply the quirk only to on-board controllers */
2774 return slot
== PCI_SLOT(pdev
->devfn
);
2780 static bool ahci_broken_suspend(struct pci_dev
*pdev
)
2782 static const struct dmi_system_id sysids
[] = {
2784 * On HP dv[4-6] and HDX18 with earlier BIOSen, link
2785 * to the harddisk doesn't become online after
2786 * resuming from STR. Warn and fail suspend.
2791 DMI_MATCH(DMI_SYS_VENDOR
, "Hewlett-Packard"),
2792 DMI_MATCH(DMI_PRODUCT_NAME
,
2793 "HP Pavilion dv4 Notebook PC"),
2795 .driver_data
= "F.30", /* cutoff BIOS version */
2800 DMI_MATCH(DMI_SYS_VENDOR
, "Hewlett-Packard"),
2801 DMI_MATCH(DMI_PRODUCT_NAME
,
2802 "HP Pavilion dv5 Notebook PC"),
2804 .driver_data
= "F.16", /* cutoff BIOS version */
2809 DMI_MATCH(DMI_SYS_VENDOR
, "Hewlett-Packard"),
2810 DMI_MATCH(DMI_PRODUCT_NAME
,
2811 "HP Pavilion dv6 Notebook PC"),
2813 .driver_data
= "F.21", /* cutoff BIOS version */
2818 DMI_MATCH(DMI_SYS_VENDOR
, "Hewlett-Packard"),
2819 DMI_MATCH(DMI_PRODUCT_NAME
,
2820 "HP HDX18 Notebook PC"),
2822 .driver_data
= "F.23", /* cutoff BIOS version */
2824 { } /* terminate list */
2826 const struct dmi_system_id
*dmi
= dmi_first_match(sysids
);
2829 if (!dmi
|| pdev
->bus
->number
|| pdev
->devfn
!= PCI_DEVFN(0x1f, 2))
2832 ver
= dmi_get_system_info(DMI_BIOS_VERSION
);
2834 return !ver
|| strcmp(ver
, dmi
->driver_data
) < 0;
2837 static bool ahci_broken_online(struct pci_dev
*pdev
)
2839 #define ENCODE_BUSDEVFN(bus, slot, func) \
2840 (void *)(unsigned long)(((bus) << 8) | PCI_DEVFN((slot), (func)))
2841 static const struct dmi_system_id sysids
[] = {
2843 * There are several gigabyte boards which use
2844 * SIMG5723s configured as hardware RAID. Certain
2845 * 5723 firmware revisions shipped there keep the link
2846 * online but fail to answer properly to SRST or
2847 * IDENTIFY when no device is attached downstream
2848 * causing libata to retry quite a few times leading
2849 * to excessive detection delay.
2851 * As these firmwares respond to the second reset try
2852 * with invalid device signature, considering unknown
2853 * sig as offline works around the problem acceptably.
2856 .ident
= "EP45-DQ6",
2858 DMI_MATCH(DMI_BOARD_VENDOR
,
2859 "Gigabyte Technology Co., Ltd."),
2860 DMI_MATCH(DMI_BOARD_NAME
, "EP45-DQ6"),
2862 .driver_data
= ENCODE_BUSDEVFN(0x0a, 0x00, 0),
2865 .ident
= "EP45-DS5",
2867 DMI_MATCH(DMI_BOARD_VENDOR
,
2868 "Gigabyte Technology Co., Ltd."),
2869 DMI_MATCH(DMI_BOARD_NAME
, "EP45-DS5"),
2871 .driver_data
= ENCODE_BUSDEVFN(0x03, 0x00, 0),
2873 { } /* terminate list */
2875 #undef ENCODE_BUSDEVFN
2876 const struct dmi_system_id
*dmi
= dmi_first_match(sysids
);
2882 val
= (unsigned long)dmi
->driver_data
;
2884 return pdev
->bus
->number
== (val
>> 8) && pdev
->devfn
== (val
& 0xff);
2887 #ifdef CONFIG_ATA_ACPI
2888 static void ahci_gtf_filter_workaround(struct ata_host
*host
)
2890 static const struct dmi_system_id sysids
[] = {
2892 * Aspire 3810T issues a bunch of SATA enable commands
2893 * via _GTF including an invalid one and one which is
2894 * rejected by the device. Among the successful ones
2895 * is FPDMA non-zero offset enable which when enabled
2896 * only on the drive side leads to NCQ command
2897 * failures. Filter it out.
2900 .ident
= "Aspire 3810T",
2902 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
2903 DMI_MATCH(DMI_PRODUCT_NAME
, "Aspire 3810T"),
2905 .driver_data
= (void *)ATA_ACPI_FILTER_FPDMA_OFFSET
,
2909 const struct dmi_system_id
*dmi
= dmi_first_match(sysids
);
2910 unsigned int filter
;
2916 filter
= (unsigned long)dmi
->driver_data
;
2917 dev_printk(KERN_INFO
, host
->dev
,
2918 "applying extra ACPI _GTF filter 0x%x for %s\n",
2919 filter
, dmi
->ident
);
2921 for (i
= 0; i
< host
->n_ports
; i
++) {
2922 struct ata_port
*ap
= host
->ports
[i
];
2923 struct ata_link
*link
;
2924 struct ata_device
*dev
;
2926 ata_for_each_link(link
, ap
, EDGE
)
2927 ata_for_each_dev(dev
, link
, ALL
)
2928 dev
->gtf_filter
|= filter
;
2932 static inline void ahci_gtf_filter_workaround(struct ata_host
*host
)
2936 static int ahci_init_one(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
2938 static int printed_version
;
2939 unsigned int board_id
= ent
->driver_data
;
2940 struct ata_port_info pi
= ahci_port_info
[board_id
];
2941 const struct ata_port_info
*ppi
[] = { &pi
, NULL
};
2942 struct device
*dev
= &pdev
->dev
;
2943 struct ahci_host_priv
*hpriv
;
2944 struct ata_host
*host
;
2949 WARN_ON(ATA_MAX_QUEUE
> AHCI_MAX_CMDS
);
2951 if (!printed_version
++)
2952 dev_printk(KERN_DEBUG
, &pdev
->dev
, "version " DRV_VERSION
"\n");
2954 /* The AHCI driver can only drive the SATA ports, the PATA driver
2955 can drive them all so if both drivers are selected make sure
2956 AHCI stays out of the way */
2957 if (pdev
->vendor
== PCI_VENDOR_ID_MARVELL
&& !marvell_enable
)
2960 /* acquire resources */
2961 rc
= pcim_enable_device(pdev
);
2965 /* AHCI controllers often implement SFF compatible interface.
2966 * Grab all PCI BARs just in case.
2968 rc
= pcim_iomap_regions_request_all(pdev
, 1 << AHCI_PCI_BAR
, DRV_NAME
);
2970 pcim_pin_device(pdev
);
2974 if (pdev
->vendor
== PCI_VENDOR_ID_INTEL
&&
2975 (pdev
->device
== 0x2652 || pdev
->device
== 0x2653)) {
2978 /* ICH6s share the same PCI ID for both piix and ahci
2979 * modes. Enabling ahci mode while MAP indicates
2980 * combined mode is a bad idea. Yield to ata_piix.
2982 pci_read_config_byte(pdev
, ICH_MAP
, &map
);
2984 dev_printk(KERN_INFO
, &pdev
->dev
, "controller is in "
2985 "combined mode, can't enable AHCI mode\n");
2990 hpriv
= devm_kzalloc(dev
, sizeof(*hpriv
), GFP_KERNEL
);
2993 hpriv
->flags
|= (unsigned long)pi
.private_data
;
2995 /* MCP65 revision A1 and A2 can't do MSI */
2996 if (board_id
== board_ahci_mcp65
&&
2997 (pdev
->revision
== 0xa1 || pdev
->revision
== 0xa2))
2998 hpriv
->flags
|= AHCI_HFLAG_NO_MSI
;
3000 /* SB800 does NOT need the workaround to ignore SERR_INTERNAL */
3001 if (board_id
== board_ahci_sb700
&& pdev
->revision
>= 0x40)
3002 hpriv
->flags
&= ~AHCI_HFLAG_IGN_SERR_INTERNAL
;
3004 /* only some SB600s can do 64bit DMA */
3005 if (ahci_sb600_enable_64bit(pdev
))
3006 hpriv
->flags
&= ~AHCI_HFLAG_32BIT_ONLY
;
3008 if ((hpriv
->flags
& AHCI_HFLAG_NO_MSI
) || pci_enable_msi(pdev
))
3011 /* save initial config */
3012 ahci_save_initial_config(pdev
, hpriv
);
3015 if (hpriv
->cap
& HOST_CAP_NCQ
)
3016 pi
.flags
|= ATA_FLAG_NCQ
| ATA_FLAG_FPDMA_AA
;
3018 if (hpriv
->cap
& HOST_CAP_PMP
)
3019 pi
.flags
|= ATA_FLAG_PMP
;
3021 if (ahci_em_messages
&& (hpriv
->cap
& HOST_CAP_EMS
)) {
3023 void __iomem
*mmio
= pcim_iomap_table(pdev
)[AHCI_PCI_BAR
];
3024 u32 em_loc
= readl(mmio
+ HOST_EM_LOC
);
3025 u32 em_ctl
= readl(mmio
+ HOST_EM_CTL
);
3027 messages
= (em_ctl
& EM_CTRL_MSG_TYPE
) >> 16;
3029 /* we only support LED message type right now */
3030 if ((messages
& 0x01) && (ahci_em_messages
== 1)) {
3032 hpriv
->em_loc
= ((em_loc
>> 16) * 4);
3033 pi
.flags
|= ATA_FLAG_EM
;
3034 if (!(em_ctl
& EM_CTL_ALHD
))
3035 pi
.flags
|= ATA_FLAG_SW_ACTIVITY
;
3039 if (ahci_broken_system_poweroff(pdev
)) {
3040 pi
.flags
|= ATA_FLAG_NO_POWEROFF_SPINDOWN
;
3041 dev_info(&pdev
->dev
,
3042 "quirky BIOS, skipping spindown on poweroff\n");
3045 if (ahci_broken_suspend(pdev
)) {
3046 hpriv
->flags
|= AHCI_HFLAG_NO_SUSPEND
;
3047 dev_printk(KERN_WARNING
, &pdev
->dev
,
3048 "BIOS update required for suspend/resume\n");
3051 if (ahci_broken_online(pdev
)) {
3052 hpriv
->flags
|= AHCI_HFLAG_SRST_TOUT_IS_OFFLINE
;
3053 dev_info(&pdev
->dev
,
3054 "online status unreliable, applying workaround\n");
3057 /* CAP.NP sometimes indicate the index of the last enabled
3058 * port, at other times, that of the last possible port, so
3059 * determining the maximum port number requires looking at
3060 * both CAP.NP and port_map.
3062 n_ports
= max(ahci_nr_ports(hpriv
->cap
), fls(hpriv
->port_map
));
3064 host
= ata_host_alloc_pinfo(&pdev
->dev
, ppi
, n_ports
);
3067 host
->iomap
= pcim_iomap_table(pdev
);
3068 host
->private_data
= hpriv
;
3070 if (!(hpriv
->cap
& HOST_CAP_SSS
) || ahci_ignore_sss
)
3071 host
->flags
|= ATA_HOST_PARALLEL_SCAN
;
3073 printk(KERN_INFO
"ahci: SSS flag set, parallel bus scan disabled\n");
3075 if (pi
.flags
& ATA_FLAG_EM
)
3076 ahci_reset_em(host
);
3078 for (i
= 0; i
< host
->n_ports
; i
++) {
3079 struct ata_port
*ap
= host
->ports
[i
];
3081 ata_port_pbar_desc(ap
, AHCI_PCI_BAR
, -1, "abar");
3082 ata_port_pbar_desc(ap
, AHCI_PCI_BAR
,
3083 0x100 + ap
->port_no
* 0x80, "port");
3085 /* set initial link pm policy */
3086 ap
->pm_policy
= NOT_AVAILABLE
;
3088 /* set enclosure management message type */
3089 if (ap
->flags
& ATA_FLAG_EM
)
3090 ap
->em_message_type
= ahci_em_messages
;
3093 /* disabled/not-implemented port */
3094 if (!(hpriv
->port_map
& (1 << i
)))
3095 ap
->ops
= &ata_dummy_port_ops
;
3098 /* apply workaround for ASUS P5W DH Deluxe mainboard */
3099 ahci_p5wdh_workaround(host
);
3101 /* apply gtf filter quirk */
3102 ahci_gtf_filter_workaround(host
);
3104 /* initialize adapter */
3105 rc
= ahci_configure_dma_masks(pdev
, hpriv
->cap
& HOST_CAP_64
);
3109 rc
= ahci_reset_controller(host
);
3113 ahci_init_controller(host
);
3114 ahci_print_info(host
);
3116 pci_set_master(pdev
);
3117 return ata_host_activate(host
, pdev
->irq
, ahci_interrupt
, IRQF_SHARED
,
3121 static int __init
ahci_init(void)
3123 return pci_register_driver(&ahci_pci_driver
);
3126 static void __exit
ahci_exit(void)
3128 pci_unregister_driver(&ahci_pci_driver
);
3132 MODULE_AUTHOR("Jeff Garzik");
3133 MODULE_DESCRIPTION("AHCI SATA low-level driver");
3134 MODULE_LICENSE("GPL");
3135 MODULE_DEVICE_TABLE(pci
, ahci_pci_tbl
);
3136 MODULE_VERSION(DRV_VERSION
);
3138 module_init(ahci_init
);
3139 module_exit(ahci_exit
);