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