blob: 3e4b993807097a302b0521460770f91ae51dda6e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 2001-2002 Andre Hedrick <andre@linux-ide.org>
3 * Copyright (C) 2003 Red Hat <alan@redhat.com>
Sergei Shtylyov075cb652007-02-17 02:40:22 +01004 * Copyright (C) 2007 MontaVista Software, Inc.
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +02005 * Copyright (C) 2007 Bartlomiej Zolnierkiewicz
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * May be copied or modified under the terms of the GNU General Public License
8 *
Jeff Garzikbf4c7962005-11-18 22:55:47 +01009 * Documentation for CMD680:
10 * http://gkernel.sourceforge.net/specs/sii/sii-0680a-v1.31.pdf.bz2
11 *
12 * Documentation for SiI 3112:
13 * http://gkernel.sourceforge.net/specs/sii/3112A_SiI-DS-0095-B2.pdf.bz2
14 *
15 * Errata and other documentation only available under NDA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 *
17 *
18 * FAQ Items:
19 * If you are using Marvell SATA-IDE adapters with Maxtor drives
20 * ensure the system is set up for ATA100/UDMA5 not UDMA6.
21 *
22 * If you are using WD drives with SATA bridges you must set the
23 * drive to "Single". "Master" will hang
24 *
25 * If you have strange problems with nVidia chipset systems please
26 * see the SI support documentation and update your system BIOS
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +020027 * if necessary
Alan Cox8693d3e2007-03-03 17:48:54 +010028 *
29 * The Dell DRAC4 has some interesting features including effectively hot
30 * unplugging/replugging the virtual CD interface when the DRAC is reset.
31 * This often causes drivers/ide/siimage to panic but is ok with the rather
32 * smarter code in libata.
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +020033 *
34 * TODO:
35 * - IORDY fixes
36 * - VDMA support
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 */
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/types.h>
40#include <linux/module.h>
41#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/hdreg.h>
43#include <linux/ide.h>
44#include <linux/init.h>
45
46#include <asm/io.h>
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048/**
49 * pdev_is_sata - check if device is SATA
50 * @pdev: PCI device to check
51 *
52 * Returns true if this is a SATA controller
53 */
54
55static int pdev_is_sata(struct pci_dev *pdev)
56{
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +020057#ifdef CONFIG_BLK_DEV_IDE_SATA
58 switch(pdev->device) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 case PCI_DEVICE_ID_SII_3112:
60 case PCI_DEVICE_ID_SII_1210SA:
61 return 1;
62 case PCI_DEVICE_ID_SII_680:
63 return 0;
64 }
65 BUG();
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +020066#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 return 0;
68}
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +020069
Linus Torvalds1da177e2005-04-16 15:20:36 -070070/**
71 * is_sata - check if hwif is SATA
72 * @hwif: interface to check
73 *
74 * Returns true if this is a SATA controller
75 */
76
77static inline int is_sata(ide_hwif_t *hwif)
78{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +010079 return pdev_is_sata(to_pci_dev(hwif->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -070080}
81
82/**
83 * siimage_selreg - return register base
84 * @hwif: interface
85 * @r: config offset
86 *
87 * Turn a config register offset into the right address in either
88 * PCI space or MMIO space to access the control register in question
89 * Thankfully this is a configuration operation so isnt performance
90 * criticial.
91 */
92
93static unsigned long siimage_selreg(ide_hwif_t *hwif, int r)
94{
95 unsigned long base = (unsigned long)hwif->hwif_data;
96 base += 0xA0 + r;
97 if(hwif->mmio)
98 base += (hwif->channel << 6);
99 else
100 base += (hwif->channel << 4);
101 return base;
102}
103
104/**
105 * siimage_seldev - return register base
106 * @hwif: interface
107 * @r: config offset
108 *
109 * Turn a config register offset into the right address in either
110 * PCI space or MMIO space to access the control register in question
111 * including accounting for the unit shift.
112 */
113
114static inline unsigned long siimage_seldev(ide_drive_t *drive, int r)
115{
116 ide_hwif_t *hwif = HWIF(drive);
117 unsigned long base = (unsigned long)hwif->hwif_data;
118 base += 0xA0 + r;
119 if(hwif->mmio)
120 base += (hwif->channel << 6);
121 else
122 base += (hwif->channel << 4);
123 base |= drive->select.b.unit << drive->select.b.unit;
124 return base;
125}
126
127/**
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200128 * sil_udma_filter - compute UDMA mask
129 * @drive: IDE device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 *
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200131 * Compute the available UDMA speeds for the device on the interface.
132 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 * For the CMD680 this depends on the clocking mode (scsc), for the
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200134 * SI3112 SATA controller life is a bit simpler.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 */
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200136
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200137static u8 sil_pata_udma_filter(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200139 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100140 struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 unsigned long base = (unsigned long) hwif->hwif_data;
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200142 u8 mask = 0, scsc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144 if (hwif->mmio)
145 scsc = hwif->INB(base + 0x4A);
146 else
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100147 pci_read_config_byte(dev, 0x8A, &scsc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 if ((scsc & 0x30) == 0x10) /* 133 */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200150 mask = ATA_UDMA6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 else if ((scsc & 0x30) == 0x20) /* 2xPCI */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200152 mask = ATA_UDMA6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 else if ((scsc & 0x30) == 0x00) /* 100 */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200154 mask = ATA_UDMA5;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 else /* Disabled ? */
156 BUG();
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200157
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200158 return mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159}
160
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200161static u8 sil_sata_udma_filter(ide_drive_t *drive)
162{
163 return strstr(drive->id->model, "Maxtor") ? ATA_UDMA5 : ATA_UDMA6;
164}
165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166/**
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200167 * sil_set_pio_mode - set host controller for PIO mode
168 * @drive: drive
169 * @pio: PIO mode number
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 *
171 * Load the timing settings for this device mode into the
172 * controller. If we are in PIO mode 3 or 4 turn on IORDY
173 * monitoring (bit 9). The TF timing is bits 31:16
174 */
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200175
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200176static void sil_set_pio_mode(ide_drive_t *drive, u8 pio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200178 const u16 tf_speed[] = { 0x328a, 0x2283, 0x1281, 0x10c3, 0x10c1 };
179 const u16 data_speed[] = { 0x328a, 0x2283, 0x1104, 0x10c3, 0x10c1 };
180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 ide_hwif_t *hwif = HWIF(drive);
Benjamin Herrenschmidta87a87c2007-10-19 00:30:05 +0200182 ide_drive_t *pair = ide_get_paired_drive(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 u32 speedt = 0;
184 u16 speedp = 0;
185 unsigned long addr = siimage_seldev(drive, 0x04);
186 unsigned long tfaddr = siimage_selreg(hwif, 0x02);
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200187 unsigned long base = (unsigned long)hwif->hwif_data;
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200188 u8 tf_pio = pio;
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200189 u8 addr_mask = hwif->channel ? (hwif->mmio ? 0xF4 : 0x84)
190 : (hwif->mmio ? 0xB4 : 0x80);
191 u8 mode = 0;
192 u8 unit = drive->select.b.unit;
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200193
194 /* trim *taskfile* PIO to the slowest of the master/slave */
195 if (pair->present) {
Bartlomiej Zolnierkiewicz21347582007-07-20 01:11:58 +0200196 u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4);
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200197
198 if (pair_pio < tf_pio)
199 tf_pio = pair_pio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 }
Sergei Shtylyov075cb652007-02-17 02:40:22 +0100201
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200202 /* cheat for now and use the docs */
203 speedp = data_speed[pio];
204 speedt = tf_speed[tf_pio];
205
Sergei Shtylyov075cb652007-02-17 02:40:22 +0100206 if (hwif->mmio) {
207 hwif->OUTW(speedp, addr);
208 hwif->OUTW(speedt, tfaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 /* Now set up IORDY */
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200210 if (pio > 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 hwif->OUTW(hwif->INW(tfaddr-2)|0x200, tfaddr-2);
212 else
213 hwif->OUTW(hwif->INW(tfaddr-2)&~0x200, tfaddr-2);
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200214
215 mode = hwif->INB(base + addr_mask);
216 mode &= ~(unit ? 0x30 : 0x03);
217 mode |= (unit ? 0x10 : 0x01);
218 hwif->OUTB(mode, base + addr_mask);
Sergei Shtylyov075cb652007-02-17 02:40:22 +0100219 } else {
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100220 struct pci_dev *dev = to_pci_dev(hwif->dev);
221
222 pci_write_config_word(dev, addr, speedp);
223 pci_write_config_word(dev, tfaddr, speedt);
224 pci_read_config_word(dev, tfaddr - 2, &speedp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 speedp &= ~0x200;
226 /* Set IORDY for mode 3 or 4 */
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200227 if (pio > 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 speedp |= 0x200;
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100229 pci_write_config_word(dev, tfaddr - 2, speedp);
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200230
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100231 pci_read_config_byte(dev, addr_mask, &mode);
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200232 mode &= ~(unit ? 0x30 : 0x03);
233 mode |= (unit ? 0x10 : 0x01);
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100234 pci_write_config_byte(dev, addr_mask, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 }
236}
237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238/**
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200239 * sil_set_dma_mode - set host controller for DMA mode
240 * @drive: drive
241 * @speed: DMA mode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 *
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200243 * Tune the SiI chipset for the desired DMA mode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 */
Bartlomiej Zolnierkiewiczf212ff22007-10-11 23:53:59 +0200245
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200246static void sil_set_dma_mode(ide_drive_t *drive, const u8 speed)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
248 u8 ultra6[] = { 0x0F, 0x0B, 0x07, 0x05, 0x03, 0x02, 0x01 };
249 u8 ultra5[] = { 0x0C, 0x07, 0x05, 0x04, 0x02, 0x01 };
250 u16 dma[] = { 0x2208, 0x10C2, 0x10C1 };
251
252 ide_hwif_t *hwif = HWIF(drive);
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100253 struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 u16 ultra = 0, multi = 0;
255 u8 mode = 0, unit = drive->select.b.unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 unsigned long base = (unsigned long)hwif->hwif_data;
257 u8 scsc = 0, addr_mask = ((hwif->channel) ?
258 ((hwif->mmio) ? 0xF4 : 0x84) :
259 ((hwif->mmio) ? 0xB4 : 0x80));
260
261 unsigned long ma = siimage_seldev(drive, 0x08);
262 unsigned long ua = siimage_seldev(drive, 0x0C);
263
264 if (hwif->mmio) {
265 scsc = hwif->INB(base + 0x4A);
266 mode = hwif->INB(base + addr_mask);
267 multi = hwif->INW(ma);
268 ultra = hwif->INW(ua);
269 } else {
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100270 pci_read_config_byte(dev, 0x8A, &scsc);
271 pci_read_config_byte(dev, addr_mask, &mode);
272 pci_read_config_word(dev, ma, &multi);
273 pci_read_config_word(dev, ua, &ultra);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 }
275
276 mode &= ~((unit) ? 0x30 : 0x03);
277 ultra &= ~0x3F;
278 scsc = ((scsc & 0x30) == 0x00) ? 0 : 1;
279
280 scsc = is_sata(hwif) ? 1 : scsc;
281
Bartlomiej Zolnierkiewicz4db90a12008-01-25 22:17:18 +0100282 if (speed >= XFER_UDMA_0) {
283 multi = dma[2];
284 ultra |= (scsc ? ultra6[speed - XFER_UDMA_0] :
285 ultra5[speed - XFER_UDMA_0]);
286 mode |= (unit ? 0x30 : 0x03);
287 } else {
288 multi = dma[speed - XFER_MW_DMA_0];
289 mode |= (unit ? 0x20 : 0x02);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 }
291
292 if (hwif->mmio) {
293 hwif->OUTB(mode, base + addr_mask);
294 hwif->OUTW(multi, ma);
295 hwif->OUTW(ultra, ua);
296 } else {
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100297 pci_write_config_byte(dev, addr_mask, mode);
298 pci_write_config_word(dev, ma, multi);
299 pci_write_config_word(dev, ua, ultra);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301}
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303/* returns 1 if dma irq issued, 0 otherwise */
304static int siimage_io_ide_dma_test_irq (ide_drive_t *drive)
305{
306 ide_hwif_t *hwif = HWIF(drive);
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100307 struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 u8 dma_altstat = 0;
309 unsigned long addr = siimage_selreg(hwif, 1);
310
311 /* return 1 if INTR asserted */
312 if ((hwif->INB(hwif->dma_status) & 4) == 4)
313 return 1;
314
315 /* return 1 if Device INTR asserted */
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100316 pci_read_config_byte(dev, addr, &dma_altstat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 if (dma_altstat & 8)
318 return 0; //return 1;
319 return 0;
320}
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322/**
323 * siimage_mmio_ide_dma_test_irq - check we caused an IRQ
324 * @drive: drive we are testing
325 *
326 * Check if we caused an IDE DMA interrupt. We may also have caused
327 * SATA status interrupts, if so we clean them up and continue.
328 */
329
330static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive)
331{
332 ide_hwif_t *hwif = HWIF(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 unsigned long addr = siimage_selreg(hwif, 0x1);
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100334 void __iomem *sata_error_addr
335 = (void __iomem *)hwif->sata_scr[SATA_ERROR_OFFSET];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100337 if (sata_error_addr) {
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200338 unsigned long base = (unsigned long)hwif->hwif_data;
Bartlomiej Zolnierkiewicz0ecdca22007-02-17 02:40:25 +0100339 u32 ext_stat = readl((void __iomem *)(base + 0x10));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 u8 watchdog = 0;
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 if (ext_stat & ((hwif->channel) ? 0x40 : 0x10)) {
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100343 u32 sata_error = readl(sata_error_addr);
344
345 writel(sata_error, sata_error_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 watchdog = (sata_error & 0x00680000) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 printk(KERN_WARNING "%s: sata_error = 0x%08x, "
348 "watchdog = %d, %s\n",
349 drive->name, sata_error, watchdog,
350 __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 } else {
353 watchdog = (ext_stat & 0x8000) ? 1 : 0;
354 }
355 ext_stat >>= 16;
356
357 if (!(ext_stat & 0x0404) && !watchdog)
358 return 0;
359 }
360
361 /* return 1 if INTR asserted */
Bartlomiej Zolnierkiewicz0ecdca22007-02-17 02:40:25 +0100362 if ((readb((void __iomem *)hwif->dma_status) & 0x04) == 0x04)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return 1;
364
365 /* return 1 if Device INTR asserted */
Bartlomiej Zolnierkiewicz0ecdca22007-02-17 02:40:25 +0100366 if ((readb((void __iomem *)addr) & 8) == 8)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 return 0; //return 1;
368
369 return 0;
370}
371
372/**
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200373 * sil_sata_reset_poll - wait for SATA reset
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 * @drive: drive we are resetting
375 *
376 * Poll the SATA phy and see whether it has come back from the dead
377 * yet.
378 */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200379
380static int sil_sata_reset_poll(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100382 ide_hwif_t *hwif = drive->hwif;
383 void __iomem *sata_status_addr
384 = (void __iomem *)hwif->sata_scr[SATA_STATUS_OFFSET];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100386 if (sata_status_addr) {
387 /* SATA Status is available only when in MMIO mode */
388 u32 sata_stat = readl(sata_status_addr);
389
390 if ((sata_stat & 0x03) != 0x03) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 printk(KERN_WARNING "%s: reset phy dead, status=0x%08x\n",
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100392 hwif->name, sata_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 HWGROUP(drive)->polling = 0;
394 return ide_started;
395 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200397
398 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399}
400
401/**
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200402 * sil_sata_pre_reset - reset hook
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 * @drive: IDE device being reset
404 *
405 * For the SATA devices we need to handle recalibration/geometry
406 * differently
407 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200409static void sil_sata_pre_reset(ide_drive_t *drive)
410{
411 if (drive->media == ide_disk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 drive->special.b.set_geometry = 0;
413 drive->special.b.recalibrate = 0;
414 }
415}
416
417/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 * proc_reports_siimage - add siimage controller to proc
419 * @dev: PCI device
420 * @clocking: SCSC value
421 * @name: controller name
422 *
423 * Report the clocking mode of the controller and add it to
424 * the /proc interface layer
425 */
426
427static void proc_reports_siimage (struct pci_dev *dev, u8 clocking, const char *name)
428{
429 if (!pdev_is_sata(dev)) {
430 printk(KERN_INFO "%s: BASE CLOCK ", name);
431 clocking &= 0x03;
432 switch (clocking) {
433 case 0x03: printk("DISABLED!\n"); break;
434 case 0x02: printk("== 2X PCI\n"); break;
435 case 0x01: printk("== 133\n"); break;
436 case 0x00: printk("== 100\n"); break;
437 }
438 }
439}
440
441/**
442 * setup_mmio_siimage - switch an SI controller into MMIO
443 * @dev: PCI device we are configuring
444 * @name: device name
445 *
446 * Attempt to put the device into mmio mode. There are some slight
447 * complications here with certain systems where the mmio bar isnt
448 * mapped so we have to be sure we can fall back to I/O.
449 */
450
451static unsigned int setup_mmio_siimage (struct pci_dev *dev, const char *name)
452{
Sergei Shtylyovc9768162008-04-07 23:30:10 +0200453 resource_size_t bar5 = pci_resource_start(dev, 5);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 unsigned long barsize = pci_resource_len(dev, 5);
455 u8 tmpbyte = 0;
456 void __iomem *ioaddr;
John W. Linvilled868dd12005-11-10 00:19:14 +0100457 u32 tmp, irq_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
459 /*
460 * Drop back to PIO if we can't map the mmio. Some
461 * systems seem to get terminally confused in the PCI
462 * spaces.
463 */
464
465 if(!request_mem_region(bar5, barsize, name))
466 {
467 printk(KERN_WARNING "siimage: IDE controller MMIO ports not available.\n");
468 return 0;
469 }
470
471 ioaddr = ioremap(bar5, barsize);
472
473 if (ioaddr == NULL)
474 {
475 release_mem_region(bar5, barsize);
476 return 0;
477 }
478
479 pci_set_master(dev);
480 pci_set_drvdata(dev, (void *) ioaddr);
481
482 if (pdev_is_sata(dev)) {
John W. Linvilled868dd12005-11-10 00:19:14 +0100483 /* make sure IDE0/1 interrupts are not masked */
484 irq_mask = (1 << 22) | (1 << 23);
485 tmp = readl(ioaddr + 0x48);
486 if (tmp & irq_mask) {
487 tmp &= ~irq_mask;
488 writel(tmp, ioaddr + 0x48);
489 readl(ioaddr + 0x48); /* flush */
490 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 writel(0, ioaddr + 0x148);
492 writel(0, ioaddr + 0x1C8);
493 }
494
495 writeb(0, ioaddr + 0xB4);
496 writeb(0, ioaddr + 0xF4);
497 tmpbyte = readb(ioaddr + 0x4A);
498
499 switch(tmpbyte & 0x30) {
500 case 0x00:
501 /* In 100 MHz clocking, try and switch to 133 */
502 writeb(tmpbyte|0x10, ioaddr + 0x4A);
503 break;
504 case 0x10:
505 /* On 133Mhz clocking */
506 break;
507 case 0x20:
508 /* On PCIx2 clocking */
509 break;
510 case 0x30:
511 /* Clocking is disabled */
512 /* 133 clock attempt to force it on */
513 writeb(tmpbyte & ~0x20, ioaddr + 0x4A);
514 break;
515 }
516
517 writeb( 0x72, ioaddr + 0xA1);
518 writew( 0x328A, ioaddr + 0xA2);
519 writel(0x62DD62DD, ioaddr + 0xA4);
520 writel(0x43924392, ioaddr + 0xA8);
521 writel(0x40094009, ioaddr + 0xAC);
522 writeb( 0x72, ioaddr + 0xE1);
523 writew( 0x328A, ioaddr + 0xE2);
524 writel(0x62DD62DD, ioaddr + 0xE4);
525 writel(0x43924392, ioaddr + 0xE8);
526 writel(0x40094009, ioaddr + 0xEC);
527
528 if (pdev_is_sata(dev)) {
529 writel(0xFFFF0000, ioaddr + 0x108);
530 writel(0xFFFF0000, ioaddr + 0x188);
531 writel(0x00680000, ioaddr + 0x148);
532 writel(0x00680000, ioaddr + 0x1C8);
533 }
534
535 tmpbyte = readb(ioaddr + 0x4A);
536
537 proc_reports_siimage(dev, (tmpbyte>>4), name);
538 return 1;
539}
540
541/**
542 * init_chipset_siimage - set up an SI device
543 * @dev: PCI device
544 * @name: device name
545 *
546 * Perform the initial PCI set up for this device. Attempt to switch
547 * to 133MHz clocking if the system isn't already set up to do it.
548 */
549
550static unsigned int __devinit init_chipset_siimage(struct pci_dev *dev, const char *name)
551{
Bartlomiej Zolnierkiewiczfc212bb2007-10-19 00:30:08 +0200552 u8 rev = dev->revision, tmpbyte = 0, BA5_EN = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Bartlomiej Zolnierkiewiczfc212bb2007-10-19 00:30:08 +0200554 pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, rev ? 1 : 255);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556 pci_read_config_byte(dev, 0x8A, &BA5_EN);
557 if ((BA5_EN & 0x01) || (pci_resource_start(dev, 5))) {
558 if (setup_mmio_siimage(dev, name)) {
559 return 0;
560 }
561 }
562
563 pci_write_config_byte(dev, 0x80, 0x00);
564 pci_write_config_byte(dev, 0x84, 0x00);
565 pci_read_config_byte(dev, 0x8A, &tmpbyte);
566 switch(tmpbyte & 0x30) {
567 case 0x00:
568 /* 133 clock attempt to force it on */
569 pci_write_config_byte(dev, 0x8A, tmpbyte|0x10);
570 case 0x30:
571 /* if clocking is disabled */
572 /* 133 clock attempt to force it on */
573 pci_write_config_byte(dev, 0x8A, tmpbyte & ~0x20);
574 case 0x10:
575 /* 133 already */
576 break;
577 case 0x20:
578 /* BIOS set PCI x2 clocking */
579 break;
580 }
581
582 pci_read_config_byte(dev, 0x8A, &tmpbyte);
583
584 pci_write_config_byte(dev, 0xA1, 0x72);
585 pci_write_config_word(dev, 0xA2, 0x328A);
586 pci_write_config_dword(dev, 0xA4, 0x62DD62DD);
587 pci_write_config_dword(dev, 0xA8, 0x43924392);
588 pci_write_config_dword(dev, 0xAC, 0x40094009);
589 pci_write_config_byte(dev, 0xB1, 0x72);
590 pci_write_config_word(dev, 0xB2, 0x328A);
591 pci_write_config_dword(dev, 0xB4, 0x62DD62DD);
592 pci_write_config_dword(dev, 0xB8, 0x43924392);
593 pci_write_config_dword(dev, 0xBC, 0x40094009);
594
595 proc_reports_siimage(dev, (tmpbyte>>4), name);
596 return 0;
597}
598
599/**
600 * init_mmio_iops_siimage - set up the iops for MMIO
601 * @hwif: interface to set up
602 *
603 * The basic setup here is fairly simple, we can use standard MMIO
604 * operations. However we do have to set the taskfile register offsets
605 * by hand as there isnt a standard defined layout for them this
606 * time.
607 *
608 * The hardware supports buffered taskfiles and also some rather nice
Alan Cox19c1ef52006-06-28 04:26:59 -0700609 * extended PRD tables. For better SI3112 support use the libata driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 */
611
612static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
613{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100614 struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 void *addr = pci_get_drvdata(dev);
616 u8 ch = hwif->channel;
617 hw_regs_t hw;
618 unsigned long base;
619
620 /*
621 * Fill in the basic HWIF bits
622 */
623
624 default_hwif_mmiops(hwif);
625 hwif->hwif_data = addr;
626
627 /*
628 * Now set up the hw. We have to do this ourselves as
Michael Opdenacker59c51592007-05-09 08:57:56 +0200629 * the MMIO layout isnt the same as the standard port
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 * based I/O
631 */
632
633 memset(&hw, 0, sizeof(hw_regs_t));
634
635 base = (unsigned long)addr;
636 if (ch)
637 base += 0xC0;
638 else
639 base += 0x80;
640
641 /*
642 * The buffered task file doesn't have status/control
643 * so we can't currently use it sanely since we want to
644 * use LBA48 mode.
645 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 hw.io_ports[IDE_DATA_OFFSET] = base;
647 hw.io_ports[IDE_ERROR_OFFSET] = base + 1;
648 hw.io_ports[IDE_NSECTOR_OFFSET] = base + 2;
649 hw.io_ports[IDE_SECTOR_OFFSET] = base + 3;
650 hw.io_ports[IDE_LCYL_OFFSET] = base + 4;
651 hw.io_ports[IDE_HCYL_OFFSET] = base + 5;
652 hw.io_ports[IDE_SELECT_OFFSET] = base + 6;
653 hw.io_ports[IDE_STATUS_OFFSET] = base + 7;
654 hw.io_ports[IDE_CONTROL_OFFSET] = base + 10;
655
656 hw.io_ports[IDE_IRQ_OFFSET] = 0;
657
658 if (pdev_is_sata(dev)) {
659 base = (unsigned long)addr;
660 if (ch)
661 base += 0x80;
662 hwif->sata_scr[SATA_STATUS_OFFSET] = base + 0x104;
663 hwif->sata_scr[SATA_ERROR_OFFSET] = base + 0x108;
664 hwif->sata_scr[SATA_CONTROL_OFFSET] = base + 0x100;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 }
666
Bartlomiej Zolnierkiewicz9239b332007-10-20 00:32:33 +0200667 memcpy(hwif->io_ports, hw.io_ports, sizeof(hwif->io_ports));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
Bartlomiej Zolnierkiewicz9239b332007-10-20 00:32:33 +0200669 hwif->irq = dev->irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Bartlomiej Zolnierkiewicz9239b332007-10-20 00:32:33 +0200671 hwif->dma_base = (unsigned long)addr + (ch ? 0x08 : 0x00);
Bartlomiej Zolnierkiewicz2ad1e552007-02-17 02:40:25 +0100672
673 hwif->mmio = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674}
675
676static int is_dev_seagate_sata(ide_drive_t *drive)
677{
678 const char *s = &drive->id->model[0];
679 unsigned len;
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 len = strnlen(s, sizeof(drive->id->model));
682
683 if ((len > 4) && (!memcmp(s, "ST", 2))) {
684 if ((!memcmp(s + len - 2, "AS", 2)) ||
685 (!memcmp(s + len - 3, "ASL", 3))) {
686 printk(KERN_INFO "%s: applying pessimistic Seagate "
687 "errata fix\n", drive->name);
688 return 1;
689 }
690 }
691 return 0;
692}
693
694/**
Bartlomiej Zolnierkiewiczf01393e2008-01-26 20:13:03 +0100695 * sil_quirkproc - post probe fixups
696 * @drive: drive
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 *
698 * Called after drive probe we use this to decide whether the
699 * Seagate fixup must be applied. This used to be in init_iops but
700 * that can occur before we know what drives are present.
701 */
702
Bartlomiej Zolnierkiewiczf01393e2008-01-26 20:13:03 +0100703static void __devinit sil_quirkproc(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704{
Bartlomiej Zolnierkiewiczf01393e2008-01-26 20:13:03 +0100705 ide_hwif_t *hwif = drive->hwif;
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 /* Try and raise the rqsize */
Bartlomiej Zolnierkiewiczf01393e2008-01-26 20:13:03 +0100708 if (!is_sata(hwif) || !is_dev_seagate_sata(drive))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 hwif->rqsize = 128;
710}
711
712/**
713 * init_iops_siimage - set up iops
714 * @hwif: interface to set up
715 *
716 * Do the basic setup for the SIIMAGE hardware interface
717 * and then do the MMIO setup if we can. This is the first
718 * look in we get for setting up the hwif so that we
719 * can get the iops right before using them.
720 */
721
722static void __devinit init_iops_siimage(ide_hwif_t *hwif)
723{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100724 struct pci_dev *dev = to_pci_dev(hwif->dev);
725
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 hwif->hwif_data = NULL;
727
728 /* Pessimal until we finish probing */
729 hwif->rqsize = 15;
730
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100731 if (pci_get_drvdata(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 return;
Bartlomiej Zolnierkiewiczfc212bb2007-10-19 00:30:08 +0200733
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 init_mmio_iops_siimage(hwif);
735}
736
737/**
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200738 * sil_cable_detect - cable detection
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 * @hwif: interface to check
740 *
741 * Check for the presence of an ATA66 capable cable on the
742 * interface.
743 */
744
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200745static u8 __devinit sil_cable_detect(ide_hwif_t *hwif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100747 struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 unsigned long addr = siimage_selreg(hwif, 0);
Bartlomiej Zolnierkiewicz49521f92007-07-09 23:17:58 +0200749 u8 ata66 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100751 if (pci_get_drvdata(dev) == NULL)
752 pci_read_config_byte(dev, addr, &ata66);
Bartlomiej Zolnierkiewicz49521f92007-07-09 23:17:58 +0200753 else
754 ata66 = hwif->INB(addr);
755
756 return (ata66 & 0x01) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757}
758
759/**
760 * init_hwif_siimage - set up hwif structs
761 * @hwif: interface to set up
762 *
763 * We do the basic set up of the interface structure. The SIIMAGE
764 * requires several custom handlers so we override the default
765 * ide DMA handlers appropriately
766 */
767
768static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
769{
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200770 u8 sata = is_sata(hwif);
771
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200772 if (sata) {
Alan Cox19c1ef52006-06-28 04:26:59 -0700773 static int first = 1;
774
Alan Cox19c1ef52006-06-28 04:26:59 -0700775 if (first) {
776 printk(KERN_INFO "siimage: For full SATA support you should use the libata sata_sil module.\n");
777 first = 0;
778 }
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200779 }
Bartlomiej Zolnierkiewiczbfa14b42008-02-02 19:56:31 +0100780
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200781 if (hwif->dma_base == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200784 if (sata)
Bartlomiej Zolnierkiewicz33c10022007-10-19 00:30:06 +0200785 hwif->host_flags |= IDE_HFLAG_NO_ATAPI_DMA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 if (hwif->mmio) {
788 hwif->ide_dma_test_irq = &siimage_mmio_ide_dma_test_irq;
789 } else {
790 hwif->ide_dma_test_irq = & siimage_io_ide_dma_test_irq;
791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792}
793
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200794static const struct ide_port_ops sil_pata_port_ops = {
795 .set_pio_mode = sil_set_pio_mode,
796 .set_dma_mode = sil_set_dma_mode,
797 .quirkproc = sil_quirkproc,
798 .udma_filter = sil_pata_udma_filter,
799 .cable_detect = sil_cable_detect,
800};
801
802static const struct ide_port_ops sil_sata_port_ops = {
803 .set_pio_mode = sil_set_pio_mode,
804 .set_dma_mode = sil_set_dma_mode,
805 .reset_poll = sil_sata_reset_poll,
806 .pre_reset = sil_sata_pre_reset,
807 .quirkproc = sil_quirkproc,
808 .udma_filter = sil_sata_udma_filter,
809 .cable_detect = sil_cable_detect,
810};
811
812#define DECLARE_SII_DEV(name_str, p_ops) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 { \
814 .name = name_str, \
815 .init_chipset = init_chipset_siimage, \
816 .init_iops = init_iops_siimage, \
817 .init_hwif = init_hwif_siimage, \
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200818 .port_ops = p_ops, \
Bartlomiej Zolnierkiewicz4099d142007-07-20 01:11:59 +0200819 .pio_mask = ATA_PIO4, \
Bartlomiej Zolnierkiewicz5f8b6c32007-10-19 00:30:07 +0200820 .mwdma_mask = ATA_MWDMA2, \
821 .udma_mask = ATA_UDMA6, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
823
Bartlomiej Zolnierkiewicz85620432007-10-20 00:32:34 +0200824static const struct ide_port_info siimage_chipsets[] __devinitdata = {
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200825 /* 0 */ DECLARE_SII_DEV("SiI680", &sil_pata_port_ops),
826 /* 1 */ DECLARE_SII_DEV("SiI3112 Serial ATA", &sil_sata_port_ops),
827 /* 2 */ DECLARE_SII_DEV("Adaptec AAR-1210SA", &sil_sata_port_ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828};
829
830/**
831 * siimage_init_one - pci layer discovery entry
832 * @dev: PCI device
833 * @id: ident table entry
834 *
835 * Called by the PCI code when it finds an SI680 or SI3112 controller.
836 * We then use the IDE PCI generic helper to do most of the work.
837 */
838
839static int __devinit siimage_init_one(struct pci_dev *dev, const struct pci_device_id *id)
840{
841 return ide_setup_pci_device(dev, &siimage_chipsets[id->driver_data]);
842}
843
Bartlomiej Zolnierkiewicz9cbcc5e2007-10-16 22:29:56 +0200844static const struct pci_device_id siimage_pci_tbl[] = {
845 { PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_680), 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846#ifdef CONFIG_BLK_DEV_IDE_SATA
Bartlomiej Zolnierkiewicz9cbcc5e2007-10-16 22:29:56 +0200847 { PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_3112), 1 },
848 { PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_1210SA), 2 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849#endif
850 { 0, },
851};
852MODULE_DEVICE_TABLE(pci, siimage_pci_tbl);
853
854static struct pci_driver driver = {
855 .name = "SiI_IDE",
856 .id_table = siimage_pci_tbl,
857 .probe = siimage_init_one,
858};
859
Bartlomiej Zolnierkiewicz82ab1ee2007-01-27 13:46:56 +0100860static int __init siimage_ide_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
862 return ide_pci_register_driver(&driver);
863}
864
865module_init(siimage_ide_init);
866
867MODULE_AUTHOR("Andre Hedrick, Alan Cox");
868MODULE_DESCRIPTION("PCI driver module for SiI IDE");
869MODULE_LICENSE("GPL");