projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[libata] add DMA setup FIS auto-activate feature
[deliverable/linux.git] / drivers / ata / ahci.c
1 /*
2 * ahci.c - AHCI SATA support
3 *
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2004-2005 Red Hat, Inc.
9 *
10 *
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)
14 * any later version.
15 *
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.
20 *
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.
24 *
25 *
26 * libata documentation is available via 'make {ps|pdf}docs',
27 * as Documentation/DocBook/libata.*
28 *
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
32 *
33 */
34
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>
48
49 #define DRV_NAME "ahci"
50 #define DRV_VERSION "3.0"
51
52 /* Enclosure Management Control */
53 #define EM_CTRL_MSG_TYPE 0x000f0000
54
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
62
63 static int ahci_skip_host_reset;
64 static int ahci_ignore_sss;
65
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)");
68
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)");
71
72 static int ahci_enable_alpm(struct ata_port *ap,
73 enum link_pm policy);
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,
77 size_t size);
78 static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
79 ssize_t size);
80
81 enum {
82 AHCI_PCI_BAR = 5,
83 AHCI_MAX_PORTS = 32,
84 AHCI_MAX_SG = 168, /* hardware max is 64K */
85 AHCI_DMA_BOUNDARY = 0xffffffff,
86 AHCI_MAX_CMDS = 32,
87 AHCI_CMD_SZ = 32,
88 AHCI_CMD_SLOT_SZ = AHCI_MAX_CMDS * AHCI_CMD_SZ,
89 AHCI_RX_FIS_SZ = 256,
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 +
95 AHCI_RX_FIS_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),
102
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 */
106
107 board_ahci = 0,
108 board_ahci_vt8251 = 1,
109 board_ahci_ign_iferr = 2,
110 board_ahci_sb600 = 3,
111 board_ahci_mv = 4,
112 board_ahci_sb700 = 5, /* for SB700 and SB800 */
113 board_ahci_mcp65 = 6,
114 board_ahci_nopmp = 7,
115 board_ahci_yesncq = 8,
116
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
126 /* HOST_CTL bits */
127 HOST_RESET = (1 << 0), /* reset controller; self-clear */
128 HOST_IRQ_EN = (1 << 1), /* global IRQ enable */
129 HOST_AHCI_EN = (1 << 31), /* AHCI enabled */
130
131 /* HOST_CAP bits */
132 HOST_CAP_EMS = (1 << 6), /* Enclosure Management support */
133 HOST_CAP_SSC = (1 << 14), /* Slumber capable */
134 HOST_CAP_PMP = (1 << 17), /* Port Multiplier support */
135 HOST_CAP_CLO = (1 << 24), /* Command List Override support */
136 HOST_CAP_ALPM = (1 << 26), /* Aggressive Link PM support */
137 HOST_CAP_SSS = (1 << 27), /* Staggered Spin-up */
138 HOST_CAP_SNTF = (1 << 29), /* SNotification register */
139 HOST_CAP_NCQ = (1 << 30), /* Native Command Queueing */
140 HOST_CAP_64 = (1 << 31), /* PCI DAC (64-bit DMA) support */
141
142 /* registers for each SATA port */
143 PORT_LST_ADDR = 0x00, /* command list DMA addr */
144 PORT_LST_ADDR_HI = 0x04, /* command list DMA addr hi */
145 PORT_FIS_ADDR = 0x08, /* FIS rx buf addr */
146 PORT_FIS_ADDR_HI = 0x0c, /* FIS rx buf addr hi */
147 PORT_IRQ_STAT = 0x10, /* interrupt status */
148 PORT_IRQ_MASK = 0x14, /* interrupt enable/disable mask */
149 PORT_CMD = 0x18, /* port command */
150 PORT_TFDATA = 0x20, /* taskfile data */
151 PORT_SIG = 0x24, /* device TF signature */
152 PORT_CMD_ISSUE = 0x38, /* command issue */
153 PORT_SCR_STAT = 0x28, /* SATA phy register: SStatus */
154 PORT_SCR_CTL = 0x2c, /* SATA phy register: SControl */
155 PORT_SCR_ERR = 0x30, /* SATA phy register: SError */
156 PORT_SCR_ACT = 0x34, /* SATA phy register: SActive */
157 PORT_SCR_NTF = 0x3c, /* SATA phy register: SNotification */
158
159 /* PORT_IRQ_{STAT,MASK} bits */
160 PORT_IRQ_COLD_PRES = (1 << 31), /* cold presence detect */
161 PORT_IRQ_TF_ERR = (1 << 30), /* task file error */
162 PORT_IRQ_HBUS_ERR = (1 << 29), /* host bus fatal error */
163 PORT_IRQ_HBUS_DATA_ERR = (1 << 28), /* host bus data error */
164 PORT_IRQ_IF_ERR = (1 << 27), /* interface fatal error */
165 PORT_IRQ_IF_NONFATAL = (1 << 26), /* interface non-fatal error */
166 PORT_IRQ_OVERFLOW = (1 << 24), /* xfer exhausted available S/G */
167 PORT_IRQ_BAD_PMP = (1 << 23), /* incorrect port multiplier */
168
169 PORT_IRQ_PHYRDY = (1 << 22), /* PhyRdy changed */
170 PORT_IRQ_DEV_ILCK = (1 << 7), /* device interlock */
171 PORT_IRQ_CONNECT = (1 << 6), /* port connect change status */
172 PORT_IRQ_SG_DONE = (1 << 5), /* descriptor processed */
173 PORT_IRQ_UNK_FIS = (1 << 4), /* unknown FIS rx'd */
174 PORT_IRQ_SDB_FIS = (1 << 3), /* Set Device Bits FIS rx'd */
175 PORT_IRQ_DMAS_FIS = (1 << 2), /* DMA Setup FIS rx'd */
176 PORT_IRQ_PIOS_FIS = (1 << 1), /* PIO Setup FIS rx'd */
177 PORT_IRQ_D2H_REG_FIS = (1 << 0), /* D2H Register FIS rx'd */
178
179 PORT_IRQ_FREEZE = PORT_IRQ_HBUS_ERR |
180 PORT_IRQ_IF_ERR |
181 PORT_IRQ_CONNECT |
182 PORT_IRQ_PHYRDY |
183 PORT_IRQ_UNK_FIS |
184 PORT_IRQ_BAD_PMP,
185 PORT_IRQ_ERROR = PORT_IRQ_FREEZE |
186 PORT_IRQ_TF_ERR |
187 PORT_IRQ_HBUS_DATA_ERR,
188 DEF_PORT_IRQ = PORT_IRQ_ERROR | PORT_IRQ_SG_DONE |
189 PORT_IRQ_SDB_FIS | PORT_IRQ_DMAS_FIS |
190 PORT_IRQ_PIOS_FIS | PORT_IRQ_D2H_REG_FIS,
191
192 /* PORT_CMD bits */
193 PORT_CMD_ASP = (1 << 27), /* Aggressive Slumber/Partial */
194 PORT_CMD_ALPE = (1 << 26), /* Aggressive Link PM enable */
195 PORT_CMD_ATAPI = (1 << 24), /* Device is ATAPI */
196 PORT_CMD_PMP = (1 << 17), /* PMP attached */
197 PORT_CMD_LIST_ON = (1 << 15), /* cmd list DMA engine running */
198 PORT_CMD_FIS_ON = (1 << 14), /* FIS DMA engine running */
199 PORT_CMD_FIS_RX = (1 << 4), /* Enable FIS receive DMA engine */
200 PORT_CMD_CLO = (1 << 3), /* Command list override */
201 PORT_CMD_POWER_ON = (1 << 2), /* Power up device */
202 PORT_CMD_SPIN_UP = (1 << 1), /* Spin up device */
203 PORT_CMD_START = (1 << 0), /* Enable port DMA engine */
204
205 PORT_CMD_ICC_MASK = (0xf << 28), /* i/f ICC state mask */
206 PORT_CMD_ICC_ACTIVE = (0x1 << 28), /* Put i/f in active state */
207 PORT_CMD_ICC_PARTIAL = (0x2 << 28), /* Put i/f in partial state */
208 PORT_CMD_ICC_SLUMBER = (0x6 << 28), /* Put i/f in slumber state */
209
210 /* hpriv->flags bits */
211 AHCI_HFLAG_NO_NCQ = (1 << 0),
212 AHCI_HFLAG_IGN_IRQ_IF_ERR = (1 << 1), /* ignore IRQ_IF_ERR */
213 AHCI_HFLAG_IGN_SERR_INTERNAL = (1 << 2), /* ignore SERR_INTERNAL */
214 AHCI_HFLAG_32BIT_ONLY = (1 << 3), /* force 32bit */
215 AHCI_HFLAG_MV_PATA = (1 << 4), /* PATA port */
216 AHCI_HFLAG_NO_MSI = (1 << 5), /* no PCI MSI */
217 AHCI_HFLAG_NO_PMP = (1 << 6), /* no PMP */
218 AHCI_HFLAG_NO_HOTPLUG = (1 << 7), /* ignore PxSERR.DIAG.N */
219 AHCI_HFLAG_SECT255 = (1 << 8), /* max 255 sectors */
220 AHCI_HFLAG_YES_NCQ = (1 << 9), /* force NCQ cap on */
221 AHCI_HFLAG_NO_SUSPEND = (1 << 10), /* don't suspend */
222 AHCI_HFLAG_SRST_TOUT_IS_OFFLINE = (1 << 11), /* treat SRST timeout as
223 link offline */
224
225 /* ap->flags bits */
226
227 AHCI_FLAG_COMMON = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
228 ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
229 ATA_FLAG_ACPI_SATA | ATA_FLAG_AN |
230 ATA_FLAG_IPM,
231
232 ICH_MAP = 0x90, /* ICH MAP register */
233
234 /* em constants */
235 EM_MAX_SLOTS = 8,
236 EM_MAX_RETRY = 5,
237
238 /* em_ctl bits */
239 EM_CTL_RST = (1 << 9), /* Reset */
240 EM_CTL_TM = (1 << 8), /* Transmit Message */
241 EM_CTL_ALHD = (1 << 26), /* Activity LED */
242 };
243
244 struct ahci_cmd_hdr {
245 __le32 opts;
246 __le32 status;
247 __le32 tbl_addr;
248 __le32 tbl_addr_hi;
249 __le32 reserved[4];
250 };
251
252 struct ahci_sg {
253 __le32 addr;
254 __le32 addr_hi;
255 __le32 reserved;
256 __le32 flags_size;
257 };
258
259 struct ahci_em_priv {
260 enum sw_activity blink_policy;
261 struct timer_list timer;
262 unsigned long saved_activity;
263 unsigned long activity;
264 unsigned long led_state;
265 };
266
267 struct ahci_host_priv {
268 unsigned int flags; /* AHCI_HFLAG_* */
269 u32 cap; /* cap to use */
270 u32 port_map; /* port map to use */
271 u32 saved_cap; /* saved initial cap */
272 u32 saved_port_map; /* saved initial port_map */
273 u32 em_loc; /* enclosure management location */
274 };
275
276 struct ahci_port_priv {
277 struct ata_link *active_link;
278 struct ahci_cmd_hdr *cmd_slot;
279 dma_addr_t cmd_slot_dma;
280 void *cmd_tbl;
281 dma_addr_t cmd_tbl_dma;
282 void *rx_fis;
283 dma_addr_t rx_fis_dma;
284 /* for NCQ spurious interrupt analysis */
285 unsigned int ncq_saw_d2h:1;
286 unsigned int ncq_saw_dmas:1;
287 unsigned int ncq_saw_sdb:1;
288 u32 intr_mask; /* interrupts to enable */
289 /* enclosure management info per PM slot */
290 struct ahci_em_priv em_priv[EM_MAX_SLOTS];
291 };
292
293 static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
294 static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
295 static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
296 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
297 static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc);
298 static int ahci_port_start(struct ata_port *ap);
299 static void ahci_port_stop(struct ata_port *ap);
300 static void ahci_qc_prep(struct ata_queued_cmd *qc);
301 static void ahci_freeze(struct ata_port *ap);
302 static void ahci_thaw(struct ata_port *ap);
303 static void ahci_pmp_attach(struct ata_port *ap);
304 static void ahci_pmp_detach(struct ata_port *ap);
305 static int ahci_softreset(struct ata_link *link, unsigned int *class,
306 unsigned long deadline);
307 static int ahci_sb600_softreset(struct ata_link *link, unsigned int *class,
308 unsigned long deadline);
309 static int ahci_hardreset(struct ata_link *link, unsigned int *class,
310 unsigned long deadline);
311 static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,
312 unsigned long deadline);
313 static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class,
314 unsigned long deadline);
315 static void ahci_postreset(struct ata_link *link, unsigned int *class);
316 static void ahci_error_handler(struct ata_port *ap);
317 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
318 static int ahci_port_resume(struct ata_port *ap);
319 static void ahci_dev_config(struct ata_device *dev);
320 static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
321 u32 opts);
322 #ifdef CONFIG_PM
323 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg);
324 static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
325 static int ahci_pci_device_resume(struct pci_dev *pdev);
326 #endif
327 static ssize_t ahci_activity_show(struct ata_device *dev, char *buf);
328 static ssize_t ahci_activity_store(struct ata_device *dev,
329 enum sw_activity val);
330 static void ahci_init_sw_activity(struct ata_link *link);
331
332 static struct device_attribute *ahci_shost_attrs[] = {
333 &dev_attr_link_power_management_policy,
334 &dev_attr_em_message_type,
335 &dev_attr_em_message,
336 NULL
337 };
338
339 static struct device_attribute *ahci_sdev_attrs[] = {
340 &dev_attr_sw_activity,
341 &dev_attr_unload_heads,
342 NULL
343 };
344
345 static struct scsi_host_template ahci_sht = {
346 ATA_NCQ_SHT(DRV_NAME),
347 .can_queue = AHCI_MAX_CMDS - 1,
348 .sg_tablesize = AHCI_MAX_SG,
349 .dma_boundary = AHCI_DMA_BOUNDARY,
350 .shost_attrs = ahci_shost_attrs,
351 .sdev_attrs = ahci_sdev_attrs,
352 };
353
354 static struct ata_port_operations ahci_ops = {
355 .inherits = &sata_pmp_port_ops,
356
357 .qc_defer = sata_pmp_qc_defer_cmd_switch,
358 .qc_prep = ahci_qc_prep,
359 .qc_issue = ahci_qc_issue,
360 .qc_fill_rtf = ahci_qc_fill_rtf,
361
362 .freeze = ahci_freeze,
363 .thaw = ahci_thaw,
364 .softreset = ahci_softreset,
365 .hardreset = ahci_hardreset,
366 .postreset = ahci_postreset,
367 .pmp_softreset = ahci_softreset,
368 .error_handler = ahci_error_handler,
369 .post_internal_cmd = ahci_post_internal_cmd,
370 .dev_config = ahci_dev_config,
371
372 .scr_read = ahci_scr_read,
373 .scr_write = ahci_scr_write,
374 .pmp_attach = ahci_pmp_attach,
375 .pmp_detach = ahci_pmp_detach,
376
377 .enable_pm = ahci_enable_alpm,
378 .disable_pm = ahci_disable_alpm,
379 .em_show = ahci_led_show,
380 .em_store = ahci_led_store,
381 .sw_activity_show = ahci_activity_show,
382 .sw_activity_store = ahci_activity_store,
383 #ifdef CONFIG_PM
384 .port_suspend = ahci_port_suspend,
385 .port_resume = ahci_port_resume,
386 #endif
387 .port_start = ahci_port_start,
388 .port_stop = ahci_port_stop,
389 };
390
391 static struct ata_port_operations ahci_vt8251_ops = {
392 .inherits = &ahci_ops,
393 .hardreset = ahci_vt8251_hardreset,
394 };
395
396 static struct ata_port_operations ahci_p5wdh_ops = {
397 .inherits = &ahci_ops,
398 .hardreset = ahci_p5wdh_hardreset,
399 };
400
401 static struct ata_port_operations ahci_sb600_ops = {
402 .inherits = &ahci_ops,
403 .softreset = ahci_sb600_softreset,
404 .pmp_softreset = ahci_sb600_softreset,
405 };
406
407 #define AHCI_HFLAGS(flags) .private_data = (void *)(flags)
408
409 static const struct ata_port_info ahci_port_info[] = {
410 [board_ahci] =
411 {
412 .flags = AHCI_FLAG_COMMON,
413 .pio_mask = ATA_PIO4,
414 .udma_mask = ATA_UDMA6,
415 .port_ops = &ahci_ops,
416 },
417 [board_ahci_vt8251] =
418 {
419 AHCI_HFLAGS (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_PMP),
420 .flags = AHCI_FLAG_COMMON,
421 .pio_mask = ATA_PIO4,
422 .udma_mask = ATA_UDMA6,
423 .port_ops = &ahci_vt8251_ops,
424 },
425 [board_ahci_ign_iferr] =
426 {
427 AHCI_HFLAGS (AHCI_HFLAG_IGN_IRQ_IF_ERR),
428 .flags = AHCI_FLAG_COMMON,
429 .pio_mask = ATA_PIO4,
430 .udma_mask = ATA_UDMA6,
431 .port_ops = &ahci_ops,
432 },
433 [board_ahci_sb600] =
434 {
435 AHCI_HFLAGS (AHCI_HFLAG_IGN_SERR_INTERNAL |
436 AHCI_HFLAG_NO_MSI | AHCI_HFLAG_SECT255),
437 .flags = AHCI_FLAG_COMMON,
438 .pio_mask = ATA_PIO4,
439 .udma_mask = ATA_UDMA6,
440 .port_ops = &ahci_sb600_ops,
441 },
442 [board_ahci_mv] =
443 {
444 AHCI_HFLAGS (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_MSI |
445 AHCI_HFLAG_MV_PATA | AHCI_HFLAG_NO_PMP),
446 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
447 ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
448 .pio_mask = ATA_PIO4,
449 .udma_mask = ATA_UDMA6,
450 .port_ops = &ahci_ops,
451 },
452 [board_ahci_sb700] = /* for SB700 and SB800 */
453 {
454 AHCI_HFLAGS (AHCI_HFLAG_IGN_SERR_INTERNAL),
455 .flags = AHCI_FLAG_COMMON,
456 .pio_mask = ATA_PIO4,
457 .udma_mask = ATA_UDMA6,
458 .port_ops = &ahci_sb600_ops,
459 },
460 [board_ahci_mcp65] =
461 {
462 AHCI_HFLAGS (AHCI_HFLAG_YES_NCQ),
463 .flags = AHCI_FLAG_COMMON,
464 .pio_mask = ATA_PIO4,
465 .udma_mask = ATA_UDMA6,
466 .port_ops = &ahci_ops,
467 },
468 [board_ahci_nopmp] =
469 {
470 AHCI_HFLAGS (AHCI_HFLAG_NO_PMP),
471 .flags = AHCI_FLAG_COMMON,
472 .pio_mask = ATA_PIO4,
473 .udma_mask = ATA_UDMA6,
474 .port_ops = &ahci_ops,
475 },
476 /* board_ahci_yesncq */
477 {
478 AHCI_HFLAGS (AHCI_HFLAG_YES_NCQ),
479 .flags = AHCI_FLAG_COMMON,
480 .pio_mask = ATA_PIO4,
481 .udma_mask = ATA_UDMA6,
482 .port_ops = &ahci_ops,
483 },
484 };
485
486 static const struct pci_device_id ahci_pci_tbl[] = {
487 /* Intel */
488 { PCI_VDEVICE(INTEL, 0x2652), board_ahci }, /* ICH6 */
489 { PCI_VDEVICE(INTEL, 0x2653), board_ahci }, /* ICH6M */
490 { PCI_VDEVICE(INTEL, 0x27c1), board_ahci }, /* ICH7 */
491 { PCI_VDEVICE(INTEL, 0x27c5), board_ahci }, /* ICH7M */
492 { PCI_VDEVICE(INTEL, 0x27c3), board_ahci }, /* ICH7R */
493 { PCI_VDEVICE(AL, 0x5288), board_ahci_ign_iferr }, /* ULi M5288 */
494 { PCI_VDEVICE(INTEL, 0x2681), board_ahci }, /* ESB2 */
495 { PCI_VDEVICE(INTEL, 0x2682), board_ahci }, /* ESB2 */
496 { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */
497 { PCI_VDEVICE(INTEL, 0x27c6), board_ahci }, /* ICH7-M DH */
498 { PCI_VDEVICE(INTEL, 0x2821), board_ahci }, /* ICH8 */
499 { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* ICH8 */
500 { PCI_VDEVICE(INTEL, 0x2824), board_ahci }, /* ICH8 */
501 { PCI_VDEVICE(INTEL, 0x2829), board_ahci }, /* ICH8M */
502 { PCI_VDEVICE(INTEL, 0x282a), board_ahci }, /* ICH8M */
503 { PCI_VDEVICE(INTEL, 0x2922), board_ahci }, /* ICH9 */
504 { PCI_VDEVICE(INTEL, 0x2923), board_ahci }, /* ICH9 */
505 { PCI_VDEVICE(INTEL, 0x2924), board_ahci }, /* ICH9 */
506 { PCI_VDEVICE(INTEL, 0x2925), board_ahci }, /* ICH9 */
507 { PCI_VDEVICE(INTEL, 0x2927), board_ahci }, /* ICH9 */
508 { PCI_VDEVICE(INTEL, 0x2929), board_ahci }, /* ICH9M */
509 { PCI_VDEVICE(INTEL, 0x292a), board_ahci }, /* ICH9M */
510 { PCI_VDEVICE(INTEL, 0x292b), board_ahci }, /* ICH9M */
511 { PCI_VDEVICE(INTEL, 0x292c), board_ahci }, /* ICH9M */
512 { PCI_VDEVICE(INTEL, 0x292f), board_ahci }, /* ICH9M */
513 { PCI_VDEVICE(INTEL, 0x294d), board_ahci }, /* ICH9 */
514 { PCI_VDEVICE(INTEL, 0x294e), board_ahci }, /* ICH9M */
515 { PCI_VDEVICE(INTEL, 0x502a), board_ahci }, /* Tolapai */
516 { PCI_VDEVICE(INTEL, 0x502b), board_ahci }, /* Tolapai */
517 { PCI_VDEVICE(INTEL, 0x3a05), board_ahci }, /* ICH10 */
518 { PCI_VDEVICE(INTEL, 0x3a22), board_ahci }, /* ICH10 */
519 { PCI_VDEVICE(INTEL, 0x3a25), board_ahci }, /* ICH10 */
520 { PCI_VDEVICE(INTEL, 0x3b22), board_ahci }, /* PCH AHCI */
521 { PCI_VDEVICE(INTEL, 0x3b23), board_ahci }, /* PCH AHCI */
522 { PCI_VDEVICE(INTEL, 0x3b24), board_ahci }, /* PCH RAID */
523 { PCI_VDEVICE(INTEL, 0x3b25), board_ahci }, /* PCH RAID */
524 { PCI_VDEVICE(INTEL, 0x3b29), board_ahci }, /* PCH AHCI */
525 { PCI_VDEVICE(INTEL, 0x3b2b), board_ahci }, /* PCH RAID */
526 { PCI_VDEVICE(INTEL, 0x3b2c), board_ahci }, /* PCH RAID */
527 { PCI_VDEVICE(INTEL, 0x3b2f), board_ahci }, /* PCH AHCI */
528
529 /* JMicron 360/1/3/5/6, match class to avoid IDE function */
530 { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
531 PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff, board_ahci_ign_iferr },
532
533 /* ATI */
534 { PCI_VDEVICE(ATI, 0x4380), board_ahci_sb600 }, /* ATI SB600 */
535 { PCI_VDEVICE(ATI, 0x4390), board_ahci_sb700 }, /* ATI SB700/800 */
536 { PCI_VDEVICE(ATI, 0x4391), board_ahci_sb700 }, /* ATI SB700/800 */
537 { PCI_VDEVICE(ATI, 0x4392), board_ahci_sb700 }, /* ATI SB700/800 */
538 { PCI_VDEVICE(ATI, 0x4393), board_ahci_sb700 }, /* ATI SB700/800 */
539 { PCI_VDEVICE(ATI, 0x4394), board_ahci_sb700 }, /* ATI SB700/800 */
540 { PCI_VDEVICE(ATI, 0x4395), board_ahci_sb700 }, /* ATI SB700/800 */
541
542 /* VIA */
543 { PCI_VDEVICE(VIA, 0x3349), board_ahci_vt8251 }, /* VIA VT8251 */
544 { PCI_VDEVICE(VIA, 0x6287), board_ahci_vt8251 }, /* VIA VT8251 */
545
546 /* NVIDIA */
547 { PCI_VDEVICE(NVIDIA, 0x044c), board_ahci_mcp65 }, /* MCP65 */
548 { PCI_VDEVICE(NVIDIA, 0x044d), board_ahci_mcp65 }, /* MCP65 */
549 { PCI_VDEVICE(NVIDIA, 0x044e), board_ahci_mcp65 }, /* MCP65 */
550 { PCI_VDEVICE(NVIDIA, 0x044f), board_ahci_mcp65 }, /* MCP65 */
551 { PCI_VDEVICE(NVIDIA, 0x045c), board_ahci_mcp65 }, /* MCP65 */
552 { PCI_VDEVICE(NVIDIA, 0x045d), board_ahci_mcp65 }, /* MCP65 */
553 { PCI_VDEVICE(NVIDIA, 0x045e), board_ahci_mcp65 }, /* MCP65 */
554 { PCI_VDEVICE(NVIDIA, 0x045f), board_ahci_mcp65 }, /* MCP65 */
555 { PCI_VDEVICE(NVIDIA, 0x0550), board_ahci_yesncq }, /* MCP67 */
556 { PCI_VDEVICE(NVIDIA, 0x0551), board_ahci_yesncq }, /* MCP67 */
557 { PCI_VDEVICE(NVIDIA, 0x0552), board_ahci_yesncq }, /* MCP67 */
558 { PCI_VDEVICE(NVIDIA, 0x0553), board_ahci_yesncq }, /* MCP67 */
559 { PCI_VDEVICE(NVIDIA, 0x0554), board_ahci_yesncq }, /* MCP67 */
560 { PCI_VDEVICE(NVIDIA, 0x0555), board_ahci_yesncq }, /* MCP67 */
561 { PCI_VDEVICE(NVIDIA, 0x0556), board_ahci_yesncq }, /* MCP67 */
562 { PCI_VDEVICE(NVIDIA, 0x0557), board_ahci_yesncq }, /* MCP67 */
563 { PCI_VDEVICE(NVIDIA, 0x0558), board_ahci_yesncq }, /* MCP67 */
564 { PCI_VDEVICE(NVIDIA, 0x0559), board_ahci_yesncq }, /* MCP67 */
565 { PCI_VDEVICE(NVIDIA, 0x055a), board_ahci_yesncq }, /* MCP67 */
566 { PCI_VDEVICE(NVIDIA, 0x055b), board_ahci_yesncq }, /* MCP67 */
567 { PCI_VDEVICE(NVIDIA, 0x07f0), board_ahci_yesncq }, /* MCP73 */
568 { PCI_VDEVICE(NVIDIA, 0x07f1), board_ahci_yesncq }, /* MCP73 */
569 { PCI_VDEVICE(NVIDIA, 0x07f2), board_ahci_yesncq }, /* MCP73 */
570 { PCI_VDEVICE(NVIDIA, 0x07f3), board_ahci_yesncq }, /* MCP73 */
571 { PCI_VDEVICE(NVIDIA, 0x07f4), board_ahci_yesncq }, /* MCP73 */
572 { PCI_VDEVICE(NVIDIA, 0x07f5), board_ahci_yesncq }, /* MCP73 */
573 { PCI_VDEVICE(NVIDIA, 0x07f6), board_ahci_yesncq }, /* MCP73 */
574 { PCI_VDEVICE(NVIDIA, 0x07f7), board_ahci_yesncq }, /* MCP73 */
575 { PCI_VDEVICE(NVIDIA, 0x07f8), board_ahci_yesncq }, /* MCP73 */
576 { PCI_VDEVICE(NVIDIA, 0x07f9), board_ahci_yesncq }, /* MCP73 */
577 { PCI_VDEVICE(NVIDIA, 0x07fa), board_ahci_yesncq }, /* MCP73 */
578 { PCI_VDEVICE(NVIDIA, 0x07fb), board_ahci_yesncq }, /* MCP73 */
579 { PCI_VDEVICE(NVIDIA, 0x0ad0), board_ahci }, /* MCP77 */
580 { PCI_VDEVICE(NVIDIA, 0x0ad1), board_ahci }, /* MCP77 */
581 { PCI_VDEVICE(NVIDIA, 0x0ad2), board_ahci }, /* MCP77 */
582 { PCI_VDEVICE(NVIDIA, 0x0ad3), board_ahci }, /* MCP77 */
583 { PCI_VDEVICE(NVIDIA, 0x0ad4), board_ahci }, /* MCP77 */
584 { PCI_VDEVICE(NVIDIA, 0x0ad5), board_ahci }, /* MCP77 */
585 { PCI_VDEVICE(NVIDIA, 0x0ad6), board_ahci }, /* MCP77 */
586 { PCI_VDEVICE(NVIDIA, 0x0ad7), board_ahci }, /* MCP77 */
587 { PCI_VDEVICE(NVIDIA, 0x0ad8), board_ahci }, /* MCP77 */
588 { PCI_VDEVICE(NVIDIA, 0x0ad9), board_ahci }, /* MCP77 */
589 { PCI_VDEVICE(NVIDIA, 0x0ada), board_ahci }, /* MCP77 */
590 { PCI_VDEVICE(NVIDIA, 0x0adb), board_ahci }, /* MCP77 */
591 { PCI_VDEVICE(NVIDIA, 0x0ab4), board_ahci }, /* MCP79 */
592 { PCI_VDEVICE(NVIDIA, 0x0ab5), board_ahci }, /* MCP79 */
593 { PCI_VDEVICE(NVIDIA, 0x0ab6), board_ahci }, /* MCP79 */
594 { PCI_VDEVICE(NVIDIA, 0x0ab7), board_ahci }, /* MCP79 */
595 { PCI_VDEVICE(NVIDIA, 0x0ab8), board_ahci }, /* MCP79 */
596 { PCI_VDEVICE(NVIDIA, 0x0ab9), board_ahci }, /* MCP79 */
597 { PCI_VDEVICE(NVIDIA, 0x0aba), board_ahci }, /* MCP79 */
598 { PCI_VDEVICE(NVIDIA, 0x0abb), board_ahci }, /* MCP79 */
599 { PCI_VDEVICE(NVIDIA, 0x0abc), board_ahci }, /* MCP79 */
600 { PCI_VDEVICE(NVIDIA, 0x0abd), board_ahci }, /* MCP79 */
601 { PCI_VDEVICE(NVIDIA, 0x0abe), board_ahci }, /* MCP79 */
602 { PCI_VDEVICE(NVIDIA, 0x0abf), board_ahci }, /* MCP79 */
603 { PCI_VDEVICE(NVIDIA, 0x0d84), board_ahci }, /* MCP89 */
604 { PCI_VDEVICE(NVIDIA, 0x0d85), board_ahci }, /* MCP89 */
605 { PCI_VDEVICE(NVIDIA, 0x0d86), board_ahci }, /* MCP89 */
606 { PCI_VDEVICE(NVIDIA, 0x0d87), board_ahci }, /* MCP89 */
607 { PCI_VDEVICE(NVIDIA, 0x0d88), board_ahci }, /* MCP89 */
608 { PCI_VDEVICE(NVIDIA, 0x0d89), board_ahci }, /* MCP89 */
609 { PCI_VDEVICE(NVIDIA, 0x0d8a), board_ahci }, /* MCP89 */
610 { PCI_VDEVICE(NVIDIA, 0x0d8b), board_ahci }, /* MCP89 */
611 { PCI_VDEVICE(NVIDIA, 0x0d8c), board_ahci }, /* MCP89 */
612 { PCI_VDEVICE(NVIDIA, 0x0d8d), board_ahci }, /* MCP89 */
613 { PCI_VDEVICE(NVIDIA, 0x0d8e), board_ahci }, /* MCP89 */
614 { PCI_VDEVICE(NVIDIA, 0x0d8f), board_ahci }, /* MCP89 */
615
616 /* SiS */
617 { PCI_VDEVICE(SI, 0x1184), board_ahci }, /* SiS 966 */
618 { PCI_VDEVICE(SI, 0x1185), board_ahci }, /* SiS 968 */
619 { PCI_VDEVICE(SI, 0x0186), board_ahci }, /* SiS 968 */
620
621 /* Marvell */
622 { PCI_VDEVICE(MARVELL, 0x6145), board_ahci_mv }, /* 6145 */
623 { PCI_VDEVICE(MARVELL, 0x6121), board_ahci_mv }, /* 6121 */
624
625 /* Promise */
626 { PCI_VDEVICE(PROMISE, 0x3f20), board_ahci }, /* PDC42819 */
627
628 /* Generic, PCI class code for AHCI */
629 { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
630 PCI_CLASS_STORAGE_SATA_AHCI, 0xffffff, board_ahci },
631
632 { } /* terminate list */
633 };
634
635
636 static struct pci_driver ahci_pci_driver = {
637 .name = DRV_NAME,
638 .id_table = ahci_pci_tbl,
639 .probe = ahci_init_one,
640 .remove = ata_pci_remove_one,
641 #ifdef CONFIG_PM
642 .suspend = ahci_pci_device_suspend,
643 .resume = ahci_pci_device_resume,
644 #endif
645 };
646
647 static int ahci_em_messages = 1;
648 module_param(ahci_em_messages, int, 0444);
649 /* add other LED protocol types when they become supported */
650 MODULE_PARM_DESC(ahci_em_messages,
651 "Set AHCI Enclosure Management Message type (0 = disabled, 1 = LED");
652
653 #if defined(CONFIG_PATA_MARVELL) || defined(CONFIG_PATA_MARVELL_MODULE)
654 static int marvell_enable;
655 #else
656 static int marvell_enable = 1;
657 #endif
658 module_param(marvell_enable, int, 0644);
659 MODULE_PARM_DESC(marvell_enable, "Marvell SATA via AHCI (1 = enabled)");
660
661
662 static inline int ahci_nr_ports(u32 cap)
663 {
664 return (cap & 0x1f) + 1;
665 }
666
667 static inline void __iomem *__ahci_port_base(struct ata_host *host,
668 unsigned int port_no)
669 {
670 void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
671
672 return mmio + 0x100 + (port_no * 0x80);
673 }
674
675 static inline void __iomem *ahci_port_base(struct ata_port *ap)
676 {
677 return __ahci_port_base(ap->host, ap->port_no);
678 }
679
680 static void ahci_enable_ahci(void __iomem *mmio)
681 {
682 int i;
683 u32 tmp;
684
685 /* turn on AHCI_EN */
686 tmp = readl(mmio + HOST_CTL);
687 if (tmp & HOST_AHCI_EN)
688 return;
689
690 /* Some controllers need AHCI_EN to be written multiple times.
691 * Try a few times before giving up.
692 */
693 for (i = 0; i < 5; i++) {
694 tmp |= HOST_AHCI_EN;
695 writel(tmp, mmio + HOST_CTL);
696 tmp = readl(mmio + HOST_CTL); /* flush && sanity check */
697 if (tmp & HOST_AHCI_EN)
698 return;
699 msleep(10);
700 }
701
702 WARN_ON(1);
703 }
704
705 /**
706 * ahci_save_initial_config - Save and fixup initial config values
707 * @pdev: target PCI device
708 * @hpriv: host private area to store config values
709 *
710 * Some registers containing configuration info might be setup by
711 * BIOS and might be cleared on reset. This function saves the
712 * initial values of those registers into @hpriv such that they
713 * can be restored after controller reset.
714 *
715 * If inconsistent, config values are fixed up by this function.
716 *
717 * LOCKING:
718 * None.
719 */
720 static void ahci_save_initial_config(struct pci_dev *pdev,
721 struct ahci_host_priv *hpriv)
722 {
723 void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
724 u32 cap, port_map;
725 int i;
726 int mv;
727
728 /* make sure AHCI mode is enabled before accessing CAP */
729 ahci_enable_ahci(mmio);
730
731 /* Values prefixed with saved_ are written back to host after
732 * reset. Values without are used for driver operation.
733 */
734 hpriv->saved_cap = cap = readl(mmio + HOST_CAP);
735 hpriv->saved_port_map = port_map = readl(mmio + HOST_PORTS_IMPL);
736
737 /* some chips have errata preventing 64bit use */
738 if ((cap & HOST_CAP_64) && (hpriv->flags & AHCI_HFLAG_32BIT_ONLY)) {
739 dev_printk(KERN_INFO, &pdev->dev,
740 "controller can't do 64bit DMA, forcing 32bit\n");
741 cap &= ~HOST_CAP_64;
742 }
743
744 if ((cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_NO_NCQ)) {
745 dev_printk(KERN_INFO, &pdev->dev,
746 "controller can't do NCQ, turning off CAP_NCQ\n");
747 cap &= ~HOST_CAP_NCQ;
748 }
749
750 if (!(cap & HOST_CAP_NCQ) && (hpriv->flags & AHCI_HFLAG_YES_NCQ)) {
751 dev_printk(KERN_INFO, &pdev->dev,
752 "controller can do NCQ, turning on CAP_NCQ\n");
753 cap |= HOST_CAP_NCQ;
754 }
755
756 if ((cap & HOST_CAP_PMP) && (hpriv->flags & AHCI_HFLAG_NO_PMP)) {
757 dev_printk(KERN_INFO, &pdev->dev,
758 "controller can't do PMP, turning off CAP_PMP\n");
759 cap &= ~HOST_CAP_PMP;
760 }
761
762 if (pdev->vendor == PCI_VENDOR_ID_JMICRON && pdev->device == 0x2361 &&
763 port_map != 1) {
764 dev_printk(KERN_INFO, &pdev->dev,
765 "JMB361 has only one port, port_map 0x%x -> 0x%x\n",
766 port_map, 1);
767 port_map = 1;
768 }
769
770 /*
771 * Temporary Marvell 6145 hack: PATA port presence
772 * is asserted through the standard AHCI port
773 * presence register, as bit 4 (counting from 0)
774 */
775 if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
776 if (pdev->device == 0x6121)
777 mv = 0x3;
778 else
779 mv = 0xf;
780 dev_printk(KERN_ERR, &pdev->dev,
781 "MV_AHCI HACK: port_map %x -> %x\n",
782 port_map,
783 port_map & mv);
784 dev_printk(KERN_ERR, &pdev->dev,
785 "Disabling your PATA port. Use the boot option 'ahci.marvell_enable=0' to avoid this.\n");
786
787 port_map &= mv;
788 }
789
790 /* cross check port_map and cap.n_ports */
791 if (port_map) {
792 int map_ports = 0;
793
794 for (i = 0; i < AHCI_MAX_PORTS; i++)
795 if (port_map & (1 << i))
796 map_ports++;
797
798 /* If PI has more ports than n_ports, whine, clear
799 * port_map and let it be generated from n_ports.
800 */
801 if (map_ports > ahci_nr_ports(cap)) {
802 dev_printk(KERN_WARNING, &pdev->dev,
803 "implemented port map (0x%x) contains more "
804 "ports than nr_ports (%u), using nr_ports\n",
805 port_map, ahci_nr_ports(cap));
806 port_map = 0;
807 }
808 }
809
810 /* fabricate port_map from cap.nr_ports */
811 if (!port_map) {
812 port_map = (1 << ahci_nr_ports(cap)) - 1;
813 dev_printk(KERN_WARNING, &pdev->dev,
814 "forcing PORTS_IMPL to 0x%x\n", port_map);
815
816 /* write the fixed up value to the PI register */
817 hpriv->saved_port_map = port_map;
818 }
819
820 /* record values to use during operation */
821 hpriv->cap = cap;
822 hpriv->port_map = port_map;
823 }
824
825 /**
826 * ahci_restore_initial_config - Restore initial config
827 * @host: target ATA host
828 *
829 * Restore initial config stored by ahci_save_initial_config().
830 *
831 * LOCKING:
832 * None.
833 */
834 static void ahci_restore_initial_config(struct ata_host *host)
835 {
836 struct ahci_host_priv *hpriv = host->private_data;
837 void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
838
839 writel(hpriv->saved_cap, mmio + HOST_CAP);
840 writel(hpriv->saved_port_map, mmio + HOST_PORTS_IMPL);
841 (void) readl(mmio + HOST_PORTS_IMPL); /* flush */
842 }
843
844 static unsigned ahci_scr_offset(struct ata_port *ap, unsigned int sc_reg)
845 {
846 static const int offset[] = {
847 [SCR_STATUS] = PORT_SCR_STAT,
848 [SCR_CONTROL] = PORT_SCR_CTL,
849 [SCR_ERROR] = PORT_SCR_ERR,
850 [SCR_ACTIVE] = PORT_SCR_ACT,
851 [SCR_NOTIFICATION] = PORT_SCR_NTF,
852 };
853 struct ahci_host_priv *hpriv = ap->host->private_data;
854
855 if (sc_reg < ARRAY_SIZE(offset) &&
856 (sc_reg != SCR_NOTIFICATION || (hpriv->cap & HOST_CAP_SNTF)))
857 return offset[sc_reg];
858 return 0;
859 }
860
861 static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val)
862 {
863 void __iomem *port_mmio = ahci_port_base(link->ap);
864 int offset = ahci_scr_offset(link->ap, sc_reg);
865
866 if (offset) {
867 *val = readl(port_mmio + offset);
868 return 0;
869 }
870 return -EINVAL;
871 }
872
873 static int ahci_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
874 {
875 void __iomem *port_mmio = ahci_port_base(link->ap);
876 int offset = ahci_scr_offset(link->ap, sc_reg);
877
878 if (offset) {
879 writel(val, port_mmio + offset);
880 return 0;
881 }
882 return -EINVAL;
883 }
884
885 static void ahci_start_engine(struct ata_port *ap)
886 {
887 void __iomem *port_mmio = ahci_port_base(ap);
888 u32 tmp;
889
890 /* start DMA */
891 tmp = readl(port_mmio + PORT_CMD);
892 tmp |= PORT_CMD_START;
893 writel(tmp, port_mmio + PORT_CMD);
894 readl(port_mmio + PORT_CMD); /* flush */
895 }
896
897 static int ahci_stop_engine(struct ata_port *ap)
898 {
899 void __iomem *port_mmio = ahci_port_base(ap);
900 u32 tmp;
901
902 tmp = readl(port_mmio + PORT_CMD);
903
904 /* check if the HBA is idle */
905 if ((tmp & (PORT_CMD_START | PORT_CMD_LIST_ON)) == 0)
906 return 0;
907
908 /* setting HBA to idle */
909 tmp &= ~PORT_CMD_START;
910 writel(tmp, port_mmio + PORT_CMD);
911
912 /* wait for engine to stop. This could be as long as 500 msec */
913 tmp = ata_wait_register(port_mmio + PORT_CMD,
914 PORT_CMD_LIST_ON, PORT_CMD_LIST_ON, 1, 500);
915 if (tmp & PORT_CMD_LIST_ON)
916 return -EIO;
917
918 return 0;
919 }
920
921 static void ahci_start_fis_rx(struct ata_port *ap)
922 {
923 void __iomem *port_mmio = ahci_port_base(ap);
924 struct ahci_host_priv *hpriv = ap->host->private_data;
925 struct ahci_port_priv *pp = ap->private_data;
926 u32 tmp;
927
928 /* set FIS registers */
929 if (hpriv->cap & HOST_CAP_64)
930 writel((pp->cmd_slot_dma >> 16) >> 16,
931 port_mmio + PORT_LST_ADDR_HI);
932 writel(pp->cmd_slot_dma & 0xffffffff, port_mmio + PORT_LST_ADDR);
933
934 if (hpriv->cap & HOST_CAP_64)
935 writel((pp->rx_fis_dma >> 16) >> 16,
936 port_mmio + PORT_FIS_ADDR_HI);
937 writel(pp->rx_fis_dma & 0xffffffff, port_mmio + PORT_FIS_ADDR);
938
939 /* enable FIS reception */
940 tmp = readl(port_mmio + PORT_CMD);
941 tmp |= PORT_CMD_FIS_RX;
942 writel(tmp, port_mmio + PORT_CMD);
943
944 /* flush */
945 readl(port_mmio + PORT_CMD);
946 }
947
948 static int ahci_stop_fis_rx(struct ata_port *ap)
949 {
950 void __iomem *port_mmio = ahci_port_base(ap);
951 u32 tmp;
952
953 /* disable FIS reception */
954 tmp = readl(port_mmio + PORT_CMD);
955 tmp &= ~PORT_CMD_FIS_RX;
956 writel(tmp, port_mmio + PORT_CMD);
957
958 /* wait for completion, spec says 500ms, give it 1000 */
959 tmp = ata_wait_register(port_mmio + PORT_CMD, PORT_CMD_FIS_ON,
960 PORT_CMD_FIS_ON, 10, 1000);
961 if (tmp & PORT_CMD_FIS_ON)
962 return -EBUSY;
963
964 return 0;
965 }
966
967 static void ahci_power_up(struct ata_port *ap)
968 {
969 struct ahci_host_priv *hpriv = ap->host->private_data;
970 void __iomem *port_mmio = ahci_port_base(ap);
971 u32 cmd;
972
973 cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
974
975 /* spin up device */
976 if (hpriv->cap & HOST_CAP_SSS) {
977 cmd |= PORT_CMD_SPIN_UP;
978 writel(cmd, port_mmio + PORT_CMD);
979 }
980
981 /* wake up link */
982 writel(cmd | PORT_CMD_ICC_ACTIVE, port_mmio + PORT_CMD);
983 }
984
985 static void ahci_disable_alpm(struct ata_port *ap)
986 {
987 struct ahci_host_priv *hpriv = ap->host->private_data;
988 void __iomem *port_mmio = ahci_port_base(ap);
989 u32 cmd;
990 struct ahci_port_priv *pp = ap->private_data;
991
992 /* IPM bits should be disabled by libata-core */
993 /* get the existing command bits */
994 cmd = readl(port_mmio + PORT_CMD);
995
996 /* disable ALPM and ASP */
997 cmd &= ~PORT_CMD_ASP;
998 cmd &= ~PORT_CMD_ALPE;
999
1000 /* force the interface back to active */
1001 cmd |= PORT_CMD_ICC_ACTIVE;
1002
1003 /* write out new cmd value */
1004 writel(cmd, port_mmio + PORT_CMD);
1005 cmd = readl(port_mmio + PORT_CMD);
1006
1007 /* wait 10ms to be sure we've come out of any low power state */
1008 msleep(10);
1009
1010 /* clear out any PhyRdy stuff from interrupt status */
1011 writel(PORT_IRQ_PHYRDY, port_mmio + PORT_IRQ_STAT);
1012
1013 /* go ahead and clean out PhyRdy Change from Serror too */
1014 ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18)));
1015
1016 /*
1017 * Clear flag to indicate that we should ignore all PhyRdy
1018 * state changes
1019 */
1020 hpriv->flags &= ~AHCI_HFLAG_NO_HOTPLUG;
1021
1022 /*
1023 * Enable interrupts on Phy Ready.
1024 */
1025 pp->intr_mask |= PORT_IRQ_PHYRDY;
1026 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
1027
1028 /*
1029 * don't change the link pm policy - we can be called
1030 * just to turn of link pm temporarily
1031 */
1032 }
1033
1034 static int ahci_enable_alpm(struct ata_port *ap,
1035 enum link_pm policy)
1036 {
1037 struct ahci_host_priv *hpriv = ap->host->private_data;
1038 void __iomem *port_mmio = ahci_port_base(ap);
1039 u32 cmd;
1040 struct ahci_port_priv *pp = ap->private_data;
1041 u32 asp;
1042
1043 /* Make sure the host is capable of link power management */
1044 if (!(hpriv->cap & HOST_CAP_ALPM))
1045 return -EINVAL;
1046
1047 switch (policy) {
1048 case MAX_PERFORMANCE:
1049 case NOT_AVAILABLE:
1050 /*
1051 * if we came here with NOT_AVAILABLE,
1052 * it just means this is the first time we
1053 * have tried to enable - default to max performance,
1054 * and let the user go to lower power modes on request.
1055 */
1056 ahci_disable_alpm(ap);
1057 return 0;
1058 case MIN_POWER:
1059 /* configure HBA to enter SLUMBER */
1060 asp = PORT_CMD_ASP;
1061 break;
1062 case MEDIUM_POWER:
1063 /* configure HBA to enter PARTIAL */
1064 asp = 0;
1065 break;
1066 default:
1067 return -EINVAL;
1068 }
1069
1070 /*
1071 * Disable interrupts on Phy Ready. This keeps us from
1072 * getting woken up due to spurious phy ready interrupts
1073 * TBD - Hot plug should be done via polling now, is
1074 * that even supported?
1075 */
1076 pp->intr_mask &= ~PORT_IRQ_PHYRDY;
1077 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
1078
1079 /*
1080 * Set a flag to indicate that we should ignore all PhyRdy
1081 * state changes since these can happen now whenever we
1082 * change link state
1083 */
1084 hpriv->flags |= AHCI_HFLAG_NO_HOTPLUG;
1085
1086 /* get the existing command bits */
1087 cmd = readl(port_mmio + PORT_CMD);
1088
1089 /*
1090 * Set ASP based on Policy
1091 */
1092 cmd |= asp;
1093
1094 /*
1095 * Setting this bit will instruct the HBA to aggressively
1096 * enter a lower power link state when it's appropriate and
1097 * based on the value set above for ASP
1098 */
1099 cmd |= PORT_CMD_ALPE;
1100
1101 /* write out new cmd value */
1102 writel(cmd, port_mmio + PORT_CMD);
1103 cmd = readl(port_mmio + PORT_CMD);
1104
1105 /* IPM bits should be set by libata-core */
1106 return 0;
1107 }
1108
1109 #ifdef CONFIG_PM
1110 static void ahci_power_down(struct ata_port *ap)
1111 {
1112 struct ahci_host_priv *hpriv = ap->host->private_data;
1113 void __iomem *port_mmio = ahci_port_base(ap);
1114 u32 cmd, scontrol;
1115
1116 if (!(hpriv->cap & HOST_CAP_SSS))
1117 return;
1118
1119 /* put device into listen mode, first set PxSCTL.DET to 0 */
1120 scontrol = readl(port_mmio + PORT_SCR_CTL);
1121 scontrol &= ~0xf;
1122 writel(scontrol, port_mmio + PORT_SCR_CTL);
1123
1124 /* then set PxCMD.SUD to 0 */
1125 cmd = readl(port_mmio + PORT_CMD) & ~PORT_CMD_ICC_MASK;
1126 cmd &= ~PORT_CMD_SPIN_UP;
1127 writel(cmd, port_mmio + PORT_CMD);
1128 }
1129 #endif
1130
1131 static void ahci_start_port(struct ata_port *ap)
1132 {
1133 struct ahci_port_priv *pp = ap->private_data;
1134 struct ata_link *link;
1135 struct ahci_em_priv *emp;
1136 ssize_t rc;
1137 int i;
1138
1139 /* enable FIS reception */
1140 ahci_start_fis_rx(ap);
1141
1142 /* enable DMA */
1143 ahci_start_engine(ap);
1144
1145 /* turn on LEDs */
1146 if (ap->flags & ATA_FLAG_EM) {
1147 ata_for_each_link(link, ap, EDGE) {
1148 emp = &pp->em_priv[link->pmp];
1149
1150 /* EM Transmit bit maybe busy during init */
1151 for (i = 0; i < EM_MAX_RETRY; i++) {
1152 rc = ahci_transmit_led_message(ap,
1153 emp->led_state,
1154 4);
1155 if (rc == -EBUSY)
1156 msleep(1);
1157 else
1158 break;
1159 }
1160 }
1161 }
1162
1163 if (ap->flags & ATA_FLAG_SW_ACTIVITY)
1164 ata_for_each_link(link, ap, EDGE)
1165 ahci_init_sw_activity(link);
1166
1167 }
1168
1169 static int ahci_deinit_port(struct ata_port *ap, const char **emsg)
1170 {
1171 int rc;
1172
1173 /* disable DMA */
1174 rc = ahci_stop_engine(ap);
1175 if (rc) {
1176 *emsg = "failed to stop engine";
1177 return rc;
1178 }
1179
1180 /* disable FIS reception */
1181 rc = ahci_stop_fis_rx(ap);
1182 if (rc) {
1183 *emsg = "failed stop FIS RX";
1184 return rc;
1185 }
1186
1187 return 0;
1188 }
1189
1190 static int ahci_reset_controller(struct ata_host *host)
1191 {
1192 struct pci_dev *pdev = to_pci_dev(host->dev);
1193 struct ahci_host_priv *hpriv = host->private_data;
1194 void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
1195 u32 tmp;
1196
1197 /* we must be in AHCI mode, before using anything
1198 * AHCI-specific, such as HOST_RESET.
1199 */
1200 ahci_enable_ahci(mmio);
1201
1202 /* global controller reset */
1203 if (!ahci_skip_host_reset) {
1204 tmp = readl(mmio + HOST_CTL);
1205 if ((tmp & HOST_RESET) == 0) {
1206 writel(tmp | HOST_RESET, mmio + HOST_CTL);
1207 readl(mmio + HOST_CTL); /* flush */
1208 }
1209
1210 /*
1211 * to perform host reset, OS should set HOST_RESET
1212 * and poll until this bit is read to be "0".
1213 * reset must complete within 1 second, or
1214 * the hardware should be considered fried.
1215 */
1216 tmp = ata_wait_register(mmio + HOST_CTL, HOST_RESET,
1217 HOST_RESET, 10, 1000);
1218
1219 if (tmp & HOST_RESET) {
1220 dev_printk(KERN_ERR, host->dev,
1221 "controller reset failed (0x%x)\n", tmp);
1222 return -EIO;
1223 }
1224
1225 /* turn on AHCI mode */
1226 ahci_enable_ahci(mmio);
1227
1228 /* Some registers might be cleared on reset. Restore
1229 * initial values.
1230 */
1231 ahci_restore_initial_config(host);
1232 } else
1233 dev_printk(KERN_INFO, host->dev,
1234 "skipping global host reset\n");
1235
1236 if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
1237 u16 tmp16;
1238
1239 /* configure PCS */
1240 pci_read_config_word(pdev, 0x92, &tmp16);
1241 if ((tmp16 & hpriv->port_map) != hpriv->port_map) {
1242 tmp16 |= hpriv->port_map;
1243 pci_write_config_word(pdev, 0x92, tmp16);
1244 }
1245 }
1246
1247 return 0;
1248 }
1249
1250 static void ahci_sw_activity(struct ata_link *link)
1251 {
1252 struct ata_port *ap = link->ap;
1253 struct ahci_port_priv *pp = ap->private_data;
1254 struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1255
1256 if (!(link->flags & ATA_LFLAG_SW_ACTIVITY))
1257 return;
1258
1259 emp->activity++;
1260 if (!timer_pending(&emp->timer))
1261 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(10));
1262 }
1263
1264 static void ahci_sw_activity_blink(unsigned long arg)
1265 {
1266 struct ata_link *link = (struct ata_link *)arg;
1267 struct ata_port *ap = link->ap;
1268 struct ahci_port_priv *pp = ap->private_data;
1269 struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1270 unsigned long led_message = emp->led_state;
1271 u32 activity_led_state;
1272 unsigned long flags;
1273
1274 led_message &= EM_MSG_LED_VALUE;
1275 led_message |= ap->port_no | (link->pmp << 8);
1276
1277 /* check to see if we've had activity. If so,
1278 * toggle state of LED and reset timer. If not,
1279 * turn LED to desired idle state.
1280 */
1281 spin_lock_irqsave(ap->lock, flags);
1282 if (emp->saved_activity != emp->activity) {
1283 emp->saved_activity = emp->activity;
1284 /* get the current LED state */
1285 activity_led_state = led_message & EM_MSG_LED_VALUE_ON;
1286
1287 if (activity_led_state)
1288 activity_led_state = 0;
1289 else
1290 activity_led_state = 1;
1291
1292 /* clear old state */
1293 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY;
1294
1295 /* toggle state */
1296 led_message |= (activity_led_state << 16);
1297 mod_timer(&emp->timer, jiffies + msecs_to_jiffies(100));
1298 } else {
1299 /* switch to idle */
1300 led_message &= ~EM_MSG_LED_VALUE_ACTIVITY;
1301 if (emp->blink_policy == BLINK_OFF)
1302 led_message |= (1 << 16);
1303 }
1304 spin_unlock_irqrestore(ap->lock, flags);
1305 ahci_transmit_led_message(ap, led_message, 4);
1306 }
1307
1308 static void ahci_init_sw_activity(struct ata_link *link)
1309 {
1310 struct ata_port *ap = link->ap;
1311 struct ahci_port_priv *pp = ap->private_data;
1312 struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1313
1314 /* init activity stats, setup timer */
1315 emp->saved_activity = emp->activity = 0;
1316 setup_timer(&emp->timer, ahci_sw_activity_blink, (unsigned long)link);
1317
1318 /* check our blink policy and set flag for link if it's enabled */
1319 if (emp->blink_policy)
1320 link->flags |= ATA_LFLAG_SW_ACTIVITY;
1321 }
1322
1323 static int ahci_reset_em(struct ata_host *host)
1324 {
1325 void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
1326 u32 em_ctl;
1327
1328 em_ctl = readl(mmio + HOST_EM_CTL);
1329 if ((em_ctl & EM_CTL_TM) || (em_ctl & EM_CTL_RST))
1330 return -EINVAL;
1331
1332 writel(em_ctl | EM_CTL_RST, mmio + HOST_EM_CTL);
1333 return 0;
1334 }
1335
1336 static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
1337 ssize_t size)
1338 {
1339 struct ahci_host_priv *hpriv = ap->host->private_data;
1340 struct ahci_port_priv *pp = ap->private_data;
1341 void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
1342 u32 em_ctl;
1343 u32 message[] = {0, 0};
1344 unsigned long flags;
1345 int pmp;
1346 struct ahci_em_priv *emp;
1347
1348 /* get the slot number from the message */
1349 pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
1350 if (pmp < EM_MAX_SLOTS)
1351 emp = &pp->em_priv[pmp];
1352 else
1353 return -EINVAL;
1354
1355 spin_lock_irqsave(ap->lock, flags);
1356
1357 /*
1358 * if we are still busy transmitting a previous message,
1359 * do not allow
1360 */
1361 em_ctl = readl(mmio + HOST_EM_CTL);
1362 if (em_ctl & EM_CTL_TM) {
1363 spin_unlock_irqrestore(ap->lock, flags);
1364 return -EBUSY;
1365 }
1366
1367 /*
1368 * create message header - this is all zero except for
1369 * the message size, which is 4 bytes.
1370 */
1371 message[0] |= (4 << 8);
1372
1373 /* ignore 0:4 of byte zero, fill in port info yourself */
1374 message[1] = ((state & ~EM_MSG_LED_HBA_PORT) | ap->port_no);
1375
1376 /* write message to EM_LOC */
1377 writel(message[0], mmio + hpriv->em_loc);
1378 writel(message[1], mmio + hpriv->em_loc+4);
1379
1380 /* save off new led state for port/slot */
1381 emp->led_state = state;
1382
1383 /*
1384 * tell hardware to transmit the message
1385 */
1386 writel(em_ctl | EM_CTL_TM, mmio + HOST_EM_CTL);
1387
1388 spin_unlock_irqrestore(ap->lock, flags);
1389 return size;
1390 }
1391
1392 static ssize_t ahci_led_show(struct ata_port *ap, char *buf)
1393 {
1394 struct ahci_port_priv *pp = ap->private_data;
1395 struct ata_link *link;
1396 struct ahci_em_priv *emp;
1397 int rc = 0;
1398
1399 ata_for_each_link(link, ap, EDGE) {
1400 emp = &pp->em_priv[link->pmp];
1401 rc += sprintf(buf, "%lx\n", emp->led_state);
1402 }
1403 return rc;
1404 }
1405
1406 static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
1407 size_t size)
1408 {
1409 int state;
1410 int pmp;
1411 struct ahci_port_priv *pp = ap->private_data;
1412 struct ahci_em_priv *emp;
1413
1414 state = simple_strtoul(buf, NULL, 0);
1415
1416 /* get the slot number from the message */
1417 pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
1418 if (pmp < EM_MAX_SLOTS)
1419 emp = &pp->em_priv[pmp];
1420 else
1421 return -EINVAL;
1422
1423 /* mask off the activity bits if we are in sw_activity
1424 * mode, user should turn off sw_activity before setting
1425 * activity led through em_message
1426 */
1427 if (emp->blink_policy)
1428 state &= ~EM_MSG_LED_VALUE_ACTIVITY;
1429
1430 return ahci_transmit_led_message(ap, state, size);
1431 }
1432
1433 static ssize_t ahci_activity_store(struct ata_device *dev, enum sw_activity val)
1434 {
1435 struct ata_link *link = dev->link;
1436 struct ata_port *ap = link->ap;
1437 struct ahci_port_priv *pp = ap->private_data;
1438 struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1439 u32 port_led_state = emp->led_state;
1440
1441 /* save the desired Activity LED behavior */
1442 if (val == OFF) {
1443 /* clear LFLAG */
1444 link->flags &= ~(ATA_LFLAG_SW_ACTIVITY);
1445
1446 /* set the LED to OFF */
1447 port_led_state &= EM_MSG_LED_VALUE_OFF;
1448 port_led_state |= (ap->port_no | (link->pmp << 8));
1449 ahci_transmit_led_message(ap, port_led_state, 4);
1450 } else {
1451 link->flags |= ATA_LFLAG_SW_ACTIVITY;
1452 if (val == BLINK_OFF) {
1453 /* set LED to ON for idle */
1454 port_led_state &= EM_MSG_LED_VALUE_OFF;
1455 port_led_state |= (ap->port_no | (link->pmp << 8));
1456 port_led_state |= EM_MSG_LED_VALUE_ON; /* check this */
1457 ahci_transmit_led_message(ap, port_led_state, 4);
1458 }
1459 }
1460 emp->blink_policy = val;
1461 return 0;
1462 }
1463
1464 static ssize_t ahci_activity_show(struct ata_device *dev, char *buf)
1465 {
1466 struct ata_link *link = dev->link;
1467 struct ata_port *ap = link->ap;
1468 struct ahci_port_priv *pp = ap->private_data;
1469 struct ahci_em_priv *emp = &pp->em_priv[link->pmp];
1470
1471 /* display the saved value of activity behavior for this
1472 * disk.
1473 */
1474 return sprintf(buf, "%d\n", emp->blink_policy);
1475 }
1476
1477 static void ahci_port_init(struct pci_dev *pdev, struct ata_port *ap,
1478 int port_no, void __iomem *mmio,
1479 void __iomem *port_mmio)
1480 {
1481 const char *emsg = NULL;
1482 int rc;
1483 u32 tmp;
1484
1485 /* make sure port is not active */
1486 rc = ahci_deinit_port(ap, &emsg);
1487 if (rc)
1488 dev_printk(KERN_WARNING, &pdev->dev,
1489 "%s (%d)\n", emsg, rc);
1490
1491 /* clear SError */
1492 tmp = readl(port_mmio + PORT_SCR_ERR);
1493 VPRINTK("PORT_SCR_ERR 0x%x\n", tmp);
1494 writel(tmp, port_mmio + PORT_SCR_ERR);
1495
1496 /* clear port IRQ */
1497 tmp = readl(port_mmio + PORT_IRQ_STAT);
1498 VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);
1499 if (tmp)
1500 writel(tmp, port_mmio + PORT_IRQ_STAT);
1501
1502 writel(1 << port_no, mmio + HOST_IRQ_STAT);
1503 }
1504
1505 static void ahci_init_controller(struct ata_host *host)
1506 {
1507 struct ahci_host_priv *hpriv = host->private_data;
1508 struct pci_dev *pdev = to_pci_dev(host->dev);
1509 void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
1510 int i;
1511 void __iomem *port_mmio;
1512 u32 tmp;
1513 int mv;
1514
1515 if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
1516 if (pdev->device == 0x6121)
1517 mv = 2;
1518 else
1519 mv = 4;
1520 port_mmio = __ahci_port_base(host, mv);
1521
1522 writel(0, port_mmio + PORT_IRQ_MASK);
1523
1524 /* clear port IRQ */
1525 tmp = readl(port_mmio + PORT_IRQ_STAT);
1526 VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);
1527 if (tmp)
1528 writel(tmp, port_mmio + PORT_IRQ_STAT);
1529 }
1530
1531 for (i = 0; i < host->n_ports; i++) {
1532 struct ata_port *ap = host->ports[i];
1533
1534 port_mmio = ahci_port_base(ap);
1535 if (ata_port_is_dummy(ap))
1536 continue;
1537
1538 ahci_port_init(pdev, ap, i, mmio, port_mmio);
1539 }
1540
1541 tmp = readl(mmio + HOST_CTL);
1542 VPRINTK("HOST_CTL 0x%x\n", tmp);
1543 writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL);
1544 tmp = readl(mmio + HOST_CTL);
1545 VPRINTK("HOST_CTL 0x%x\n", tmp);
1546 }
1547
1548 static void ahci_dev_config(struct ata_device *dev)
1549 {
1550 struct ahci_host_priv *hpriv = dev->link->ap->host->private_data;
1551
1552 if (hpriv->flags & AHCI_HFLAG_SECT255) {
1553 dev->max_sectors = 255;
1554 ata_dev_printk(dev, KERN_INFO,
1555 "SB600 AHCI: limiting to 255 sectors per cmd\n");
1556 }
1557 }
1558
1559 static unsigned int ahci_dev_classify(struct ata_port *ap)
1560 {
1561 void __iomem *port_mmio = ahci_port_base(ap);
1562 struct ata_taskfile tf;
1563 u32 tmp;
1564
1565 tmp = readl(port_mmio + PORT_SIG);
1566 tf.lbah = (tmp >> 24) & 0xff;
1567 tf.lbam = (tmp >> 16) & 0xff;
1568 tf.lbal = (tmp >> 8) & 0xff;
1569 tf.nsect = (tmp) & 0xff;
1570
1571 return ata_dev_classify(&tf);
1572 }
1573
1574 static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
1575 u32 opts)
1576 {
1577 dma_addr_t cmd_tbl_dma;
1578
1579 cmd_tbl_dma = pp->cmd_tbl_dma + tag * AHCI_CMD_TBL_SZ;
1580
1581 pp->cmd_slot[tag].opts = cpu_to_le32(opts);
1582 pp->cmd_slot[tag].status = 0;
1583 pp->cmd_slot[tag].tbl_addr = cpu_to_le32(cmd_tbl_dma & 0xffffffff);
1584 pp->cmd_slot[tag].tbl_addr_hi = cpu_to_le32((cmd_tbl_dma >> 16) >> 16);
1585 }
1586
1587 static int ahci_kick_engine(struct ata_port *ap, int force_restart)
1588 {
1589 void __iomem *port_mmio = ahci_port_base(ap);
1590 struct ahci_host_priv *hpriv = ap->host->private_data;
1591 u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
1592 u32 tmp;
1593 int busy, rc;
1594
1595 /* do we need to kick the port? */
1596 busy = status & (ATA_BUSY | ATA_DRQ);
1597 if (!busy && !force_restart)
1598 return 0;
1599
1600 /* stop engine */
1601 rc = ahci_stop_engine(ap);
1602 if (rc)
1603 goto out_restart;
1604
1605 /* need to do CLO? */
1606 if (!busy) {
1607 rc = 0;
1608 goto out_restart;
1609 }
1610
1611 if (!(hpriv->cap & HOST_CAP_CLO)) {
1612 rc = -EOPNOTSUPP;
1613 goto out_restart;
1614 }
1615
1616 /* perform CLO */
1617 tmp = readl(port_mmio + PORT_CMD);
1618 tmp |= PORT_CMD_CLO;
1619 writel(tmp, port_mmio + PORT_CMD);
1620
1621 rc = 0;
1622 tmp = ata_wait_register(port_mmio + PORT_CMD,
1623 PORT_CMD_CLO, PORT_CMD_CLO, 1, 500);
1624 if (tmp & PORT_CMD_CLO)
1625 rc = -EIO;
1626
1627 /* restart engine */
1628 out_restart:
1629 ahci_start_engine(ap);
1630 return rc;
1631 }
1632
1633 static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
1634 struct ata_taskfile *tf, int is_cmd, u16 flags,
1635 unsigned long timeout_msec)
1636 {
1637 const u32 cmd_fis_len = 5; /* five dwords */
1638 struct ahci_port_priv *pp = ap->private_data;
1639 void __iomem *port_mmio = ahci_port_base(ap);
1640 u8 *fis = pp->cmd_tbl;
1641 u32 tmp;
1642
1643 /* prep the command */
1644 ata_tf_to_fis(tf, pmp, is_cmd, fis);
1645 ahci_fill_cmd_slot(pp, 0, cmd_fis_len | flags | (pmp << 12));
1646
1647 /* issue & wait */
1648 writel(1, port_mmio + PORT_CMD_ISSUE);
1649
1650 if (timeout_msec) {
1651 tmp = ata_wait_register(port_mmio + PORT_CMD_ISSUE, 0x1, 0x1,
1652 1, timeout_msec);
1653 if (tmp & 0x1) {
1654 ahci_kick_engine(ap, 1);
1655 return -EBUSY;
1656 }
1657 } else
1658 readl(port_mmio + PORT_CMD_ISSUE); /* flush */
1659
1660 return 0;
1661 }
1662
1663 static int ahci_do_softreset(struct ata_link *link, unsigned int *class,
1664 int pmp, unsigned long deadline,
1665 int (*check_ready)(struct ata_link *link))
1666 {
1667 struct ata_port *ap = link->ap;
1668 struct ahci_host_priv *hpriv = ap->host->private_data;
1669 const char *reason = NULL;
1670 unsigned long now, msecs;
1671 struct ata_taskfile tf;
1672 int rc;
1673
1674 DPRINTK("ENTER\n");
1675
1676 /* prepare for SRST (AHCI-1.1 10.4.1) */
1677 rc = ahci_kick_engine(ap, 1);
1678 if (rc && rc != -EOPNOTSUPP)
1679 ata_link_printk(link, KERN_WARNING,
1680 "failed to reset engine (errno=%d)\n", rc);
1681
1682 ata_tf_init(link->device, &tf);
1683
1684 /* issue the first D2H Register FIS */
1685 msecs = 0;
1686 now = jiffies;
1687 if (time_after(now, deadline))
1688 msecs = jiffies_to_msecs(deadline - now);
1689
1690 tf.ctl |= ATA_SRST;
1691 if (ahci_exec_polled_cmd(ap, pmp, &tf, 0,
1692 AHCI_CMD_RESET | AHCI_CMD_CLR_BUSY, msecs)) {
1693 rc = -EIO;
1694 reason = "1st FIS failed";
1695 goto fail;
1696 }
1697
1698 /* spec says at least 5us, but be generous and sleep for 1ms */
1699 msleep(1);
1700
1701 /* issue the second D2H Register FIS */
1702 tf.ctl &= ~ATA_SRST;
1703 ahci_exec_polled_cmd(ap, pmp, &tf, 0, 0, 0);
1704
1705 /* wait for link to become ready */
1706 rc = ata_wait_after_reset(link, deadline, check_ready);
1707 if (rc == -EBUSY && hpriv->flags & AHCI_HFLAG_SRST_TOUT_IS_OFFLINE) {
1708 /*
1709 * Workaround for cases where link online status can't
1710 * be trusted. Treat device readiness timeout as link
1711 * offline.
1712 */
1713 ata_link_printk(link, KERN_INFO,
1714 "device not ready, treating as offline\n");
1715 *class = ATA_DEV_NONE;
1716 } else if (rc) {
1717 /* link occupied, -ENODEV too is an error */
1718 reason = "device not ready";
1719 goto fail;
1720 } else
1721 *class = ahci_dev_classify(ap);
1722
1723 DPRINTK("EXIT, class=%u\n", *class);
1724 return 0;
1725
1726 fail:
1727 ata_link_printk(link, KERN_ERR, "softreset failed (%s)\n", reason);
1728 return rc;
1729 }
1730
1731 static int ahci_check_ready(struct ata_link *link)
1732 {
1733 void __iomem *port_mmio = ahci_port_base(link->ap);
1734 u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
1735
1736 return ata_check_ready(status);
1737 }
1738
1739 static int ahci_softreset(struct ata_link *link, unsigned int *class,
1740 unsigned long deadline)
1741 {
1742 int pmp = sata_srst_pmp(link);
1743
1744 DPRINTK("ENTER\n");
1745
1746 return ahci_do_softreset(link, class, pmp, deadline, ahci_check_ready);
1747 }
1748
1749 static int ahci_sb600_check_ready(struct ata_link *link)
1750 {
1751 void __iomem *port_mmio = ahci_port_base(link->ap);
1752 u8 status = readl(port_mmio + PORT_TFDATA) & 0xFF;
1753 u32 irq_status = readl(port_mmio + PORT_IRQ_STAT);
1754
1755 /*
1756 * There is no need to check TFDATA if BAD PMP is found due to HW bug,
1757 * which can save timeout delay.
1758 */
1759 if (irq_status & PORT_IRQ_BAD_PMP)
1760 return -EIO;
1761
1762 return ata_check_ready(status);
1763 }
1764
1765 static int ahci_sb600_softreset(struct ata_link *link, unsigned int *class,
1766 unsigned long deadline)
1767 {
1768 struct ata_port *ap = link->ap;
1769 void __iomem *port_mmio = ahci_port_base(ap);
1770 int pmp = sata_srst_pmp(link);
1771 int rc;
1772 u32 irq_sts;
1773
1774 DPRINTK("ENTER\n");
1775
1776 rc = ahci_do_softreset(link, class, pmp, deadline,
1777 ahci_sb600_check_ready);
1778
1779 /*
1780 * Soft reset fails on some ATI chips with IPMS set when PMP
1781 * is enabled but SATA HDD/ODD is connected to SATA port,
1782 * do soft reset again to port 0.
1783 */
1784 if (rc == -EIO) {
1785 irq_sts = readl(port_mmio + PORT_IRQ_STAT);
1786 if (irq_sts & PORT_IRQ_BAD_PMP) {
1787 ata_link_printk(link, KERN_WARNING,
1788 "applying SB600 PMP SRST workaround "
1789 "and retrying\n");
1790 rc = ahci_do_softreset(link, class, 0, deadline,
1791 ahci_check_ready);
1792 }
1793 }
1794
1795 return rc;
1796 }
1797
1798 static int ahci_hardreset(struct ata_link *link, unsigned int *class,
1799 unsigned long deadline)
1800 {
1801 const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
1802 struct ata_port *ap = link->ap;
1803 struct ahci_port_priv *pp = ap->private_data;
1804 u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
1805 struct ata_taskfile tf;
1806 bool online;
1807 int rc;
1808
1809 DPRINTK("ENTER\n");
1810
1811 ahci_stop_engine(ap);
1812
1813 /* clear D2H reception area to properly wait for D2H FIS */
1814 ata_tf_init(link->device, &tf);
1815 tf.command = 0x80;
1816 ata_tf_to_fis(&tf, 0, 0, d2h_fis);
1817
1818 rc = sata_link_hardreset(link, timing, deadline, &online,
1819 ahci_check_ready);
1820
1821 ahci_start_engine(ap);
1822
1823 if (online)
1824 *class = ahci_dev_classify(ap);
1825
1826 DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
1827 return rc;
1828 }
1829
1830 static int ahci_vt8251_hardreset(struct ata_link *link, unsigned int *class,
1831 unsigned long deadline)
1832 {
1833 struct ata_port *ap = link->ap;
1834 bool online;
1835 int rc;
1836
1837 DPRINTK("ENTER\n");
1838
1839 ahci_stop_engine(ap);
1840
1841 rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context),
1842 deadline, &online, NULL);
1843
1844 ahci_start_engine(ap);
1845
1846 DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
1847
1848 /* vt8251 doesn't clear BSY on signature FIS reception,
1849 * request follow-up softreset.
1850 */
1851 return online ? -EAGAIN : rc;
1852 }
1853
1854 static int ahci_p5wdh_hardreset(struct ata_link *link, unsigned int *class,
1855 unsigned long deadline)
1856 {
1857 struct ata_port *ap = link->ap;
1858 struct ahci_port_priv *pp = ap->private_data;
1859 u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
1860 struct ata_taskfile tf;
1861 bool online;
1862 int rc;
1863
1864 ahci_stop_engine(ap);
1865
1866 /* clear D2H reception area to properly wait for D2H FIS */
1867 ata_tf_init(link->device, &tf);
1868 tf.command = 0x80;
1869 ata_tf_to_fis(&tf, 0, 0, d2h_fis);
1870
1871 rc = sata_link_hardreset(link, sata_ehc_deb_timing(&link->eh_context),
1872 deadline, &online, NULL);
1873
1874 ahci_start_engine(ap);
1875
1876 /* The pseudo configuration device on SIMG4726 attached to
1877 * ASUS P5W-DH Deluxe doesn't send signature FIS after
1878 * hardreset if no device is attached to the first downstream
1879 * port && the pseudo device locks up on SRST w/ PMP==0. To
1880 * work around this, wait for !BSY only briefly. If BSY isn't
1881 * cleared, perform CLO and proceed to IDENTIFY (achieved by
1882 * ATA_LFLAG_NO_SRST and ATA_LFLAG_ASSUME_ATA).
1883 *
1884 * Wait for two seconds. Devices attached to downstream port
1885 * which can't process the following IDENTIFY after this will
1886 * have to be reset again. For most cases, this should
1887 * suffice while making probing snappish enough.
1888 */
1889 if (online) {
1890 rc = ata_wait_after_reset(link, jiffies + 2 * HZ,
1891 ahci_check_ready);
1892 if (rc)
1893 ahci_kick_engine(ap, 0);
1894 }
1895 return rc;
1896 }
1897
1898 static void ahci_postreset(struct ata_link *link, unsigned int *class)
1899 {
1900 struct ata_port *ap = link->ap;
1901 void __iomem *port_mmio = ahci_port_base(ap);
1902 u32 new_tmp, tmp;
1903
1904 ata_std_postreset(link, class);
1905
1906 /* Make sure port's ATAPI bit is set appropriately */
1907 new_tmp = tmp = readl(port_mmio + PORT_CMD);
1908 if (*class == ATA_DEV_ATAPI)
1909 new_tmp |= PORT_CMD_ATAPI;
1910 else
1911 new_tmp &= ~PORT_CMD_ATAPI;
1912 if (new_tmp != tmp) {
1913 writel(new_tmp, port_mmio + PORT_CMD);
1914 readl(port_mmio + PORT_CMD); /* flush */
1915 }
1916 }
1917
1918 static unsigned int ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl)
1919 {
1920 struct scatterlist *sg;
1921 struct ahci_sg *ahci_sg = cmd_tbl + AHCI_CMD_TBL_HDR_SZ;
1922 unsigned int si;
1923
1924 VPRINTK("ENTER\n");
1925
1926 /*
1927 * Next, the S/G list.
1928 */
1929 for_each_sg(qc->sg, sg, qc->n_elem, si) {
1930 dma_addr_t addr = sg_dma_address(sg);
1931 u32 sg_len = sg_dma_len(sg);
1932
1933 ahci_sg[si].addr = cpu_to_le32(addr & 0xffffffff);
1934 ahci_sg[si].addr_hi = cpu_to_le32((addr >> 16) >> 16);
1935 ahci_sg[si].flags_size = cpu_to_le32(sg_len - 1);
1936 }
1937
1938 return si;
1939 }
1940
1941 static void ahci_qc_prep(struct ata_queued_cmd *qc)
1942 {
1943 struct ata_port *ap = qc->ap;
1944 struct ahci_port_priv *pp = ap->private_data;
1945 int is_atapi = ata_is_atapi(qc->tf.protocol);
1946 void *cmd_tbl;
1947 u32 opts;
1948 const u32 cmd_fis_len = 5; /* five dwords */
1949 unsigned int n_elem;
1950
1951 /*
1952 * Fill in command table information. First, the header,
1953 * a SATA Register - Host to Device command FIS.
1954 */
1955 cmd_tbl = pp->cmd_tbl + qc->tag * AHCI_CMD_TBL_SZ;
1956
1957 ata_tf_to_fis(&qc->tf, qc->dev->link->pmp, 1, cmd_tbl);
1958 if (is_atapi) {
1959 memset(cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32);
1960 memcpy(cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, qc->dev->cdb_len);
1961 }
1962
1963 n_elem = 0;
1964 if (qc->flags & ATA_QCFLAG_DMAMAP)
1965 n_elem = ahci_fill_sg(qc, cmd_tbl);
1966
1967 /*
1968 * Fill in command slot information.
1969 */
1970 opts = cmd_fis_len | n_elem << 16 | (qc->dev->link->pmp << 12);
1971 if (qc->tf.flags & ATA_TFLAG_WRITE)
1972 opts |= AHCI_CMD_WRITE;
1973 if (is_atapi)
1974 opts |= AHCI_CMD_ATAPI | AHCI_CMD_PREFETCH;
1975
1976 ahci_fill_cmd_slot(pp, qc->tag, opts);
1977 }
1978
1979 static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
1980 {
1981 struct ahci_host_priv *hpriv = ap->host->private_data;
1982 struct ahci_port_priv *pp = ap->private_data;
1983 struct ata_eh_info *host_ehi = &ap->link.eh_info;
1984 struct ata_link *link = NULL;
1985 struct ata_queued_cmd *active_qc;
1986 struct ata_eh_info *active_ehi;
1987 u32 serror;
1988
1989 /* determine active link */
1990 ata_for_each_link(link, ap, EDGE)
1991 if (ata_link_active(link))
1992 break;
1993 if (!link)
1994 link = &ap->link;
1995
1996 active_qc = ata_qc_from_tag(ap, link->active_tag);
1997 active_ehi = &link->eh_info;
1998
1999 /* record irq stat */
2000 ata_ehi_clear_desc(host_ehi);
2001 ata_ehi_push_desc(host_ehi, "irq_stat 0x%08x", irq_stat);
2002
2003 /* AHCI needs SError cleared; otherwise, it might lock up */
2004 ahci_scr_read(&ap->link, SCR_ERROR, &serror);
2005 ahci_scr_write(&ap->link, SCR_ERROR, serror);
2006 host_ehi->serror |= serror;
2007
2008 /* some controllers set IRQ_IF_ERR on device errors, ignore it */
2009 if (hpriv->flags & AHCI_HFLAG_IGN_IRQ_IF_ERR)
2010 irq_stat &= ~PORT_IRQ_IF_ERR;
2011
2012 if (irq_stat & PORT_IRQ_TF_ERR) {
2013 /* If qc is active, charge it; otherwise, the active
2014 * link. There's no active qc on NCQ errors. It will
2015 * be determined by EH by reading log page 10h.
2016 */
2017 if (active_qc)
2018 active_qc->err_mask |= AC_ERR_DEV;
2019 else
2020 active_ehi->err_mask |= AC_ERR_DEV;
2021
2022 if (hpriv->flags & AHCI_HFLAG_IGN_SERR_INTERNAL)
2023 host_ehi->serror &= ~SERR_INTERNAL;
2024 }
2025
2026 if (irq_stat & PORT_IRQ_UNK_FIS) {
2027 u32 *unk = (u32 *)(pp->rx_fis + RX_FIS_UNK);
2028
2029 active_ehi->err_mask |= AC_ERR_HSM;
2030 active_ehi->action |= ATA_EH_RESET;
2031 ata_ehi_push_desc(active_ehi,
2032 "unknown FIS %08x %08x %08x %08x" ,
2033 unk[0], unk[1], unk[2], unk[3]);
2034 }
2035
2036 if (sata_pmp_attached(ap) && (irq_stat & PORT_IRQ_BAD_PMP)) {
2037 active_ehi->err_mask |= AC_ERR_HSM;
2038 active_ehi->action |= ATA_EH_RESET;
2039 ata_ehi_push_desc(active_ehi, "incorrect PMP");
2040 }
2041
2042 if (irq_stat & (PORT_IRQ_HBUS_ERR | PORT_IRQ_HBUS_DATA_ERR)) {
2043 host_ehi->err_mask |= AC_ERR_HOST_BUS;
2044 host_ehi->action |= ATA_EH_RESET;
2045 ata_ehi_push_desc(host_ehi, "host bus error");
2046 }
2047
2048 if (irq_stat & PORT_IRQ_IF_ERR) {
2049 host_ehi->err_mask |= AC_ERR_ATA_BUS;
2050 host_ehi->action |= ATA_EH_RESET;
2051 ata_ehi_push_desc(host_ehi, "interface fatal error");
2052 }
2053
2054 if (irq_stat & (PORT_IRQ_CONNECT | PORT_IRQ_PHYRDY)) {
2055 ata_ehi_hotplugged(host_ehi);
2056 ata_ehi_push_desc(host_ehi, "%s",
2057 irq_stat & PORT_IRQ_CONNECT ?
2058 "connection status changed" : "PHY RDY changed");
2059 }
2060
2061 /* okay, let's hand over to EH */
2062
2063 if (irq_stat & PORT_IRQ_FREEZE)
2064 ata_port_freeze(ap);
2065 else
2066 ata_port_abort(ap);
2067 }
2068
2069 static void ahci_port_intr(struct ata_port *ap)
2070 {
2071 void __iomem *port_mmio = ahci_port_base(ap);
2072 struct ata_eh_info *ehi = &ap->link.eh_info;
2073 struct ahci_port_priv *pp = ap->private_data;
2074 struct ahci_host_priv *hpriv = ap->host->private_data;
2075 int resetting = !!(ap->pflags & ATA_PFLAG_RESETTING);
2076 u32 status, qc_active;
2077 int rc;
2078
2079 status = readl(port_mmio + PORT_IRQ_STAT);
2080 writel(status, port_mmio + PORT_IRQ_STAT);
2081
2082 /* ignore BAD_PMP while resetting */
2083 if (unlikely(resetting))
2084 status &= ~PORT_IRQ_BAD_PMP;
2085
2086 /* If we are getting PhyRdy, this is
2087 * just a power state change, we should
2088 * clear out this, plus the PhyRdy/Comm
2089 * Wake bits from Serror
2090 */
2091 if ((hpriv->flags & AHCI_HFLAG_NO_HOTPLUG) &&
2092 (status & PORT_IRQ_PHYRDY)) {
2093 status &= ~PORT_IRQ_PHYRDY;
2094 ahci_scr_write(&ap->link, SCR_ERROR, ((1 << 16) | (1 << 18)));
2095 }
2096
2097 if (unlikely(status & PORT_IRQ_ERROR)) {
2098 ahci_error_intr(ap, status);
2099 return;
2100 }
2101
2102 if (status & PORT_IRQ_SDB_FIS) {
2103 /* If SNotification is available, leave notification
2104 * handling to sata_async_notification(). If not,
2105 * emulate it by snooping SDB FIS RX area.
2106 *
2107 * Snooping FIS RX area is probably cheaper than
2108 * poking SNotification but some constrollers which
2109 * implement SNotification, ICH9 for example, don't
2110 * store AN SDB FIS into receive area.
2111 */
2112 if (hpriv->cap & HOST_CAP_SNTF)
2113 sata_async_notification(ap);
2114 else {
2115 /* If the 'N' bit in word 0 of the FIS is set,
2116 * we just received asynchronous notification.
2117 * Tell libata about it.
2118 */
2119 const __le32 *f = pp->rx_fis + RX_FIS_SDB;
2120 u32 f0 = le32_to_cpu(f[0]);
2121
2122 if (f0 & (1 << 15))
2123 sata_async_notification(ap);
2124 }
2125 }
2126
2127 /* pp->active_link is valid iff any command is in flight */
2128 if (ap->qc_active && pp->active_link->sactive)
2129 qc_active = readl(port_mmio + PORT_SCR_ACT);
2130 else
2131 qc_active = readl(port_mmio + PORT_CMD_ISSUE);
2132
2133 rc = ata_qc_complete_multiple(ap, qc_active);
2134
2135 /* while resetting, invalid completions are expected */
2136 if (unlikely(rc < 0 && !resetting)) {
2137 ehi->err_mask |= AC_ERR_HSM;
2138 ehi->action |= ATA_EH_RESET;
2139 ata_port_freeze(ap);
2140 }
2141 }
2142
2143 static irqreturn_t ahci_interrupt(int irq, void *dev_instance)
2144 {
2145 struct ata_host *host = dev_instance;
2146 struct ahci_host_priv *hpriv;
2147 unsigned int i, handled = 0;
2148 void __iomem *mmio;
2149 u32 irq_stat, irq_masked;
2150
2151 VPRINTK("ENTER\n");
2152
2153 hpriv = host->private_data;
2154 mmio = host->iomap[AHCI_PCI_BAR];
2155
2156 /* sigh. 0xffffffff is a valid return from h/w */
2157 irq_stat = readl(mmio + HOST_IRQ_STAT);
2158 if (!irq_stat)
2159 return IRQ_NONE;
2160
2161 irq_masked = irq_stat & hpriv->port_map;
2162
2163 spin_lock(&host->lock);
2164
2165 for (i = 0; i < host->n_ports; i++) {
2166 struct ata_port *ap;
2167
2168 if (!(irq_masked & (1 << i)))
2169 continue;
2170
2171 ap = host->ports[i];
2172 if (ap) {
2173 ahci_port_intr(ap);
2174 VPRINTK("port %u\n", i);
2175 } else {
2176 VPRINTK("port %u (no irq)\n", i);
2177 if (ata_ratelimit())
2178 dev_printk(KERN_WARNING, host->dev,
2179 "interrupt on disabled port %u\n", i);
2180 }
2181
2182 handled = 1;
2183 }
2184
2185 /* HOST_IRQ_STAT behaves as level triggered latch meaning that
2186 * it should be cleared after all the port events are cleared;
2187 * otherwise, it will raise a spurious interrupt after each
2188 * valid one. Please read section 10.6.2 of ahci 1.1 for more
2189 * information.
2190 *
2191 * Also, use the unmasked value to clear interrupt as spurious
2192 * pending event on a dummy port might cause screaming IRQ.
2193 */
2194 writel(irq_stat, mmio + HOST_IRQ_STAT);
2195
2196 spin_unlock(&host->lock);
2197
2198 VPRINTK("EXIT\n");
2199
2200 return IRQ_RETVAL(handled);
2201 }
2202
2203 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc)
2204 {
2205 struct ata_port *ap = qc->ap;
2206 void __iomem *port_mmio = ahci_port_base(ap);
2207 struct ahci_port_priv *pp = ap->private_data;
2208
2209 /* Keep track of the currently active link. It will be used
2210 * in completion path to determine whether NCQ phase is in
2211 * progress.
2212 */
2213 pp->active_link = qc->dev->link;
2214
2215 if (qc->tf.protocol == ATA_PROT_NCQ)
2216 writel(1 << qc->tag, port_mmio + PORT_SCR_ACT);
2217 writel(1 << qc->tag, port_mmio + PORT_CMD_ISSUE);
2218
2219 ahci_sw_activity(qc->dev->link);
2220
2221 return 0;
2222 }
2223
2224 static bool ahci_qc_fill_rtf(struct ata_queued_cmd *qc)
2225 {
2226 struct ahci_port_priv *pp = qc->ap->private_data;
2227 u8 *d2h_fis = pp->rx_fis + RX_FIS_D2H_REG;
2228
2229 ata_tf_from_fis(d2h_fis, &qc->result_tf);
2230 return true;
2231 }
2232
2233 static void ahci_freeze(struct ata_port *ap)
2234 {
2235 void __iomem *port_mmio = ahci_port_base(ap);
2236
2237 /* turn IRQ off */
2238 writel(0, port_mmio + PORT_IRQ_MASK);
2239 }
2240
2241 static void ahci_thaw(struct ata_port *ap)
2242 {
2243 void __iomem *mmio = ap->host->iomap[AHCI_PCI_BAR];
2244 void __iomem *port_mmio = ahci_port_base(ap);
2245 u32 tmp;
2246 struct ahci_port_priv *pp = ap->private_data;
2247
2248 /* clear IRQ */
2249 tmp = readl(port_mmio + PORT_IRQ_STAT);
2250 writel(tmp, port_mmio + PORT_IRQ_STAT);
2251 writel(1 << ap->port_no, mmio + HOST_IRQ_STAT);
2252
2253 /* turn IRQ back on */
2254 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
2255 }
2256
2257 static void ahci_error_handler(struct ata_port *ap)
2258 {
2259 if (!(ap->pflags & ATA_PFLAG_FROZEN)) {
2260 /* restart engine */
2261 ahci_stop_engine(ap);
2262 ahci_start_engine(ap);
2263 }
2264
2265 sata_pmp_error_handler(ap);
2266 }
2267
2268 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
2269 {
2270 struct ata_port *ap = qc->ap;
2271
2272 /* make DMA engine forget about the failed command */
2273 if (qc->flags & ATA_QCFLAG_FAILED)
2274 ahci_kick_engine(ap, 1);
2275 }
2276
2277 static void ahci_pmp_attach(struct ata_port *ap)
2278 {
2279 void __iomem *port_mmio = ahci_port_base(ap);
2280 struct ahci_port_priv *pp = ap->private_data;
2281 u32 cmd;
2282
2283 cmd = readl(port_mmio + PORT_CMD);
2284 cmd |= PORT_CMD_PMP;
2285 writel(cmd, port_mmio + PORT_CMD);
2286
2287 pp->intr_mask |= PORT_IRQ_BAD_PMP;
2288 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
2289 }
2290
2291 static void ahci_pmp_detach(struct ata_port *ap)
2292 {
2293 void __iomem *port_mmio = ahci_port_base(ap);
2294 struct ahci_port_priv *pp = ap->private_data;
2295 u32 cmd;
2296
2297 cmd = readl(port_mmio + PORT_CMD);
2298 cmd &= ~PORT_CMD_PMP;
2299 writel(cmd, port_mmio + PORT_CMD);
2300
2301 pp->intr_mask &= ~PORT_IRQ_BAD_PMP;
2302 writel(pp->intr_mask, port_mmio + PORT_IRQ_MASK);
2303 }
2304
2305 static int ahci_port_resume(struct ata_port *ap)
2306 {
2307 ahci_power_up(ap);
2308 ahci_start_port(ap);
2309
2310 if (sata_pmp_attached(ap))
2311 ahci_pmp_attach(ap);
2312 else
2313 ahci_pmp_detach(ap);
2314
2315 return 0;
2316 }
2317
2318 #ifdef CONFIG_PM
2319 static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg)
2320 {
2321 const char *emsg = NULL;
2322 int rc;
2323
2324 rc = ahci_deinit_port(ap, &emsg);
2325 if (rc == 0)
2326 ahci_power_down(ap);
2327 else {
2328 ata_port_printk(ap, KERN_ERR, "%s (%d)\n", emsg, rc);
2329 ahci_start_port(ap);
2330 }
2331
2332 return rc;
2333 }
2334
2335 static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
2336 {
2337 struct ata_host *host = dev_get_drvdata(&pdev->dev);
2338 struct ahci_host_priv *hpriv = host->private_data;
2339 void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
2340 u32 ctl;
2341
2342 if (mesg.event & PM_EVENT_SUSPEND &&
2343 hpriv->flags & AHCI_HFLAG_NO_SUSPEND) {
2344 dev_printk(KERN_ERR, &pdev->dev,
2345 "BIOS update required for suspend/resume\n");
2346 return -EIO;
2347 }
2348
2349 if (mesg.event & PM_EVENT_SLEEP) {
2350 /* AHCI spec rev1.1 section 8.3.3:
2351 * Software must disable interrupts prior to requesting a
2352 * transition of the HBA to D3 state.
2353 */
2354 ctl = readl(mmio + HOST_CTL);
2355 ctl &= ~HOST_IRQ_EN;
2356 writel(ctl, mmio + HOST_CTL);
2357 readl(mmio + HOST_CTL); /* flush */
2358 }
2359
2360 return ata_pci_device_suspend(pdev, mesg);
2361 }
2362
2363 static int ahci_pci_device_resume(struct pci_dev *pdev)
2364 {
2365 struct ata_host *host = dev_get_drvdata(&pdev->dev);
2366 int rc;
2367
2368 rc = ata_pci_device_do_resume(pdev);
2369 if (rc)
2370 return rc;
2371
2372 if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2373 rc = ahci_reset_controller(host);
2374 if (rc)
2375 return rc;
2376
2377 ahci_init_controller(host);
2378 }
2379
2380 ata_host_resume(host);
2381
2382 return 0;
2383 }
2384 #endif
2385
2386 static int ahci_port_start(struct ata_port *ap)
2387 {
2388 struct device *dev = ap->host->dev;
2389 struct ahci_port_priv *pp;
2390 void *mem;
2391 dma_addr_t mem_dma;
2392
2393 pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
2394 if (!pp)
2395 return -ENOMEM;
2396
2397 mem = dmam_alloc_coherent(dev, AHCI_PORT_PRIV_DMA_SZ, &mem_dma,
2398 GFP_KERNEL);
2399 if (!mem)
2400 return -ENOMEM;
2401 memset(mem, 0, AHCI_PORT_PRIV_DMA_SZ);
2402
2403 /*
2404 * First item in chunk of DMA memory: 32-slot command table,
2405 * 32 bytes each in size
2406 */
2407 pp->cmd_slot = mem;
2408 pp->cmd_slot_dma = mem_dma;
2409
2410 mem += AHCI_CMD_SLOT_SZ;
2411 mem_dma += AHCI_CMD_SLOT_SZ;
2412
2413 /*
2414 * Second item: Received-FIS area
2415 */
2416 pp->rx_fis = mem;
2417 pp->rx_fis_dma = mem_dma;
2418
2419 mem += AHCI_RX_FIS_SZ;
2420 mem_dma += AHCI_RX_FIS_SZ;
2421
2422 /*
2423 * Third item: data area for storing a single command
2424 * and its scatter-gather table
2425 */
2426 pp->cmd_tbl = mem;
2427 pp->cmd_tbl_dma = mem_dma;
2428
2429 /*
2430 * Save off initial list of interrupts to be enabled.
2431 * This could be changed later
2432 */
2433 pp->intr_mask = DEF_PORT_IRQ;
2434
2435 ap->private_data = pp;
2436
2437 /* engage engines, captain */
2438 return ahci_port_resume(ap);
2439 }
2440
2441 static void ahci_port_stop(struct ata_port *ap)
2442 {
2443 const char *emsg = NULL;
2444 int rc;
2445
2446 /* de-initialize port */
2447 rc = ahci_deinit_port(ap, &emsg);
2448 if (rc)
2449 ata_port_printk(ap, KERN_WARNING, "%s (%d)\n", emsg, rc);
2450 }
2451
2452 static int ahci_configure_dma_masks(struct pci_dev *pdev, int using_dac)
2453 {
2454 int rc;
2455
2456 if (using_dac &&
2457 !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
2458 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
2459 if (rc) {
2460 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2461 if (rc) {
2462 dev_printk(KERN_ERR, &pdev->dev,
2463 "64-bit DMA enable failed\n");
2464 return rc;
2465 }
2466 }
2467 } else {
2468 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2469 if (rc) {
2470 dev_printk(KERN_ERR, &pdev->dev,
2471 "32-bit DMA enable failed\n");
2472 return rc;
2473 }
2474 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2475 if (rc) {
2476 dev_printk(KERN_ERR, &pdev->dev,
2477 "32-bit consistent DMA enable failed\n");
2478 return rc;
2479 }
2480 }
2481 return 0;
2482 }
2483
2484 static void ahci_print_info(struct ata_host *host)
2485 {
2486 struct ahci_host_priv *hpriv = host->private_data;
2487 struct pci_dev *pdev = to_pci_dev(host->dev);
2488 void __iomem *mmio = host->iomap[AHCI_PCI_BAR];
2489 u32 vers, cap, impl, speed;
2490 const char *speed_s;
2491 u16 cc;
2492 const char *scc_s;
2493
2494 vers = readl(mmio + HOST_VERSION);
2495 cap = hpriv->cap;
2496 impl = hpriv->port_map;
2497
2498 speed = (cap >> 20) & 0xf;
2499 if (speed == 1)
2500 speed_s = "1.5";
2501 else if (speed == 2)
2502 speed_s = "3";
2503 else if (speed == 3)
2504 speed_s = "6";
2505 else
2506 speed_s = "?";
2507
2508 pci_read_config_word(pdev, 0x0a, &cc);
2509 if (cc == PCI_CLASS_STORAGE_IDE)
2510 scc_s = "IDE";
2511 else if (cc == PCI_CLASS_STORAGE_SATA)
2512 scc_s = "SATA";
2513 else if (cc == PCI_CLASS_STORAGE_RAID)
2514 scc_s = "RAID";
2515 else
2516 scc_s = "unknown";
2517
2518 dev_printk(KERN_INFO, &pdev->dev,
2519 "AHCI %02x%02x.%02x%02x "
2520 "%u slots %u ports %s Gbps 0x%x impl %s mode\n"
2521 ,
2522
2523 (vers >> 24) & 0xff,
2524 (vers >> 16) & 0xff,
2525 (vers >> 8) & 0xff,
2526 vers & 0xff,
2527
2528 ((cap >> 8) & 0x1f) + 1,
2529 (cap & 0x1f) + 1,
2530 speed_s,
2531 impl,
2532 scc_s);
2533
2534 dev_printk(KERN_INFO, &pdev->dev,
2535 "flags: "
2536 "%s%s%s%s%s%s%s"
2537 "%s%s%s%s%s%s%s"
2538 "%s\n"
2539 ,
2540
2541 cap & (1 << 31) ? "64bit " : "",
2542 cap & (1 << 30) ? "ncq " : "",
2543 cap & (1 << 29) ? "sntf " : "",
2544 cap & (1 << 28) ? "ilck " : "",
2545 cap & (1 << 27) ? "stag " : "",
2546 cap & (1 << 26) ? "pm " : "",
2547 cap & (1 << 25) ? "led " : "",
2548
2549 cap & (1 << 24) ? "clo " : "",
2550 cap & (1 << 19) ? "nz " : "",
2551 cap & (1 << 18) ? "only " : "",
2552 cap & (1 << 17) ? "pmp " : "",
2553 cap & (1 << 15) ? "pio " : "",
2554 cap & (1 << 14) ? "slum " : "",
2555 cap & (1 << 13) ? "part " : "",
2556 cap & (1 << 6) ? "ems ": ""
2557 );
2558 }
2559
2560 /* On ASUS P5W DH Deluxe, the second port of PCI device 00:1f.2 is
2561 * hardwired to on-board SIMG 4726. The chipset is ICH8 and doesn't
2562 * support PMP and the 4726 either directly exports the device
2563 * attached to the first downstream port or acts as a hardware storage
2564 * controller and emulate a single ATA device (can be RAID 0/1 or some
2565 * other configuration).
2566 *
2567 * When there's no device attached to the first downstream port of the
2568 * 4726, "Config Disk" appears, which is a pseudo ATA device to
2569 * configure the 4726. However, ATA emulation of the device is very
2570 * lame. It doesn't send signature D2H Reg FIS after the initial
2571 * hardreset, pukes on SRST w/ PMP==0 and has bunch of other issues.
2572 *
2573 * The following function works around the problem by always using
2574 * hardreset on the port and not depending on receiving signature FIS
2575 * afterward. If signature FIS isn't received soon, ATA class is
2576 * assumed without follow-up softreset.
2577 */
2578 static void ahci_p5wdh_workaround(struct ata_host *host)
2579 {
2580 static struct dmi_system_id sysids[] = {
2581 {
2582 .ident = "P5W DH Deluxe",
2583 .matches = {
2584 DMI_MATCH(DMI_SYS_VENDOR,
2585 "ASUSTEK COMPUTER INC"),
2586 DMI_MATCH(DMI_PRODUCT_NAME, "P5W DH Deluxe"),
2587 },
2588 },
2589 { }
2590 };
2591 struct pci_dev *pdev = to_pci_dev(host->dev);
2592
2593 if (pdev->bus->number == 0 && pdev->devfn == PCI_DEVFN(0x1f, 2) &&
2594 dmi_check_system(sysids)) {
2595 struct ata_port *ap = host->ports[1];
2596
2597 dev_printk(KERN_INFO, &pdev->dev, "enabling ASUS P5W DH "
2598 "Deluxe on-board SIMG4726 workaround\n");
2599
2600 ap->ops = &ahci_p5wdh_ops;
2601 ap->link.flags |= ATA_LFLAG_NO_SRST | ATA_LFLAG_ASSUME_ATA;
2602 }
2603 }
2604
2605 /*
2606 * SB600 ahci controller on ASUS M2A-VM can't do 64bit DMA with older
2607 * BIOS. The oldest version known to be broken is 0901 and working is
2608 * 1501 which was released on 2007-10-26. Force 32bit DMA on anything
2609 * older than 1501. Please read bko#9412 for more info.
2610 */
2611 static bool ahci_asus_m2a_vm_32bit_only(struct pci_dev *pdev)
2612 {
2613 static const struct dmi_system_id sysids[] = {
2614 {
2615 .ident = "ASUS M2A-VM",
2616 .matches = {
2617 DMI_MATCH(DMI_BOARD_VENDOR,
2618 "ASUSTeK Computer INC."),
2619 DMI_MATCH(DMI_BOARD_NAME, "M2A-VM"),
2620 },
2621 },
2622 { }
2623 };
2624 const char *cutoff_mmdd = "10/26";
2625 const char *date;
2626 int year;
2627
2628 if (pdev->bus->number != 0 || pdev->devfn != PCI_DEVFN(0x12, 0) ||
2629 !dmi_check_system(sysids))
2630 return false;
2631
2632 /*
2633 * Argh.... both version and date are free form strings.
2634 * Let's hope they're using the same date format across
2635 * different versions.
2636 */
2637 date = dmi_get_system_info(DMI_BIOS_DATE);
2638 year = dmi_get_year(DMI_BIOS_DATE);
2639 if (date && strlen(date) >= 10 && date[2] == '/' && date[5] == '/' &&
2640 (year > 2007 ||
2641 (year == 2007 && strncmp(date, cutoff_mmdd, 5) >= 0)))
2642 return false;
2643
2644 dev_printk(KERN_WARNING, &pdev->dev, "ASUS M2A-VM: BIOS too old, "
2645 "forcing 32bit DMA, update BIOS\n");
2646
2647 return true;
2648 }
2649
2650 static bool ahci_broken_system_poweroff(struct pci_dev *pdev)
2651 {
2652 static const struct dmi_system_id broken_systems[] = {
2653 {
2654 .ident = "HP Compaq nx6310",
2655 .matches = {
2656 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2657 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6310"),
2658 },
2659 /* PCI slot number of the controller */
2660 .driver_data = (void *)0x1FUL,
2661 },
2662 {
2663 .ident = "HP Compaq 6720s",
2664 .matches = {
2665 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2666 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6720s"),
2667 },
2668 /* PCI slot number of the controller */
2669 .driver_data = (void *)0x1FUL,
2670 },
2671
2672 { } /* terminate list */
2673 };
2674 const struct dmi_system_id *dmi = dmi_first_match(broken_systems);
2675
2676 if (dmi) {
2677 unsigned long slot = (unsigned long)dmi->driver_data;
2678 /* apply the quirk only to on-board controllers */
2679 return slot == PCI_SLOT(pdev->devfn);
2680 }
2681
2682 return false;
2683 }
2684
2685 static bool ahci_broken_suspend(struct pci_dev *pdev)
2686 {
2687 static const struct dmi_system_id sysids[] = {
2688 /*
2689 * On HP dv[4-6] and HDX18 with earlier BIOSen, link
2690 * to the harddisk doesn't become online after
2691 * resuming from STR. Warn and fail suspend.
2692 */
2693 {
2694 .ident = "dv4",
2695 .matches = {
2696 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2697 DMI_MATCH(DMI_PRODUCT_NAME,
2698 "HP Pavilion dv4 Notebook PC"),
2699 },
2700 .driver_data = "F.30", /* cutoff BIOS version */
2701 },
2702 {
2703 .ident = "dv5",
2704 .matches = {
2705 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2706 DMI_MATCH(DMI_PRODUCT_NAME,
2707 "HP Pavilion dv5 Notebook PC"),
2708 },
2709 .driver_data = "F.16", /* cutoff BIOS version */
2710 },
2711 {
2712 .ident = "dv6",
2713 .matches = {
2714 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2715 DMI_MATCH(DMI_PRODUCT_NAME,
2716 "HP Pavilion dv6 Notebook PC"),
2717 },
2718 .driver_data = "F.21", /* cutoff BIOS version */
2719 },
2720 {
2721 .ident = "HDX18",
2722 .matches = {
2723 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
2724 DMI_MATCH(DMI_PRODUCT_NAME,
2725 "HP HDX18 Notebook PC"),
2726 },
2727 .driver_data = "F.23", /* cutoff BIOS version */
2728 },
2729 { } /* terminate list */
2730 };
2731 const struct dmi_system_id *dmi = dmi_first_match(sysids);
2732 const char *ver;
2733
2734 if (!dmi || pdev->bus->number || pdev->devfn != PCI_DEVFN(0x1f, 2))
2735 return false;
2736
2737 ver = dmi_get_system_info(DMI_BIOS_VERSION);
2738
2739 return !ver || strcmp(ver, dmi->driver_data) < 0;
2740 }
2741
2742 static bool ahci_broken_online(struct pci_dev *pdev)
2743 {
2744 #define ENCODE_BUSDEVFN(bus, slot, func) \
2745 (void *)(unsigned long)(((bus) << 8) | PCI_DEVFN((slot), (func)))
2746 static const struct dmi_system_id sysids[] = {
2747 /*
2748 * There are several gigabyte boards which use
2749 * SIMG5723s configured as hardware RAID. Certain
2750 * 5723 firmware revisions shipped there keep the link
2751 * online but fail to answer properly to SRST or
2752 * IDENTIFY when no device is attached downstream
2753 * causing libata to retry quite a few times leading
2754 * to excessive detection delay.
2755 *
2756 * As these firmwares respond to the second reset try
2757 * with invalid device signature, considering unknown
2758 * sig as offline works around the problem acceptably.
2759 */
2760 {
2761 .ident = "EP45-DQ6",
2762 .matches = {
2763 DMI_MATCH(DMI_BOARD_VENDOR,
2764 "Gigabyte Technology Co., Ltd."),
2765 DMI_MATCH(DMI_BOARD_NAME, "EP45-DQ6"),
2766 },
2767 .driver_data = ENCODE_BUSDEVFN(0x0a, 0x00, 0),
2768 },
2769 {
2770 .ident = "EP45-DS5",
2771 .matches = {
2772 DMI_MATCH(DMI_BOARD_VENDOR,
2773 "Gigabyte Technology Co., Ltd."),
2774 DMI_MATCH(DMI_BOARD_NAME, "EP45-DS5"),
2775 },
2776 .driver_data = ENCODE_BUSDEVFN(0x03, 0x00, 0),
2777 },
2778 { } /* terminate list */
2779 };
2780 #undef ENCODE_BUSDEVFN
2781 const struct dmi_system_id *dmi = dmi_first_match(sysids);
2782 unsigned int val;
2783
2784 if (!dmi)
2785 return false;
2786
2787 val = (unsigned long)dmi->driver_data;
2788
2789 return pdev->bus->number == (val >> 8) && pdev->devfn == (val & 0xff);
2790 }
2791
2792 static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
2793 {
2794 static int printed_version;
2795 unsigned int board_id = ent->driver_data;
2796 struct ata_port_info pi = ahci_port_info[board_id];
2797 const struct ata_port_info *ppi[] = { &pi, NULL };
2798 struct device *dev = &pdev->dev;
2799 struct ahci_host_priv *hpriv;
2800 struct ata_host *host;
2801 int n_ports, i, rc;
2802
2803 VPRINTK("ENTER\n");
2804
2805 WARN_ON(ATA_MAX_QUEUE > AHCI_MAX_CMDS);
2806
2807 if (!printed_version++)
2808 dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
2809
2810 /* The AHCI driver can only drive the SATA ports, the PATA driver
2811 can drive them all so if both drivers are selected make sure
2812 AHCI stays out of the way */
2813 if (pdev->vendor == PCI_VENDOR_ID_MARVELL && !marvell_enable)
2814 return -ENODEV;
2815
2816 /* acquire resources */
2817 rc = pcim_enable_device(pdev);
2818 if (rc)
2819 return rc;
2820
2821 /* AHCI controllers often implement SFF compatible interface.
2822 * Grab all PCI BARs just in case.
2823 */
2824 rc = pcim_iomap_regions_request_all(pdev, 1 << AHCI_PCI_BAR, DRV_NAME);
2825 if (rc == -EBUSY)
2826 pcim_pin_device(pdev);
2827 if (rc)
2828 return rc;
2829
2830 if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
2831 (pdev->device == 0x2652 || pdev->device == 0x2653)) {
2832 u8 map;
2833
2834 /* ICH6s share the same PCI ID for both piix and ahci
2835 * modes. Enabling ahci mode while MAP indicates
2836 * combined mode is a bad idea. Yield to ata_piix.
2837 */
2838 pci_read_config_byte(pdev, ICH_MAP, &map);
2839 if (map & 0x3) {
2840 dev_printk(KERN_INFO, &pdev->dev, "controller is in "
2841 "combined mode, can't enable AHCI mode\n");
2842 return -ENODEV;
2843 }
2844 }
2845
2846 hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
2847 if (!hpriv)
2848 return -ENOMEM;
2849 hpriv->flags |= (unsigned long)pi.private_data;
2850
2851 /* MCP65 revision A1 and A2 can't do MSI */
2852 if (board_id == board_ahci_mcp65 &&
2853 (pdev->revision == 0xa1 || pdev->revision == 0xa2))
2854 hpriv->flags |= AHCI_HFLAG_NO_MSI;
2855
2856 /* SB800 does NOT need the workaround to ignore SERR_INTERNAL */
2857 if (board_id == board_ahci_sb700 && pdev->revision >= 0x40)
2858 hpriv->flags &= ~AHCI_HFLAG_IGN_SERR_INTERNAL;
2859
2860 /* apply ASUS M2A_VM quirk */
2861 if (ahci_asus_m2a_vm_32bit_only(pdev))
2862 hpriv->flags |= AHCI_HFLAG_32BIT_ONLY;
2863
2864 if (!(hpriv->flags & AHCI_HFLAG_NO_MSI))
2865 pci_enable_msi(pdev);
2866
2867 /* save initial config */
2868 ahci_save_initial_config(pdev, hpriv);
2869
2870 /* prepare host */
2871 if (hpriv->cap & HOST_CAP_NCQ)
2872 pi.flags |= ATA_FLAG_NCQ | ATA_FLAG_FPDMA_AA;
2873
2874 if (hpriv->cap & HOST_CAP_PMP)
2875 pi.flags |= ATA_FLAG_PMP;
2876
2877 if (ahci_em_messages && (hpriv->cap & HOST_CAP_EMS)) {
2878 u8 messages;
2879 void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
2880 u32 em_loc = readl(mmio + HOST_EM_LOC);
2881 u32 em_ctl = readl(mmio + HOST_EM_CTL);
2882
2883 messages = (em_ctl & EM_CTRL_MSG_TYPE) >> 16;
2884
2885 /* we only support LED message type right now */
2886 if ((messages & 0x01) && (ahci_em_messages == 1)) {
2887 /* store em_loc */
2888 hpriv->em_loc = ((em_loc >> 16) * 4);
2889 pi.flags |= ATA_FLAG_EM;
2890 if (!(em_ctl & EM_CTL_ALHD))
2891 pi.flags |= ATA_FLAG_SW_ACTIVITY;
2892 }
2893 }
2894
2895 if (ahci_broken_system_poweroff(pdev)) {
2896 pi.flags |= ATA_FLAG_NO_POWEROFF_SPINDOWN;
2897 dev_info(&pdev->dev,
2898 "quirky BIOS, skipping spindown on poweroff\n");
2899 }
2900
2901 if (ahci_broken_suspend(pdev)) {
2902 hpriv->flags |= AHCI_HFLAG_NO_SUSPEND;
2903 dev_printk(KERN_WARNING, &pdev->dev,
2904 "BIOS update required for suspend/resume\n");
2905 }
2906
2907 if (ahci_broken_online(pdev)) {
2908 hpriv->flags |= AHCI_HFLAG_SRST_TOUT_IS_OFFLINE;
2909 dev_info(&pdev->dev,
2910 "online status unreliable, applying workaround\n");
2911 }
2912
2913 /* CAP.NP sometimes indicate the index of the last enabled
2914 * port, at other times, that of the last possible port, so
2915 * determining the maximum port number requires looking at
2916 * both CAP.NP and port_map.
2917 */
2918 n_ports = max(ahci_nr_ports(hpriv->cap), fls(hpriv->port_map));
2919
2920 host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports);
2921 if (!host)
2922 return -ENOMEM;
2923 host->iomap = pcim_iomap_table(pdev);
2924 host->private_data = hpriv;
2925
2926 if (!(hpriv->cap & HOST_CAP_SSS) || ahci_ignore_sss)
2927 host->flags |= ATA_HOST_PARALLEL_SCAN;
2928 else
2929 printk(KERN_INFO "ahci: SSS flag set, parallel bus scan disabled\n");
2930
2931 if (pi.flags & ATA_FLAG_EM)
2932 ahci_reset_em(host);
2933
2934 for (i = 0; i < host->n_ports; i++) {
2935 struct ata_port *ap = host->ports[i];
2936
2937 ata_port_pbar_desc(ap, AHCI_PCI_BAR, -1, "abar");
2938 ata_port_pbar_desc(ap, AHCI_PCI_BAR,
2939 0x100 + ap->port_no * 0x80, "port");
2940
2941 /* set initial link pm policy */
2942 ap->pm_policy = NOT_AVAILABLE;
2943
2944 /* set enclosure management message type */
2945 if (ap->flags & ATA_FLAG_EM)
2946 ap->em_message_type = ahci_em_messages;
2947
2948
2949 /* disabled/not-implemented port */
2950 if (!(hpriv->port_map & (1 << i)))
2951 ap->ops = &ata_dummy_port_ops;
2952 }
2953
2954 /* apply workaround for ASUS P5W DH Deluxe mainboard */
2955 ahci_p5wdh_workaround(host);
2956
2957 /* initialize adapter */
2958 rc = ahci_configure_dma_masks(pdev, hpriv->cap & HOST_CAP_64);
2959 if (rc)
2960 return rc;
2961
2962 rc = ahci_reset_controller(host);
2963 if (rc)
2964 return rc;
2965
2966 ahci_init_controller(host);
2967 ahci_print_info(host);
2968
2969 pci_set_master(pdev);
2970 return ata_host_activate(host, pdev->irq, ahci_interrupt, IRQF_SHARED,
2971 &ahci_sht);
2972 }
2973
2974 static int __init ahci_init(void)
2975 {
2976 return pci_register_driver(&ahci_pci_driver);
2977 }
2978
2979 static void __exit ahci_exit(void)
2980 {
2981 pci_unregister_driver(&ahci_pci_driver);
2982 }
2983
2984
2985 MODULE_AUTHOR("Jeff Garzik");
2986 MODULE_DESCRIPTION("AHCI SATA low-level driver");
2987 MODULE_LICENSE("GPL");
2988 MODULE_DEVICE_TABLE(pci, ahci_pci_tbl);
2989 MODULE_VERSION(DRV_VERSION);
2990
2991 module_init(ahci_init);
2992 module_exit(ahci_exit);
Linux kernel - Deliverables
This page took 0.16449 seconds and 6 git commands to generate.