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