Commit | Line | Data |
---|---|---|
c82ee6d3 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
2 | /* |
3 | * sata_sil.c - Silicon Image SATA | |
4 | * | |
8c3d3d4b | 5 | * Maintained by: Tejun Heo <tj@kernel.org> |
1da177e4 LT |
6 | * Please ALWAYS copy linux-ide@vger.kernel.org |
7 | * on emails. | |
8 | * | |
af36d7f0 | 9 | * Copyright 2003-2005 Red Hat, Inc. |
1da177e4 LT |
10 | * Copyright 2003 Benjamin Herrenschmidt |
11 | * | |
af36d7f0 | 12 | * libata documentation is available via 'make {ps|pdf}docs', |
19285f3c | 13 | * as Documentation/driver-api/libata.rst |
1da177e4 | 14 | * |
953d1137 JG |
15 | * Documentation for SiI 3112: |
16 | * http://gkernel.sourceforge.net/specs/sii/3112A_SiI-DS-0095-B2.pdf.bz2 | |
17 | * | |
18 | * Other errata and documentation available under NDA. | |
1da177e4 LT |
19 | */ |
20 | ||
21 | #include <linux/kernel.h> | |
22 | #include <linux/module.h> | |
23 | #include <linux/pci.h> | |
1da177e4 LT |
24 | #include <linux/blkdev.h> |
25 | #include <linux/delay.h> | |
26 | #include <linux/interrupt.h> | |
a9524a76 | 27 | #include <linux/device.h> |
1da177e4 LT |
28 | #include <scsi/scsi_host.h> |
29 | #include <linux/libata.h> | |
1737ef75 | 30 | #include <linux/dmi.h> |
1da177e4 LT |
31 | |
32 | #define DRV_NAME "sata_sil" | |
c7e324f1 RH |
33 | #define DRV_VERSION "2.4" |
34 | ||
35 | #define SIL_DMA_BOUNDARY 0x7fffffffUL | |
1da177e4 LT |
36 | |
37 | enum { | |
0d5ff566 TH |
38 | SIL_MMIO_BAR = 5, |
39 | ||
e653a1e6 TH |
40 | /* |
41 | * host flags | |
42 | */ | |
201ce859 | 43 | SIL_FLAG_NO_SATA_IRQ = (1 << 28), |
e4e10e3e | 44 | SIL_FLAG_RERR_ON_DMA_ACT = (1 << 29), |
e4deec63 | 45 | SIL_FLAG_MOD15WRITE = (1 << 30), |
20888d83 | 46 | |
9cbe056f | 47 | SIL_DFL_PORT_FLAGS = ATA_FLAG_SATA, |
e4deec63 | 48 | |
e653a1e6 TH |
49 | /* |
50 | * Controller IDs | |
51 | */ | |
1da177e4 | 52 | sil_3112 = 0, |
201ce859 TH |
53 | sil_3112_no_sata_irq = 1, |
54 | sil_3512 = 2, | |
55 | sil_3114 = 3, | |
1da177e4 | 56 | |
e653a1e6 TH |
57 | /* |
58 | * Register offsets | |
59 | */ | |
1da177e4 | 60 | SIL_SYSCFG = 0x48, |
e653a1e6 TH |
61 | |
62 | /* | |
63 | * Register bits | |
64 | */ | |
65 | /* SYSCFG */ | |
1da177e4 LT |
66 | SIL_MASK_IDE0_INT = (1 << 22), |
67 | SIL_MASK_IDE1_INT = (1 << 23), | |
68 | SIL_MASK_IDE2_INT = (1 << 24), | |
69 | SIL_MASK_IDE3_INT = (1 << 25), | |
70 | SIL_MASK_2PORT = SIL_MASK_IDE0_INT | SIL_MASK_IDE1_INT, | |
71 | SIL_MASK_4PORT = SIL_MASK_2PORT | | |
72 | SIL_MASK_IDE2_INT | SIL_MASK_IDE3_INT, | |
73 | ||
e653a1e6 | 74 | /* BMDMA/BMDMA2 */ |
1da177e4 | 75 | SIL_INTR_STEERING = (1 << 1), |
e653a1e6 | 76 | |
20888d83 TH |
77 | SIL_DMA_ENABLE = (1 << 0), /* DMA run switch */ |
78 | SIL_DMA_RDWR = (1 << 3), /* DMA Rd-Wr */ | |
79 | SIL_DMA_SATA_IRQ = (1 << 4), /* OR of all SATA IRQs */ | |
80 | SIL_DMA_ACTIVE = (1 << 16), /* DMA running */ | |
81 | SIL_DMA_ERROR = (1 << 17), /* PCI bus error */ | |
82 | SIL_DMA_COMPLETE = (1 << 18), /* cmd complete / IRQ pending */ | |
83 | SIL_DMA_N_SATA_IRQ = (1 << 6), /* SATA_IRQ for the next channel */ | |
84 | SIL_DMA_N_ACTIVE = (1 << 24), /* ACTIVE for the next channel */ | |
85 | SIL_DMA_N_ERROR = (1 << 25), /* ERROR for the next channel */ | |
86 | SIL_DMA_N_COMPLETE = (1 << 26), /* COMPLETE for the next channel */ | |
87 | ||
88 | /* SIEN */ | |
89 | SIL_SIEN_N = (1 << 16), /* triggered by SError.N */ | |
90 | ||
e653a1e6 TH |
91 | /* |
92 | * Others | |
93 | */ | |
1da177e4 LT |
94 | SIL_QUIRK_MOD15WRITE = (1 << 0), |
95 | SIL_QUIRK_UDMA5MAX = (1 << 1), | |
96 | }; | |
97 | ||
5796d1c4 | 98 | static int sil_init_one(struct pci_dev *pdev, const struct pci_device_id *ent); |
58eb8cd5 | 99 | #ifdef CONFIG_PM_SLEEP |
afb5a7cb | 100 | static int sil_pci_device_resume(struct pci_dev *pdev); |
281d426c | 101 | #endif |
cd0d3bbc | 102 | static void sil_dev_config(struct ata_device *dev); |
82ef04fb TH |
103 | static int sil_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val); |
104 | static int sil_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val); | |
0260731f | 105 | static int sil_set_mode(struct ata_link *link, struct ata_device **r_failed); |
95364f36 | 106 | static enum ata_completion_errors sil_qc_prep(struct ata_queued_cmd *qc); |
c7e324f1 RH |
107 | static void sil_bmdma_setup(struct ata_queued_cmd *qc); |
108 | static void sil_bmdma_start(struct ata_queued_cmd *qc); | |
109 | static void sil_bmdma_stop(struct ata_queued_cmd *qc); | |
f6aae27e TH |
110 | static void sil_freeze(struct ata_port *ap); |
111 | static void sil_thaw(struct ata_port *ap); | |
1da177e4 | 112 | |
374b1873 | 113 | |
3b7d697d | 114 | static const struct pci_device_id sil_pci_tbl[] = { |
54bb3a94 JG |
115 | { PCI_VDEVICE(CMD, 0x3112), sil_3112 }, |
116 | { PCI_VDEVICE(CMD, 0x0240), sil_3112 }, | |
117 | { PCI_VDEVICE(CMD, 0x3512), sil_3512 }, | |
118 | { PCI_VDEVICE(CMD, 0x3114), sil_3114 }, | |
119 | { PCI_VDEVICE(ATI, 0x436e), sil_3112 }, | |
120 | { PCI_VDEVICE(ATI, 0x4379), sil_3112_no_sata_irq }, | |
121 | { PCI_VDEVICE(ATI, 0x437a), sil_3112_no_sata_irq }, | |
122 | ||
1da177e4 LT |
123 | { } /* terminate list */ |
124 | }; | |
125 | ||
126 | ||
127 | /* TODO firmware versions should be added - eric */ | |
128 | static const struct sil_drivelist { | |
5796d1c4 | 129 | const char *product; |
1da177e4 LT |
130 | unsigned int quirk; |
131 | } sil_blacklist [] = { | |
132 | { "ST320012AS", SIL_QUIRK_MOD15WRITE }, | |
133 | { "ST330013AS", SIL_QUIRK_MOD15WRITE }, | |
134 | { "ST340017AS", SIL_QUIRK_MOD15WRITE }, | |
135 | { "ST360015AS", SIL_QUIRK_MOD15WRITE }, | |
1da177e4 LT |
136 | { "ST380023AS", SIL_QUIRK_MOD15WRITE }, |
137 | { "ST3120023AS", SIL_QUIRK_MOD15WRITE }, | |
1da177e4 LT |
138 | { "ST340014ASL", SIL_QUIRK_MOD15WRITE }, |
139 | { "ST360014ASL", SIL_QUIRK_MOD15WRITE }, | |
140 | { "ST380011ASL", SIL_QUIRK_MOD15WRITE }, | |
141 | { "ST3120022ASL", SIL_QUIRK_MOD15WRITE }, | |
142 | { "ST3160021ASL", SIL_QUIRK_MOD15WRITE }, | |
9f9c47f0 | 143 | { "TOSHIBA MK2561GSYN", SIL_QUIRK_MOD15WRITE }, |
1da177e4 LT |
144 | { "Maxtor 4D060H3", SIL_QUIRK_UDMA5MAX }, |
145 | { } | |
146 | }; | |
147 | ||
148 | static struct pci_driver sil_pci_driver = { | |
149 | .name = DRV_NAME, | |
150 | .id_table = sil_pci_tbl, | |
151 | .probe = sil_init_one, | |
152 | .remove = ata_pci_remove_one, | |
58eb8cd5 | 153 | #ifdef CONFIG_PM_SLEEP |
afb5a7cb TH |
154 | .suspend = ata_pci_device_suspend, |
155 | .resume = sil_pci_device_resume, | |
281d426c | 156 | #endif |
1da177e4 LT |
157 | }; |
158 | ||
25df73d9 | 159 | static const struct scsi_host_template sil_sht = { |
c7e324f1 RH |
160 | ATA_BASE_SHT(DRV_NAME), |
161 | /** These controllers support Large Block Transfer which allows | |
162 | transfer chunks up to 2GB and which cross 64KB boundaries, | |
163 | therefore the DMA limits are more relaxed than standard ATA SFF. */ | |
164 | .dma_boundary = SIL_DMA_BOUNDARY, | |
165 | .sg_tablesize = ATA_MAX_PRD | |
1da177e4 LT |
166 | }; |
167 | ||
029cfd6b | 168 | static struct ata_port_operations sil_ops = { |
31f80112 | 169 | .inherits = &ata_bmdma32_port_ops, |
1da177e4 | 170 | .dev_config = sil_dev_config, |
9d2c7c75 | 171 | .set_mode = sil_set_mode, |
c7e324f1 RH |
172 | .bmdma_setup = sil_bmdma_setup, |
173 | .bmdma_start = sil_bmdma_start, | |
174 | .bmdma_stop = sil_bmdma_stop, | |
175 | .qc_prep = sil_qc_prep, | |
f6aae27e TH |
176 | .freeze = sil_freeze, |
177 | .thaw = sil_thaw, | |
1da177e4 LT |
178 | .scr_read = sil_scr_read, |
179 | .scr_write = sil_scr_write, | |
1da177e4 LT |
180 | }; |
181 | ||
98ac62de | 182 | static const struct ata_port_info sil_port_info[] = { |
1da177e4 | 183 | /* sil_3112 */ |
e4deec63 | 184 | { |
cca3974e | 185 | .flags = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE, |
14bdef98 EIB |
186 | .pio_mask = ATA_PIO4, |
187 | .mwdma_mask = ATA_MWDMA2, | |
bf6263a8 | 188 | .udma_mask = ATA_UDMA5, |
e4deec63 | 189 | .port_ops = &sil_ops, |
0ee304d5 | 190 | }, |
201ce859 TH |
191 | /* sil_3112_no_sata_irq */ |
192 | { | |
cca3974e | 193 | .flags = SIL_DFL_PORT_FLAGS | SIL_FLAG_MOD15WRITE | |
201ce859 | 194 | SIL_FLAG_NO_SATA_IRQ, |
14bdef98 EIB |
195 | .pio_mask = ATA_PIO4, |
196 | .mwdma_mask = ATA_MWDMA2, | |
bf6263a8 | 197 | .udma_mask = ATA_UDMA5, |
201ce859 TH |
198 | .port_ops = &sil_ops, |
199 | }, | |
0ee304d5 | 200 | /* sil_3512 */ |
1da177e4 | 201 | { |
cca3974e | 202 | .flags = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT, |
14bdef98 EIB |
203 | .pio_mask = ATA_PIO4, |
204 | .mwdma_mask = ATA_MWDMA2, | |
bf6263a8 | 205 | .udma_mask = ATA_UDMA5, |
0ee304d5 TH |
206 | .port_ops = &sil_ops, |
207 | }, | |
208 | /* sil_3114 */ | |
1da177e4 | 209 | { |
cca3974e | 210 | .flags = SIL_DFL_PORT_FLAGS | SIL_FLAG_RERR_ON_DMA_ACT, |
14bdef98 EIB |
211 | .pio_mask = ATA_PIO4, |
212 | .mwdma_mask = ATA_MWDMA2, | |
bf6263a8 | 213 | .udma_mask = ATA_UDMA5, |
1da177e4 LT |
214 | .port_ops = &sil_ops, |
215 | }, | |
216 | }; | |
217 | ||
218 | /* per-port register offsets */ | |
219 | /* TODO: we can probably calculate rather than use a table */ | |
220 | static const struct { | |
221 | unsigned long tf; /* ATA taskfile register block */ | |
222 | unsigned long ctl; /* ATA control/altstatus register block */ | |
223 | unsigned long bmdma; /* DMA register block */ | |
20888d83 | 224 | unsigned long bmdma2; /* DMA register block #2 */ |
48d4ef2a | 225 | unsigned long fifo_cfg; /* FIFO Valid Byte Count and Control */ |
1da177e4 LT |
226 | unsigned long scr; /* SATA control register block */ |
227 | unsigned long sien; /* SATA Interrupt Enable register */ | |
228 | unsigned long xfer_mode;/* data transfer mode register */ | |
e4e10e3e | 229 | unsigned long sfis_cfg; /* SATA FIS reception config register */ |
1da177e4 LT |
230 | } sil_port[] = { |
231 | /* port 0 ... */ | |
5bcd7a00 JG |
232 | /* tf ctl bmdma bmdma2 fifo scr sien mode sfis */ |
233 | { 0x80, 0x8A, 0x0, 0x10, 0x40, 0x100, 0x148, 0xb4, 0x14c }, | |
234 | { 0xC0, 0xCA, 0x8, 0x18, 0x44, 0x180, 0x1c8, 0xf4, 0x1cc }, | |
20888d83 TH |
235 | { 0x280, 0x28A, 0x200, 0x210, 0x240, 0x300, 0x348, 0x2b4, 0x34c }, |
236 | { 0x2C0, 0x2CA, 0x208, 0x218, 0x244, 0x380, 0x3c8, 0x2f4, 0x3cc }, | |
1da177e4 LT |
237 | /* ... port 3 */ |
238 | }; | |
239 | ||
240 | MODULE_AUTHOR("Jeff Garzik"); | |
241 | MODULE_DESCRIPTION("low-level driver for Silicon Image SATA controller"); | |
242 | MODULE_LICENSE("GPL"); | |
243 | MODULE_DEVICE_TABLE(pci, sil_pci_tbl); | |
244 | MODULE_VERSION(DRV_VERSION); | |
245 | ||
5796d1c4 | 246 | static int slow_down; |
51e9f2ff JG |
247 | module_param(slow_down, int, 0444); |
248 | MODULE_PARM_DESC(slow_down, "Sledgehammer used to work around random problems, by limiting commands to 15 sectors (0=off, 1=on)"); | |
249 | ||
374b1873 | 250 | |
c7e324f1 RH |
251 | static void sil_bmdma_stop(struct ata_queued_cmd *qc) |
252 | { | |
253 | struct ata_port *ap = qc->ap; | |
254 | void __iomem *mmio_base = ap->host->iomap[SIL_MMIO_BAR]; | |
255 | void __iomem *bmdma2 = mmio_base + sil_port[ap->port_no].bmdma2; | |
256 | ||
257 | /* clear start/stop bit - can safely always write 0 */ | |
258 | iowrite8(0, bmdma2); | |
259 | ||
260 | /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */ | |
261 | ata_sff_dma_pause(ap); | |
262 | } | |
263 | ||
264 | static void sil_bmdma_setup(struct ata_queued_cmd *qc) | |
265 | { | |
266 | struct ata_port *ap = qc->ap; | |
267 | void __iomem *bmdma = ap->ioaddr.bmdma_addr; | |
268 | ||
269 | /* load PRD table addr. */ | |
f60d7011 | 270 | iowrite32(ap->bmdma_prd_dma, bmdma + ATA_DMA_TABLE_OFS); |
c7e324f1 RH |
271 | |
272 | /* issue r/w command */ | |
273 | ap->ops->sff_exec_command(ap, &qc->tf); | |
274 | } | |
275 | ||
276 | static void sil_bmdma_start(struct ata_queued_cmd *qc) | |
277 | { | |
278 | unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE); | |
279 | struct ata_port *ap = qc->ap; | |
280 | void __iomem *mmio_base = ap->host->iomap[SIL_MMIO_BAR]; | |
281 | void __iomem *bmdma2 = mmio_base + sil_port[ap->port_no].bmdma2; | |
282 | u8 dmactl = ATA_DMA_START; | |
283 | ||
284 | /* set transfer direction, start host DMA transaction | |
285 | Note: For Large Block Transfer to work, the DMA must be started | |
286 | using the bmdma2 register. */ | |
287 | if (!rw) | |
288 | dmactl |= ATA_DMA_WR; | |
289 | iowrite8(dmactl, bmdma2); | |
290 | } | |
291 | ||
292 | /* The way God intended PCI IDE scatter/gather lists to look and behave... */ | |
293 | static void sil_fill_sg(struct ata_queued_cmd *qc) | |
294 | { | |
295 | struct scatterlist *sg; | |
296 | struct ata_port *ap = qc->ap; | |
f60d7011 | 297 | struct ata_bmdma_prd *prd, *last_prd = NULL; |
c7e324f1 RH |
298 | unsigned int si; |
299 | ||
f60d7011 | 300 | prd = &ap->bmdma_prd[0]; |
c7e324f1 RH |
301 | for_each_sg(qc->sg, sg, qc->n_elem, si) { |
302 | /* Note h/w doesn't support 64-bit, so we unconditionally | |
303 | * truncate dma_addr_t to u32. | |
304 | */ | |
305 | u32 addr = (u32) sg_dma_address(sg); | |
306 | u32 sg_len = sg_dma_len(sg); | |
307 | ||
308 | prd->addr = cpu_to_le32(addr); | |
309 | prd->flags_len = cpu_to_le32(sg_len); | |
c7e324f1 RH |
310 | |
311 | last_prd = prd; | |
312 | prd++; | |
313 | } | |
314 | ||
315 | if (likely(last_prd)) | |
316 | last_prd->flags_len |= cpu_to_le32(ATA_PRD_EOT); | |
317 | } | |
318 | ||
95364f36 | 319 | static enum ata_completion_errors sil_qc_prep(struct ata_queued_cmd *qc) |
c7e324f1 RH |
320 | { |
321 | if (!(qc->flags & ATA_QCFLAG_DMAMAP)) | |
95364f36 | 322 | return AC_ERR_OK; |
c7e324f1 RH |
323 | |
324 | sil_fill_sg(qc); | |
95364f36 JS |
325 | |
326 | return AC_ERR_OK; | |
c7e324f1 RH |
327 | } |
328 | ||
1da177e4 LT |
329 | static unsigned char sil_get_device_cache_line(struct pci_dev *pdev) |
330 | { | |
331 | u8 cache_line = 0; | |
332 | pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_line); | |
333 | return cache_line; | |
334 | } | |
335 | ||
9d2c7c75 AC |
336 | /** |
337 | * sil_set_mode - wrap set_mode functions | |
0260731f | 338 | * @link: link to set up |
9d2c7c75 AC |
339 | * @r_failed: returned device when we fail |
340 | * | |
341 | * Wrap the libata method for device setup as after the setup we need | |
342 | * to inspect the results and do some configuration work | |
343 | */ | |
344 | ||
0260731f | 345 | static int sil_set_mode(struct ata_link *link, struct ata_device **r_failed) |
1da177e4 | 346 | { |
0260731f TH |
347 | struct ata_port *ap = link->ap; |
348 | void __iomem *mmio_base = ap->host->iomap[SIL_MMIO_BAR]; | |
0d5ff566 | 349 | void __iomem *addr = mmio_base + sil_port[ap->port_no].xfer_mode; |
0260731f | 350 | struct ata_device *dev; |
f58229f8 | 351 | u32 tmp, dev_mode[2] = { }; |
9d2c7c75 | 352 | int rc; |
a617c09f | 353 | |
0260731f | 354 | rc = ata_do_set_mode(link, r_failed); |
9d2c7c75 AC |
355 | if (rc) |
356 | return rc; | |
1da177e4 | 357 | |
1eca4365 | 358 | ata_for_each_dev(dev, link, ALL) { |
e1211e3f | 359 | if (!ata_dev_enabled(dev)) |
f58229f8 | 360 | dev_mode[dev->devno] = 0; /* PIO0/1/2 */ |
1da177e4 | 361 | else if (dev->flags & ATA_DFLAG_PIO) |
f58229f8 | 362 | dev_mode[dev->devno] = 1; /* PIO3/4 */ |
1da177e4 | 363 | else |
f58229f8 | 364 | dev_mode[dev->devno] = 3; /* UDMA */ |
1da177e4 LT |
365 | /* value 2 indicates MDMA */ |
366 | } | |
367 | ||
368 | tmp = readl(addr); | |
369 | tmp &= ~((1<<5) | (1<<4) | (1<<1) | (1<<0)); | |
370 | tmp |= dev_mode[0]; | |
371 | tmp |= (dev_mode[1] << 4); | |
372 | writel(tmp, addr); | |
373 | readl(addr); /* flush */ | |
9d2c7c75 | 374 | return 0; |
1da177e4 LT |
375 | } |
376 | ||
5796d1c4 JG |
377 | static inline void __iomem *sil_scr_addr(struct ata_port *ap, |
378 | unsigned int sc_reg) | |
1da177e4 | 379 | { |
0d5ff566 | 380 | void __iomem *offset = ap->ioaddr.scr_addr; |
1da177e4 LT |
381 | |
382 | switch (sc_reg) { | |
383 | case SCR_STATUS: | |
384 | return offset + 4; | |
385 | case SCR_ERROR: | |
386 | return offset + 8; | |
387 | case SCR_CONTROL: | |
388 | return offset; | |
389 | default: | |
390 | /* do nothing */ | |
391 | break; | |
392 | } | |
393 | ||
8d9db2d2 | 394 | return NULL; |
1da177e4 LT |
395 | } |
396 | ||
82ef04fb | 397 | static int sil_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val) |
1da177e4 | 398 | { |
82ef04fb | 399 | void __iomem *mmio = sil_scr_addr(link->ap, sc_reg); |
da3dbb17 TH |
400 | |
401 | if (mmio) { | |
402 | *val = readl(mmio); | |
403 | return 0; | |
404 | } | |
405 | return -EINVAL; | |
1da177e4 LT |
406 | } |
407 | ||
82ef04fb | 408 | static int sil_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val) |
1da177e4 | 409 | { |
82ef04fb | 410 | void __iomem *mmio = sil_scr_addr(link->ap, sc_reg); |
da3dbb17 TH |
411 | |
412 | if (mmio) { | |
1da177e4 | 413 | writel(val, mmio); |
da3dbb17 TH |
414 | return 0; |
415 | } | |
416 | return -EINVAL; | |
1da177e4 LT |
417 | } |
418 | ||
cbe88fbc TH |
419 | static void sil_host_intr(struct ata_port *ap, u32 bmdma2) |
420 | { | |
9af5c9c9 TH |
421 | struct ata_eh_info *ehi = &ap->link.eh_info; |
422 | struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag); | |
cbe88fbc TH |
423 | u8 status; |
424 | ||
e573890b | 425 | if (unlikely(bmdma2 & SIL_DMA_SATA_IRQ)) { |
ebd1699e | 426 | u32 serror = 0xffffffff; |
d4c85325 TH |
427 | |
428 | /* SIEN doesn't mask SATA IRQs on some 3112s. Those | |
429 | * controllers continue to assert IRQ as long as | |
430 | * SError bits are pending. Clear SError immediately. | |
431 | */ | |
82ef04fb TH |
432 | sil_scr_read(&ap->link, SCR_ERROR, &serror); |
433 | sil_scr_write(&ap->link, SCR_ERROR, serror); | |
d4c85325 | 434 | |
8cf32ac6 TH |
435 | /* Sometimes spurious interrupts occur, double check |
436 | * it's PHYRDY CHG. | |
d4c85325 | 437 | */ |
8cf32ac6 | 438 | if (serror & SERR_PHYRDY_CHG) { |
f7fe7ad4 | 439 | ap->link.eh_info.serror |= serror; |
8cf32ac6 | 440 | goto freeze; |
d4c85325 TH |
441 | } |
442 | ||
8cf32ac6 TH |
443 | if (!(bmdma2 & SIL_DMA_COMPLETE)) |
444 | return; | |
e573890b TH |
445 | } |
446 | ||
8cf32ac6 | 447 | if (unlikely(!qc || (qc->tf.flags & ATA_TFLAG_POLLING))) { |
e2f8fb72 | 448 | /* this sometimes happens, just clear IRQ */ |
5682ed33 | 449 | ap->ops->sff_check_status(ap); |
e2f8fb72 TH |
450 | return; |
451 | } | |
452 | ||
cbe88fbc TH |
453 | /* Check whether we are expecting interrupt in this state */ |
454 | switch (ap->hsm_task_state) { | |
455 | case HSM_ST_FIRST: | |
456 | /* Some pre-ATAPI-4 devices assert INTRQ | |
457 | * at this state when ready to receive CDB. | |
458 | */ | |
459 | ||
460 | /* Check the ATA_DFLAG_CDB_INTR flag is enough here. | |
405e66b3 TH |
461 | * The flag was turned on only for atapi devices. No |
462 | * need to check ata_is_atapi(qc->tf.protocol) again. | |
cbe88fbc TH |
463 | */ |
464 | if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) | |
465 | goto err_hsm; | |
466 | break; | |
467 | case HSM_ST_LAST: | |
405e66b3 | 468 | if (ata_is_dma(qc->tf.protocol)) { |
cbe88fbc TH |
469 | /* clear DMA-Start bit */ |
470 | ap->ops->bmdma_stop(qc); | |
471 | ||
472 | if (bmdma2 & SIL_DMA_ERROR) { | |
473 | qc->err_mask |= AC_ERR_HOST_BUS; | |
474 | ap->hsm_task_state = HSM_ST_ERR; | |
475 | } | |
476 | } | |
477 | break; | |
478 | case HSM_ST: | |
479 | break; | |
480 | default: | |
481 | goto err_hsm; | |
482 | } | |
483 | ||
484 | /* check main status, clearing INTRQ */ | |
5682ed33 | 485 | status = ap->ops->sff_check_status(ap); |
cbe88fbc TH |
486 | if (unlikely(status & ATA_BUSY)) |
487 | goto err_hsm; | |
488 | ||
489 | /* ack bmdma irq events */ | |
37f65b8b | 490 | ata_bmdma_irq_clear(ap); |
cbe88fbc TH |
491 | |
492 | /* kick HSM in the ass */ | |
9363c382 | 493 | ata_sff_hsm_move(ap, qc, status, 0); |
cbe88fbc | 494 | |
405e66b3 | 495 | if (unlikely(qc->err_mask) && ata_is_dma(qc->tf.protocol)) |
ea54763f TH |
496 | ata_ehi_push_desc(ehi, "BMDMA2 stat 0x%x", bmdma2); |
497 | ||
cbe88fbc TH |
498 | return; |
499 | ||
500 | err_hsm: | |
501 | qc->err_mask |= AC_ERR_HSM; | |
502 | freeze: | |
503 | ata_port_freeze(ap); | |
504 | } | |
505 | ||
7d12e780 | 506 | static irqreturn_t sil_interrupt(int irq, void *dev_instance) |
cbe88fbc | 507 | { |
cca3974e | 508 | struct ata_host *host = dev_instance; |
0d5ff566 | 509 | void __iomem *mmio_base = host->iomap[SIL_MMIO_BAR]; |
cbe88fbc TH |
510 | int handled = 0; |
511 | int i; | |
512 | ||
cca3974e | 513 | spin_lock(&host->lock); |
cbe88fbc | 514 | |
cca3974e JG |
515 | for (i = 0; i < host->n_ports; i++) { |
516 | struct ata_port *ap = host->ports[i]; | |
cbe88fbc TH |
517 | u32 bmdma2 = readl(mmio_base + sil_port[ap->port_no].bmdma2); |
518 | ||
201ce859 TH |
519 | /* turn off SATA_IRQ if not supported */ |
520 | if (ap->flags & SIL_FLAG_NO_SATA_IRQ) | |
521 | bmdma2 &= ~SIL_DMA_SATA_IRQ; | |
522 | ||
23fa9618 TH |
523 | if (bmdma2 == 0xffffffff || |
524 | !(bmdma2 & (SIL_DMA_COMPLETE | SIL_DMA_SATA_IRQ))) | |
cbe88fbc TH |
525 | continue; |
526 | ||
527 | sil_host_intr(ap, bmdma2); | |
528 | handled = 1; | |
529 | } | |
530 | ||
cca3974e | 531 | spin_unlock(&host->lock); |
cbe88fbc TH |
532 | |
533 | return IRQ_RETVAL(handled); | |
534 | } | |
535 | ||
f6aae27e TH |
536 | static void sil_freeze(struct ata_port *ap) |
537 | { | |
0d5ff566 | 538 | void __iomem *mmio_base = ap->host->iomap[SIL_MMIO_BAR]; |
f6aae27e TH |
539 | u32 tmp; |
540 | ||
e573890b TH |
541 | /* global IRQ mask doesn't block SATA IRQ, turn off explicitly */ |
542 | writel(0, mmio_base + sil_port[ap->port_no].sien); | |
543 | ||
f6aae27e TH |
544 | /* plug IRQ */ |
545 | tmp = readl(mmio_base + SIL_SYSCFG); | |
546 | tmp |= SIL_MASK_IDE0_INT << ap->port_no; | |
547 | writel(tmp, mmio_base + SIL_SYSCFG); | |
548 | readl(mmio_base + SIL_SYSCFG); /* flush */ | |
2fc37adb JG |
549 | |
550 | /* Ensure DMA_ENABLE is off. | |
551 | * | |
552 | * This is because the controller will not give us access to the | |
553 | * taskfile registers while a DMA is in progress | |
554 | */ | |
555 | iowrite8(ioread8(ap->ioaddr.bmdma_addr) & ~SIL_DMA_ENABLE, | |
556 | ap->ioaddr.bmdma_addr); | |
557 | ||
558 | /* According to ata_bmdma_stop, an HDMA transition requires | |
559 | * on PIO cycle. But we can't read a taskfile register. | |
560 | */ | |
561 | ioread8(ap->ioaddr.bmdma_addr); | |
f6aae27e TH |
562 | } |
563 | ||
564 | static void sil_thaw(struct ata_port *ap) | |
565 | { | |
0d5ff566 | 566 | void __iomem *mmio_base = ap->host->iomap[SIL_MMIO_BAR]; |
f6aae27e TH |
567 | u32 tmp; |
568 | ||
569 | /* clear IRQ */ | |
5682ed33 | 570 | ap->ops->sff_check_status(ap); |
37f65b8b | 571 | ata_bmdma_irq_clear(ap); |
f6aae27e | 572 | |
201ce859 TH |
573 | /* turn on SATA IRQ if supported */ |
574 | if (!(ap->flags & SIL_FLAG_NO_SATA_IRQ)) | |
575 | writel(SIL_SIEN_N, mmio_base + sil_port[ap->port_no].sien); | |
e573890b | 576 | |
f6aae27e TH |
577 | /* turn on IRQ */ |
578 | tmp = readl(mmio_base + SIL_SYSCFG); | |
579 | tmp &= ~(SIL_MASK_IDE0_INT << ap->port_no); | |
580 | writel(tmp, mmio_base + SIL_SYSCFG); | |
581 | } | |
582 | ||
1da177e4 LT |
583 | /** |
584 | * sil_dev_config - Apply device/host-specific errata fixups | |
1da177e4 LT |
585 | * @dev: Device to be examined |
586 | * | |
587 | * After the IDENTIFY [PACKET] DEVICE step is complete, and a | |
588 | * device is known to be present, this function is called. | |
589 | * We apply two errata fixups which are specific to Silicon Image, | |
590 | * a Seagate and a Maxtor fixup. | |
591 | * | |
592 | * For certain Seagate devices, we must limit the maximum sectors | |
593 | * to under 8K. | |
594 | * | |
595 | * For certain Maxtor devices, we must not program the drive | |
596 | * beyond udma5. | |
597 | * | |
598 | * Both fixups are unfairly pessimistic. As soon as I get more | |
599 | * information on these errata, I will create a more exhaustive | |
600 | * list, and apply the fixups to only the specific | |
601 | * devices/hosts/firmwares that need it. | |
602 | * | |
603 | * 20040111 - Seagate drives affected by the Mod15Write bug are blacklisted | |
604 | * The Maxtor quirk is in the blacklist, but I'm keeping the original | |
605 | * pessimistic fix for the following reasons... | |
606 | * - There seems to be less info on it, only one device gleaned off the | |
607 | * Windows driver, maybe only one is affected. More info would be greatly | |
608 | * appreciated. | |
609 | * - But then again UDMA5 is hardly anything to complain about | |
610 | */ | |
cd0d3bbc | 611 | static void sil_dev_config(struct ata_device *dev) |
1da177e4 | 612 | { |
9af5c9c9 TH |
613 | struct ata_port *ap = dev->link->ap; |
614 | int print_info = ap->link.eh_context.i.flags & ATA_EHI_PRINTINFO; | |
1da177e4 | 615 | unsigned int n, quirks = 0; |
a0cf733b | 616 | unsigned char model_num[ATA_ID_PROD_LEN + 1]; |
1da177e4 | 617 | |
d98f1cd0 MP |
618 | /* This controller doesn't support trim */ |
619 | dev->horkage |= ATA_HORKAGE_NOTRIM; | |
620 | ||
a0cf733b | 621 | ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num)); |
1da177e4 | 622 | |
8a60a071 | 623 | for (n = 0; sil_blacklist[n].product; n++) |
2e02671d | 624 | if (!strcmp(sil_blacklist[n].product, model_num)) { |
1da177e4 LT |
625 | quirks = sil_blacklist[n].quirk; |
626 | break; | |
627 | } | |
8a60a071 | 628 | |
1da177e4 | 629 | /* limit requests to 15 sectors */ |
51e9f2ff JG |
630 | if (slow_down || |
631 | ((ap->flags & SIL_FLAG_MOD15WRITE) && | |
632 | (quirks & SIL_QUIRK_MOD15WRITE))) { | |
efdaedc4 | 633 | if (print_info) |
a9a79dfe JP |
634 | ata_dev_info(dev, |
635 | "applying Seagate errata fix (mod15write workaround)\n"); | |
b00eec1d | 636 | dev->max_sectors = 15; |
1da177e4 LT |
637 | return; |
638 | } | |
639 | ||
640 | /* limit to udma5 */ | |
641 | if (quirks & SIL_QUIRK_UDMA5MAX) { | |
efdaedc4 | 642 | if (print_info) |
a9a79dfe JP |
643 | ata_dev_info(dev, "applying Maxtor errata fix %s\n", |
644 | model_num); | |
5a529139 | 645 | dev->udma_mask &= ATA_UDMA5; |
1da177e4 LT |
646 | return; |
647 | } | |
648 | } | |
649 | ||
4447d351 | 650 | static void sil_init_controller(struct ata_host *host) |
3d8ec913 | 651 | { |
4447d351 TH |
652 | struct pci_dev *pdev = to_pci_dev(host->dev); |
653 | void __iomem *mmio_base = host->iomap[SIL_MMIO_BAR]; | |
3d8ec913 TH |
654 | u8 cls; |
655 | u32 tmp; | |
656 | int i; | |
657 | ||
658 | /* Initialize FIFO PCI bus arbitration */ | |
659 | cls = sil_get_device_cache_line(pdev); | |
660 | if (cls) { | |
661 | cls >>= 3; | |
662 | cls++; /* cls = (line_size/8)+1 */ | |
4447d351 | 663 | for (i = 0; i < host->n_ports; i++) |
3d8ec913 TH |
664 | writew(cls << 8 | cls, |
665 | mmio_base + sil_port[i].fifo_cfg); | |
666 | } else | |
a44fec1f JP |
667 | dev_warn(&pdev->dev, |
668 | "cache line size not set. Driver may not function\n"); | |
3d8ec913 TH |
669 | |
670 | /* Apply R_ERR on DMA activate FIS errata workaround */ | |
4447d351 | 671 | if (host->ports[0]->flags & SIL_FLAG_RERR_ON_DMA_ACT) { |
3d8ec913 TH |
672 | int cnt; |
673 | ||
4447d351 | 674 | for (i = 0, cnt = 0; i < host->n_ports; i++) { |
3d8ec913 TH |
675 | tmp = readl(mmio_base + sil_port[i].sfis_cfg); |
676 | if ((tmp & 0x3) != 0x01) | |
677 | continue; | |
678 | if (!cnt) | |
a44fec1f JP |
679 | dev_info(&pdev->dev, |
680 | "Applying R_ERR on DMA activate FIS errata fix\n"); | |
3d8ec913 TH |
681 | writel(tmp & ~0x3, mmio_base + sil_port[i].sfis_cfg); |
682 | cnt++; | |
683 | } | |
684 | } | |
685 | ||
4447d351 | 686 | if (host->n_ports == 4) { |
3d8ec913 TH |
687 | /* flip the magic "make 4 ports work" bit */ |
688 | tmp = readl(mmio_base + sil_port[2].bmdma); | |
689 | if ((tmp & SIL_INTR_STEERING) == 0) | |
690 | writel(tmp | SIL_INTR_STEERING, | |
691 | mmio_base + sil_port[2].bmdma); | |
692 | } | |
693 | } | |
694 | ||
e57db7bd RW |
695 | static bool sil_broken_system_poweroff(struct pci_dev *pdev) |
696 | { | |
697 | static const struct dmi_system_id broken_systems[] = { | |
698 | { | |
699 | .ident = "HP Compaq nx6325", | |
700 | .matches = { | |
701 | DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), | |
702 | DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6325"), | |
703 | }, | |
704 | /* PCI slot number of the controller */ | |
705 | .driver_data = (void *)0x12UL, | |
706 | }, | |
707 | ||
708 | { } /* terminate list */ | |
709 | }; | |
710 | const struct dmi_system_id *dmi = dmi_first_match(broken_systems); | |
711 | ||
712 | if (dmi) { | |
713 | unsigned long slot = (unsigned long)dmi->driver_data; | |
714 | /* apply the quirk only to on-board controllers */ | |
715 | return slot == PCI_SLOT(pdev->devfn); | |
716 | } | |
717 | ||
718 | return false; | |
719 | } | |
720 | ||
5796d1c4 | 721 | static int sil_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) |
1da177e4 | 722 | { |
4447d351 | 723 | int board_id = ent->driver_data; |
e57db7bd RW |
724 | struct ata_port_info pi = sil_port_info[board_id]; |
725 | const struct ata_port_info *ppi[] = { &pi, NULL }; | |
4447d351 | 726 | struct ata_host *host; |
ea6ba10b | 727 | void __iomem *mmio_base; |
4447d351 | 728 | int n_ports, rc; |
1da177e4 | 729 | unsigned int i; |
1da177e4 | 730 | |
06296a1e | 731 | ata_print_version_once(&pdev->dev, DRV_VERSION); |
1da177e4 | 732 | |
4447d351 TH |
733 | /* allocate host */ |
734 | n_ports = 2; | |
735 | if (board_id == sil_3114) | |
736 | n_ports = 4; | |
737 | ||
e57db7bd RW |
738 | if (sil_broken_system_poweroff(pdev)) { |
739 | pi.flags |= ATA_FLAG_NO_POWEROFF_SPINDOWN | | |
740 | ATA_FLAG_NO_HIBERNATE_SPINDOWN; | |
741 | dev_info(&pdev->dev, "quirky BIOS, skipping spindown " | |
742 | "on poweroff and hibernation\n"); | |
743 | } | |
744 | ||
4447d351 TH |
745 | host = ata_host_alloc_pinfo(&pdev->dev, ppi, n_ports); |
746 | if (!host) | |
747 | return -ENOMEM; | |
748 | ||
749 | /* acquire resources and fill host */ | |
24dc5f33 | 750 | rc = pcim_enable_device(pdev); |
1da177e4 LT |
751 | if (rc) |
752 | return rc; | |
753 | ||
0d5ff566 TH |
754 | rc = pcim_iomap_regions(pdev, 1 << SIL_MMIO_BAR, DRV_NAME); |
755 | if (rc == -EBUSY) | |
24dc5f33 | 756 | pcim_pin_device(pdev); |
0d5ff566 | 757 | if (rc) |
24dc5f33 | 758 | return rc; |
4447d351 | 759 | host->iomap = pcim_iomap_table(pdev); |
1da177e4 | 760 | |
b5e55556 | 761 | rc = dma_set_mask_and_coherent(&pdev->dev, ATA_DMA_MASK); |
1da177e4 | 762 | if (rc) |
24dc5f33 | 763 | return rc; |
1da177e4 | 764 | |
4447d351 | 765 | mmio_base = host->iomap[SIL_MMIO_BAR]; |
1da177e4 | 766 | |
4447d351 | 767 | for (i = 0; i < host->n_ports; i++) { |
cbcdd875 TH |
768 | struct ata_port *ap = host->ports[i]; |
769 | struct ata_ioports *ioaddr = &ap->ioaddr; | |
4447d351 TH |
770 | |
771 | ioaddr->cmd_addr = mmio_base + sil_port[i].tf; | |
772 | ioaddr->altstatus_addr = | |
773 | ioaddr->ctl_addr = mmio_base + sil_port[i].ctl; | |
774 | ioaddr->bmdma_addr = mmio_base + sil_port[i].bmdma; | |
775 | ioaddr->scr_addr = mmio_base + sil_port[i].scr; | |
9363c382 | 776 | ata_sff_std_ports(ioaddr); |
cbcdd875 TH |
777 | |
778 | ata_port_pbar_desc(ap, SIL_MMIO_BAR, -1, "mmio"); | |
779 | ata_port_pbar_desc(ap, SIL_MMIO_BAR, sil_port[i].tf, "tf"); | |
1da177e4 LT |
780 | } |
781 | ||
4447d351 TH |
782 | /* initialize and activate */ |
783 | sil_init_controller(host); | |
1da177e4 | 784 | |
1da177e4 | 785 | pci_set_master(pdev); |
4447d351 TH |
786 | return ata_host_activate(host, pdev->irq, sil_interrupt, IRQF_SHARED, |
787 | &sil_sht); | |
1da177e4 LT |
788 | } |
789 | ||
58eb8cd5 | 790 | #ifdef CONFIG_PM_SLEEP |
afb5a7cb TH |
791 | static int sil_pci_device_resume(struct pci_dev *pdev) |
792 | { | |
0a86e1c8 | 793 | struct ata_host *host = pci_get_drvdata(pdev); |
553c4aa6 TH |
794 | int rc; |
795 | ||
796 | rc = ata_pci_device_do_resume(pdev); | |
797 | if (rc) | |
798 | return rc; | |
afb5a7cb | 799 | |
4447d351 | 800 | sil_init_controller(host); |
cca3974e | 801 | ata_host_resume(host); |
afb5a7cb TH |
802 | |
803 | return 0; | |
804 | } | |
281d426c | 805 | #endif |
afb5a7cb | 806 | |
2fc75da0 | 807 | module_pci_driver(sil_pci_driver); |