blob: ddeda444a27aebdcfda34a20bb04742d288656d2 [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>
Alan Coxccd32e22008-11-02 21:40:08 +01003 * Copyright (C) 2003 Red Hat
Sergei Shtylyov7b255432008-04-28 23:44:44 +02004 * Copyright (C) 2007-2008 MontaVista Software, Inc.
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +02005 * Copyright (C) 2007-2008 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
Sergei Shtylyov7b255432008-04-28 23:44:44 +020020 * ensure the system is set up for ATA100/UDMA5, not UDMA6.
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 *
22 * If you are using WD drives with SATA bridges you must set the
Sergei Shtylyov7b255432008-04-28 23:44:44 +020023 * drive to "Single". "Master" will hang.
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 *
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:
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +020035 * - VDMA support
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 */
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/types.h>
39#include <linux/module.h>
40#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/ide.h>
42#include <linux/init.h>
Sergei Shtylyov7b255432008-04-28 23:44:44 +020043#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Bartlomiej Zolnierkiewiczced3ec82008-07-24 22:53:32 +020045#define DRV_NAME "siimage"
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047/**
48 * pdev_is_sata - check if device is SATA
49 * @pdev: PCI device to check
Sergei Shtylyov7b255432008-04-28 23:44:44 +020050 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 * Returns true if this is a SATA controller
52 */
Sergei Shtylyov7b255432008-04-28 23:44:44 +020053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054static int pdev_is_sata(struct pci_dev *pdev)
55{
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +020056#ifdef CONFIG_BLK_DEV_IDE_SATA
Sergei Shtylyov7b255432008-04-28 23:44:44 +020057 switch (pdev->device) {
58 case PCI_DEVICE_ID_SII_3112:
59 case PCI_DEVICE_ID_SII_1210SA:
60 return 1;
61 case PCI_DEVICE_ID_SII_680:
62 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 }
64 BUG();
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +020065#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 return 0;
67}
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +020068
Linus Torvalds1da177e2005-04-16 15:20:36 -070069/**
70 * is_sata - check if hwif is SATA
71 * @hwif: interface to check
Sergei Shtylyov7b255432008-04-28 23:44:44 +020072 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 * Returns true if this is a SATA controller
74 */
Sergei Shtylyov7b255432008-04-28 23:44:44 +020075
Linus Torvalds1da177e2005-04-16 15:20:36 -070076static inline int is_sata(ide_hwif_t *hwif)
77{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +010078 return pdev_is_sata(to_pci_dev(hwif->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
80
81/**
82 * siimage_selreg - return register base
83 * @hwif: interface
84 * @r: config offset
85 *
86 * Turn a config register offset into the right address in either
87 * PCI space or MMIO space to access the control register in question
Sergei Shtylyov7b255432008-04-28 23:44:44 +020088 * Thankfully this is a configuration operation, so isn't performance
89 * critical.
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 */
Sergei Shtylyov7b255432008-04-28 23:44:44 +020091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092static unsigned long siimage_selreg(ide_hwif_t *hwif, int r)
93{
94 unsigned long base = (unsigned long)hwif->hwif_data;
Sergei Shtylyov7b255432008-04-28 23:44:44 +020095
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 base += 0xA0 + r;
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +020097 if (hwif->host_flags & IDE_HFLAG_MMIO)
Sergei Shtylyov7b255432008-04-28 23:44:44 +020098 base += hwif->channel << 6;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 else
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200100 base += hwif->channel << 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 return base;
102}
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104/**
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 */
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114static inline unsigned long siimage_seldev(ide_drive_t *drive, int r)
115{
Bartlomiej Zolnierkiewicz898ec222009-01-06 17:20:52 +0100116 ide_hwif_t *hwif = drive->hwif;
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200117 unsigned long base = (unsigned long)hwif->hwif_data;
Bartlomiej Zolnierkiewicz123995b2008-10-13 21:39:40 +0200118 u8 unit = drive->dn & 1;
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 base += 0xA0 + r;
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +0200121 if (hwif->host_flags & IDE_HFLAG_MMIO)
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200122 base += hwif->channel << 6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 else
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200124 base += hwif->channel << 4;
Bartlomiej Zolnierkiewicz123995b2008-10-13 21:39:40 +0200125 base |= unit << unit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 return base;
127}
128
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200129static u8 sil_ioread8(struct pci_dev *dev, unsigned long addr)
130{
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200131 struct ide_host *host = pci_get_drvdata(dev);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200132 u8 tmp = 0;
133
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200134 if (host->host_priv)
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200135 tmp = readb((void __iomem *)addr);
136 else
137 pci_read_config_byte(dev, addr, &tmp);
138
139 return tmp;
140}
141
142static u16 sil_ioread16(struct pci_dev *dev, unsigned long addr)
143{
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200144 struct ide_host *host = pci_get_drvdata(dev);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200145 u16 tmp = 0;
146
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200147 if (host->host_priv)
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200148 tmp = readw((void __iomem *)addr);
149 else
150 pci_read_config_word(dev, addr, &tmp);
151
152 return tmp;
153}
154
155static void sil_iowrite8(struct pci_dev *dev, u8 val, unsigned long addr)
156{
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200157 struct ide_host *host = pci_get_drvdata(dev);
158
159 if (host->host_priv)
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200160 writeb(val, (void __iomem *)addr);
161 else
162 pci_write_config_byte(dev, addr, val);
163}
164
165static void sil_iowrite16(struct pci_dev *dev, u16 val, unsigned long addr)
166{
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200167 struct ide_host *host = pci_get_drvdata(dev);
168
169 if (host->host_priv)
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200170 writew(val, (void __iomem *)addr);
171 else
172 pci_write_config_word(dev, addr, val);
173}
174
175static void sil_iowrite32(struct pci_dev *dev, u32 val, unsigned long addr)
176{
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200177 struct ide_host *host = pci_get_drvdata(dev);
178
179 if (host->host_priv)
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200180 writel(val, (void __iomem *)addr);
181 else
182 pci_write_config_dword(dev, addr, val);
183}
184
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185/**
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200186 * sil_udma_filter - compute UDMA mask
187 * @drive: IDE device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 *
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200189 * Compute the available UDMA speeds for the device on the interface.
190 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 * For the CMD680 this depends on the clocking mode (scsc), for the
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200192 * SI3112 SATA controller life is a bit simpler.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 */
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200194
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200195static u8 sil_pata_udma_filter(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200197 ide_hwif_t *hwif = drive->hwif;
198 struct pci_dev *dev = to_pci_dev(hwif->dev);
199 unsigned long base = (unsigned long)hwif->hwif_data;
200 u8 scsc, mask = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +0200202 base += (hwif->host_flags & IDE_HFLAG_MMIO) ? 0x4A : 0x8A;
203
204 scsc = sil_ioread8(dev, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200206 switch (scsc & 0x30) {
207 case 0x10: /* 133 */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200208 mask = ATA_UDMA6;
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200209 break;
210 case 0x20: /* 2xPCI */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200211 mask = ATA_UDMA6;
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200212 break;
213 case 0x00: /* 100 */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200214 mask = ATA_UDMA5;
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200215 break;
216 default: /* Disabled ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 BUG();
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200218 }
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200219
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200220 return mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200223static u8 sil_sata_udma_filter(ide_drive_t *drive)
224{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200225 char *m = (char *)&drive->id[ATA_ID_PROD];
226
227 return strstr(m, "Maxtor") ? ATA_UDMA5 : ATA_UDMA6;
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200228}
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230/**
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200231 * sil_set_pio_mode - set host controller for PIO mode
Bartlomiej Zolnierkiewicze085b3c2010-01-19 01:44:41 -0800232 * @hwif: port
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200233 * @drive: drive
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 *
235 * Load the timing settings for this device mode into the
Bartlomiej Zolnierkiewiczc9ef59f2009-06-15 18:52:53 +0200236 * controller.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 */
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200238
Bartlomiej Zolnierkiewicze085b3c2010-01-19 01:44:41 -0800239static void sil_set_pio_mode(ide_hwif_t *hwif, ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200241 static const u16 tf_speed[] = { 0x328a, 0x2283, 0x1281, 0x10c3, 0x10c1 };
242 static const u16 data_speed[] = { 0x328a, 0x2283, 0x1104, 0x10c3, 0x10c1 };
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200243
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200244 struct pci_dev *dev = to_pci_dev(hwif->dev);
Bartlomiej Zolnierkiewicz7e59ea22008-10-10 22:39:26 +0200245 ide_drive_t *pair = ide_get_pair_dev(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 u32 speedt = 0;
247 u16 speedp = 0;
248 unsigned long addr = siimage_seldev(drive, 0x04);
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200249 unsigned long tfaddr = siimage_selreg(hwif, 0x02);
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200250 unsigned long base = (unsigned long)hwif->hwif_data;
Bartlomiej Zolnierkiewicze085b3c2010-01-19 01:44:41 -0800251 const u8 pio = drive->pio_mode - XFER_PIO_0;
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200252 u8 tf_pio = pio;
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +0200253 u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
254 u8 addr_mask = hwif->channel ? (mmio ? 0xF4 : 0x84)
255 : (mmio ? 0xB4 : 0x80);
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200256 u8 mode = 0;
Bartlomiej Zolnierkiewicz123995b2008-10-13 21:39:40 +0200257 u8 unit = drive->dn & 1;
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200258
259 /* trim *taskfile* PIO to the slowest of the master/slave */
Bartlomiej Zolnierkiewicz7e59ea22008-10-10 22:39:26 +0200260 if (pair) {
Bartlomiej Zolnierkiewiczbb430612010-01-18 07:22:16 +0000261 u8 pair_pio = pair->pio_mode - XFER_PIO_0;
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200262
263 if (pair_pio < tf_pio)
264 tf_pio = pair_pio;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 }
Sergei Shtylyov075cb652007-02-17 02:40:22 +0100266
Bartlomiej Zolnierkiewicz328dcbb2007-07-20 01:11:54 +0200267 /* cheat for now and use the docs */
268 speedp = data_speed[pio];
269 speedt = tf_speed[tf_pio];
270
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200271 sil_iowrite16(dev, speedp, addr);
272 sil_iowrite16(dev, speedt, tfaddr);
Bartlomiej Zolnierkiewiczffe54152007-10-11 23:54:01 +0200273
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200274 /* now set up IORDY */
275 speedp = sil_ioread16(dev, tfaddr - 2);
276 speedp &= ~0x200;
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100277
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200278 mode = sil_ioread8(dev, base + addr_mask);
279 mode &= ~(unit ? 0x30 : 0x03);
Bartlomiej Zolnierkiewiczc9ef59f2009-06-15 18:52:53 +0200280
281 if (ide_pio_need_iordy(drive, pio)) {
282 speedp |= 0x200;
283 mode |= unit ? 0x10 : 0x01;
284 }
285
286 sil_iowrite16(dev, speedp, tfaddr - 2);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200287 sil_iowrite8(dev, mode, base + addr_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288}
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290/**
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200291 * sil_set_dma_mode - set host controller for DMA mode
Bartlomiej Zolnierkiewicz87761682010-01-19 01:45:29 -0800292 * @hwif: port
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200293 * @drive: drive
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 *
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200295 * Tune the SiI chipset for the desired DMA mode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 */
Bartlomiej Zolnierkiewiczf212ff22007-10-11 23:53:59 +0200297
Bartlomiej Zolnierkiewicz87761682010-01-19 01:45:29 -0800298static void sil_set_dma_mode(ide_hwif_t *hwif, ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299{
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200300 static const u8 ultra6[] = { 0x0F, 0x0B, 0x07, 0x05, 0x03, 0x02, 0x01 };
301 static const u8 ultra5[] = { 0x0C, 0x07, 0x05, 0x04, 0x02, 0x01 };
302 static const u16 dma[] = { 0x2208, 0x10C2, 0x10C1 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100304 struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 unsigned long base = (unsigned long)hwif->hwif_data;
Bartlomiej Zolnierkiewicz123995b2008-10-13 21:39:40 +0200306 u16 ultra = 0, multi = 0;
307 u8 mode = 0, unit = drive->dn & 1;
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +0200308 u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
309 u8 scsc = 0, addr_mask = hwif->channel ? (mmio ? 0xF4 : 0x84)
310 : (mmio ? 0xB4 : 0x80);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 unsigned long ma = siimage_seldev(drive, 0x08);
312 unsigned long ua = siimage_seldev(drive, 0x0C);
Bartlomiej Zolnierkiewicz87761682010-01-19 01:45:29 -0800313 const u8 speed = drive->dma_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +0200315 scsc = sil_ioread8 (dev, base + (mmio ? 0x4A : 0x8A));
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200316 mode = sil_ioread8 (dev, base + addr_mask);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200317 multi = sil_ioread16(dev, ma);
318 ultra = sil_ioread16(dev, ua);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200320 mode &= ~(unit ? 0x30 : 0x03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 ultra &= ~0x3F;
322 scsc = ((scsc & 0x30) == 0x00) ? 0 : 1;
323
324 scsc = is_sata(hwif) ? 1 : scsc;
325
Bartlomiej Zolnierkiewicz4db90a12008-01-25 22:17:18 +0100326 if (speed >= XFER_UDMA_0) {
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200327 multi = dma[2];
328 ultra |= scsc ? ultra6[speed - XFER_UDMA_0] :
329 ultra5[speed - XFER_UDMA_0];
330 mode |= unit ? 0x30 : 0x03;
Bartlomiej Zolnierkiewicz4db90a12008-01-25 22:17:18 +0100331 } else {
332 multi = dma[speed - XFER_MW_DMA_0];
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200333 mode |= unit ? 0x20 : 0x02;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 }
335
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200336 sil_iowrite8 (dev, mode, base + addr_mask);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200337 sil_iowrite16(dev, multi, ma);
338 sil_iowrite16(dev, ultra, ua);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339}
340
Sergei Shtylyovec053e42009-06-15 18:53:00 +0200341static int sil_test_irq(ide_hwif_t *hwif)
342{
343 struct pci_dev *dev = to_pci_dev(hwif->dev);
344 unsigned long addr = siimage_selreg(hwif, 1);
345 u8 val = sil_ioread8(dev, addr);
346
347 /* Return 1 if INTRQ asserted */
348 return (val & 8) ? 1 : 0;
349}
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351/**
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200352 * siimage_mmio_dma_test_irq - check we caused an IRQ
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 * @drive: drive we are testing
354 *
355 * Check if we caused an IDE DMA interrupt. We may also have caused
356 * SATA status interrupts, if so we clean them up and continue.
357 */
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200358
359static int siimage_mmio_dma_test_irq(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
Bartlomiej Zolnierkiewicz898ec222009-01-06 17:20:52 +0100361 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100362 void __iomem *sata_error_addr
363 = (void __iomem *)hwif->sata_scr[SATA_ERROR_OFFSET];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100365 if (sata_error_addr) {
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200366 unsigned long base = (unsigned long)hwif->hwif_data;
367 u32 ext_stat = readl((void __iomem *)(base + 0x10));
368 u8 watchdog = 0;
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 if (ext_stat & ((hwif->channel) ? 0x40 : 0x10)) {
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100371 u32 sata_error = readl(sata_error_addr);
372
373 writel(sata_error, sata_error_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 watchdog = (sata_error & 0x00680000) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 printk(KERN_WARNING "%s: sata_error = 0x%08x, "
376 "watchdog = %d, %s\n",
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200377 drive->name, sata_error, watchdog, __func__);
378 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 watchdog = (ext_stat & 0x8000) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200381 ext_stat >>= 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 if (!(ext_stat & 0x0404) && !watchdog)
383 return 0;
384 }
385
386 /* return 1 if INTR asserted */
Bartlomiej Zolnierkiewiczcab7f8e2008-07-23 19:55:51 +0200387 if (readb((void __iomem *)(hwif->dma_base + ATA_DMA_STATUS)) & 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return 1;
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 return 0;
391}
392
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200393static int siimage_dma_test_irq(ide_drive_t *drive)
394{
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +0200395 if (drive->hwif->host_flags & IDE_HFLAG_MMIO)
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200396 return siimage_mmio_dma_test_irq(drive);
397 else
Sergei Shtylyov74414a92009-06-15 18:52:57 +0200398 return ide_dma_test_irq(drive);
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200399}
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401/**
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200402 * sil_sata_reset_poll - wait for SATA reset
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 * @drive: drive we are resetting
404 *
405 * Poll the SATA phy and see whether it has come back from the dead
406 * yet.
407 */
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200408
409static int sil_sata_reset_poll(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100411 ide_hwif_t *hwif = drive->hwif;
412 void __iomem *sata_status_addr
413 = (void __iomem *)hwif->sata_scr[SATA_STATUS_OFFSET];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100415 if (sata_status_addr) {
416 /* SATA Status is available only when in MMIO mode */
417 u32 sata_stat = readl(sata_status_addr);
418
419 if ((sata_stat & 0x03) != 0x03) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 printk(KERN_WARNING "%s: reset phy dead, status=0x%08x\n",
Bartlomiej Zolnierkiewicz835457d2008-02-02 19:56:45 +0100421 hwif->name, sata_stat);
Elias Oltmanns64a8f002008-07-16 20:33:48 +0200422 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200425
426 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427}
428
429/**
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200430 * sil_sata_pre_reset - reset hook
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 * @drive: IDE device being reset
432 *
433 * For the SATA devices we need to handle recalibration/geometry
434 * differently
435 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Bartlomiej Zolnierkiewicz438c4702007-10-20 00:32:31 +0200437static void sil_sata_pre_reset(ide_drive_t *drive)
438{
439 if (drive->media == ide_disk) {
Bartlomiej Zolnierkiewiczca1b96e2009-05-17 19:12:21 +0200440 drive->special_flags &=
441 ~(IDE_SFLAG_SET_GEOMETRY | IDE_SFLAG_RECALIBRATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 }
443}
444
445/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 * init_chipset_siimage - set up an SI device
447 * @dev: PCI device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 *
449 * Perform the initial PCI set up for this device. Attempt to switch
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200450 * to 133 MHz clocking if the system isn't already set up to do it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 */
452
Bartlomiej Zolnierkiewicz2ed0ef52009-03-24 23:22:53 +0100453static int init_chipset_siimage(struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454{
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200455 struct ide_host *host = pci_get_drvdata(dev);
456 void __iomem *ioaddr = host->host_priv;
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200457 unsigned long base, scsc_addr;
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200458 u8 rev = dev->revision, tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Bartlomiej Zolnierkiewiczfc212bb2007-10-19 00:30:08 +0200460 pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, rev ? 1 : 255);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200462 if (ioaddr)
463 pci_set_master(dev);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200464
465 base = (unsigned long)ioaddr;
466
467 if (ioaddr && pdev_is_sata(dev)) {
468 u32 tmp32, irq_mask;
469
470 /* make sure IDE0/1 interrupts are not masked */
471 irq_mask = (1 << 22) | (1 << 23);
472 tmp32 = readl(ioaddr + 0x48);
473 if (tmp32 & irq_mask) {
474 tmp32 &= ~irq_mask;
475 writel(tmp32, ioaddr + 0x48);
476 readl(ioaddr + 0x48); /* flush */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200478 writel(0, ioaddr + 0x148);
479 writel(0, ioaddr + 0x1C8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 }
481
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200482 sil_iowrite8(dev, 0, base ? (base + 0xB4) : 0x80);
483 sil_iowrite8(dev, 0, base ? (base + 0xF4) : 0x84);
484
485 scsc_addr = base ? (base + 0x4A) : 0x8A;
486 tmp = sil_ioread8(dev, scsc_addr);
487
488 switch (tmp & 0x30) {
489 case 0x00:
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200490 /* On 100 MHz clocking, try and switch to 133 MHz */
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200491 sil_iowrite8(dev, tmp | 0x10, scsc_addr);
492 break;
493 case 0x30:
494 /* Clocking is disabled, attempt to force 133MHz clocking. */
495 sil_iowrite8(dev, tmp & ~0x20, scsc_addr);
496 case 0x10:
497 /* On 133Mhz clocking. */
498 break;
499 case 0x20:
500 /* On PCIx2 clocking. */
501 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 }
503
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200504 tmp = sil_ioread8(dev, scsc_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200506 sil_iowrite8 (dev, 0x72, base + 0xA1);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200507 sil_iowrite16(dev, 0x328A, base + 0xA2);
508 sil_iowrite32(dev, 0x62DD62DD, base + 0xA4);
509 sil_iowrite32(dev, 0x43924392, base + 0xA8);
510 sil_iowrite32(dev, 0x40094009, base + 0xAC);
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200511 sil_iowrite8 (dev, 0x72, base ? (base + 0xE1) : 0xB1);
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200512 sil_iowrite16(dev, 0x328A, base ? (base + 0xE2) : 0xB2);
513 sil_iowrite32(dev, 0x62DD62DD, base ? (base + 0xE4) : 0xB4);
514 sil_iowrite32(dev, 0x43924392, base ? (base + 0xE8) : 0xB8);
515 sil_iowrite32(dev, 0x40094009, base ? (base + 0xEC) : 0xBC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200517 if (base && pdev_is_sata(dev)) {
518 writel(0xFFFF0000, ioaddr + 0x108);
519 writel(0xFFFF0000, ioaddr + 0x188);
520 writel(0x00680000, ioaddr + 0x148);
521 writel(0x00680000, ioaddr + 0x1C8);
522 }
523
Bartlomiej Zolnierkiewicz24cc4342008-04-28 23:44:38 +0200524 /* report the clocking mode of the controller */
525 if (!pdev_is_sata(dev)) {
526 static const char *clk_str[] =
527 { "== 100", "== 133", "== 2X PCI", "DISABLED!" };
528
529 tmp >>= 4;
Bartlomiej Zolnierkiewicza326b022008-07-24 22:53:33 +0200530 printk(KERN_INFO DRV_NAME " %s: BASE CLOCK %s\n",
531 pci_name(dev), clk_str[tmp & 3]);
Bartlomiej Zolnierkiewicz24cc4342008-04-28 23:44:38 +0200532 }
Bartlomiej Zolnierkiewicz165701d2008-04-28 23:44:38 +0200533
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 return 0;
535}
536
537/**
538 * init_mmio_iops_siimage - set up the iops for MMIO
539 * @hwif: interface to set up
540 *
541 * The basic setup here is fairly simple, we can use standard MMIO
542 * operations. However we do have to set the taskfile register offsets
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200543 * by hand as there isn't a standard defined layout for them this time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 *
545 * The hardware supports buffered taskfiles and also some rather nice
Alan Cox19c1ef52006-06-28 04:26:59 -0700546 * extended PRD tables. For better SI3112 support use the libata driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 */
548
549static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
550{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100551 struct pci_dev *dev = to_pci_dev(hwif->dev);
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200552 struct ide_host *host = pci_get_drvdata(dev);
553 void *addr = host->host_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 u8 ch = hwif->channel;
Bartlomiej Zolnierkiewicz4c3032d2008-04-27 15:38:32 +0200555 struct ide_io_ports *io_ports = &hwif->io_ports;
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200556 unsigned long base;
Bartlomiej Zolnierkiewicz4c3032d2008-04-27 15:38:32 +0200557
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 /*
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200559 * Fill in the basic hwif bits
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 */
Bartlomiej Zolnierkiewiczc5dd43e2008-04-28 23:44:37 +0200561 hwif->host_flags |= IDE_HFLAG_MMIO;
Bartlomiej Zolnierkiewicz761052e2008-07-23 19:55:54 +0200562
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200563 hwif->hwif_data = addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565 /*
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200566 * Now set up the hw. We have to do this ourselves as the
567 * MMIO layout isn't the same as the standard port based I/O.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 */
Bartlomiej Zolnierkiewicz4c3032d2008-04-27 15:38:32 +0200569 memset(io_ports, 0, sizeof(*io_ports));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 base = (unsigned long)addr;
572 if (ch)
573 base += 0xC0;
574 else
575 base += 0x80;
576
577 /*
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200578 * The buffered task file doesn't have status/control, so we
579 * can't currently use it sanely since we want to use LBA48 mode.
580 */
Bartlomiej Zolnierkiewicz4c3032d2008-04-27 15:38:32 +0200581 io_ports->data_addr = base;
582 io_ports->error_addr = base + 1;
583 io_ports->nsect_addr = base + 2;
584 io_ports->lbal_addr = base + 3;
585 io_ports->lbam_addr = base + 4;
586 io_ports->lbah_addr = base + 5;
587 io_ports->device_addr = base + 6;
588 io_ports->status_addr = base + 7;
589 io_ports->ctl_addr = base + 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 if (pdev_is_sata(dev)) {
592 base = (unsigned long)addr;
593 if (ch)
594 base += 0x80;
595 hwif->sata_scr[SATA_STATUS_OFFSET] = base + 0x104;
596 hwif->sata_scr[SATA_ERROR_OFFSET] = base + 0x108;
597 hwif->sata_scr[SATA_CONTROL_OFFSET] = base + 0x100;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 }
599
Bartlomiej Zolnierkiewicz9239b332007-10-20 00:32:33 +0200600 hwif->irq = dev->irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Bartlomiej Zolnierkiewicz9239b332007-10-20 00:32:33 +0200602 hwif->dma_base = (unsigned long)addr + (ch ? 0x08 : 0x00);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603}
604
605static int is_dev_seagate_sata(ide_drive_t *drive)
606{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200607 const char *s = (const char *)&drive->id[ATA_ID_PROD];
608 unsigned len = strnlen(s, ATA_ID_PROD_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200610 if ((len > 4) && (!memcmp(s, "ST", 2)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if ((!memcmp(s + len - 2, "AS", 2)) ||
612 (!memcmp(s + len - 3, "ASL", 3))) {
613 printk(KERN_INFO "%s: applying pessimistic Seagate "
614 "errata fix\n", drive->name);
615 return 1;
616 }
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 return 0;
619}
620
621/**
Bartlomiej Zolnierkiewiczf01393e2008-01-26 20:13:03 +0100622 * sil_quirkproc - post probe fixups
623 * @drive: drive
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 *
625 * Called after drive probe we use this to decide whether the
626 * Seagate fixup must be applied. This used to be in init_iops but
627 * that can occur before we know what drives are present.
628 */
629
Bartlomiej Zolnierkiewicz36de9942008-08-05 18:17:03 +0200630static void sil_quirkproc(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
Bartlomiej Zolnierkiewiczf01393e2008-01-26 20:13:03 +0100632 ide_hwif_t *hwif = drive->hwif;
633
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200634 /* Try and rise the rqsize */
Bartlomiej Zolnierkiewiczf01393e2008-01-26 20:13:03 +0100635 if (!is_sata(hwif) || !is_dev_seagate_sata(drive))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 hwif->rqsize = 128;
637}
638
639/**
640 * init_iops_siimage - set up iops
641 * @hwif: interface to set up
642 *
643 * Do the basic setup for the SIIMAGE hardware interface
644 * and then do the MMIO setup if we can. This is the first
645 * look in we get for setting up the hwif so that we
646 * can get the iops right before using them.
647 */
648
649static void __devinit init_iops_siimage(ide_hwif_t *hwif)
650{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100651 struct pci_dev *dev = to_pci_dev(hwif->dev);
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200652 struct ide_host *host = pci_get_drvdata(dev);
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 hwif->hwif_data = NULL;
655
656 /* Pessimal until we finish probing */
657 hwif->rqsize = 15;
658
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200659 if (host->host_priv)
660 init_mmio_iops_siimage(hwif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661}
662
663/**
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200664 * sil_cable_detect - cable detection
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 * @hwif: interface to check
666 *
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200667 * Check for the presence of an ATA66 capable cable on the interface.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 */
669
Bartlomiej Zolnierkiewiczf454cbe2008-08-05 18:17:04 +0200670static u8 sil_cable_detect(ide_hwif_t *hwif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200672 struct pci_dev *dev = to_pci_dev(hwif->dev);
673 unsigned long addr = siimage_selreg(hwif, 0);
674 u8 ata66 = sil_ioread8(dev, addr);
Bartlomiej Zolnierkiewicz49521f92007-07-09 23:17:58 +0200675
676 return (ata66 & 0x01) ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677}
678
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200679static const struct ide_port_ops sil_pata_port_ops = {
680 .set_pio_mode = sil_set_pio_mode,
681 .set_dma_mode = sil_set_dma_mode,
682 .quirkproc = sil_quirkproc,
Sergei Shtylyovec053e42009-06-15 18:53:00 +0200683 .test_irq = sil_test_irq,
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200684 .udma_filter = sil_pata_udma_filter,
685 .cable_detect = sil_cable_detect,
686};
687
688static const struct ide_port_ops sil_sata_port_ops = {
689 .set_pio_mode = sil_set_pio_mode,
690 .set_dma_mode = sil_set_dma_mode,
691 .reset_poll = sil_sata_reset_poll,
692 .pre_reset = sil_sata_pre_reset,
693 .quirkproc = sil_quirkproc,
Sergei Shtylyovec053e42009-06-15 18:53:00 +0200694 .test_irq = sil_test_irq,
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200695 .udma_filter = sil_sata_udma_filter,
696 .cable_detect = sil_cable_detect,
697};
698
Benjamin Herrenschmidtb26b0c52008-04-29 22:57:37 +0200699static const struct ide_dma_ops sil_dma_ops = {
700 .dma_host_set = ide_dma_host_set,
701 .dma_setup = ide_dma_setup,
Benjamin Herrenschmidtb26b0c52008-04-29 22:57:37 +0200702 .dma_start = ide_dma_start,
Bartlomiej Zolnierkiewicz653bcf52008-10-13 21:39:46 +0200703 .dma_end = ide_dma_end,
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200704 .dma_test_irq = siimage_dma_test_irq,
Bartlomiej Zolnierkiewicz22117d62009-03-27 12:46:47 +0100705 .dma_timer_expiry = ide_dma_sff_timer_expiry,
Benjamin Herrenschmidtb26b0c52008-04-29 22:57:37 +0200706 .dma_lost_irq = ide_dma_lost_irq,
Sergei Shtylyov592b5312009-01-06 17:21:02 +0100707 .dma_sff_read_status = ide_dma_sff_read_status,
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200708};
709
Bartlomiej Zolnierkiewiczced3ec82008-07-24 22:53:32 +0200710#define DECLARE_SII_DEV(p_ops) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 { \
Bartlomiej Zolnierkiewiczced3ec82008-07-24 22:53:32 +0200712 .name = DRV_NAME, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 .init_chipset = init_chipset_siimage, \
714 .init_iops = init_iops_siimage, \
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200715 .port_ops = p_ops, \
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200716 .dma_ops = &sil_dma_ops, \
Bartlomiej Zolnierkiewicz4099d142007-07-20 01:11:59 +0200717 .pio_mask = ATA_PIO4, \
Bartlomiej Zolnierkiewicz5f8b6c32007-10-19 00:30:07 +0200718 .mwdma_mask = ATA_MWDMA2, \
719 .udma_mask = ATA_UDMA6, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 }
721
Bartlomiej Zolnierkiewicz85620432007-10-20 00:32:34 +0200722static const struct ide_port_info siimage_chipsets[] __devinitdata = {
Bartlomiej Zolnierkiewiczced3ec82008-07-24 22:53:32 +0200723 /* 0: SiI680 */ DECLARE_SII_DEV(&sil_pata_port_ops),
724 /* 1: SiI3112 */ DECLARE_SII_DEV(&sil_sata_port_ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725};
726
727/**
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200728 * siimage_init_one - PCI layer discovery entry
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 * @dev: PCI device
730 * @id: ident table entry
731 *
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200732 * Called by the PCI code when it finds an SiI680 or SiI3112 controller.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 * We then use the IDE PCI generic helper to do most of the work.
734 */
Sergei Shtylyov7b255432008-04-28 23:44:44 +0200735
736static int __devinit siimage_init_one(struct pci_dev *dev,
737 const struct pci_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200739 void __iomem *ioaddr = NULL;
740 resource_size_t bar5 = pci_resource_start(dev, 5);
741 unsigned long barsize = pci_resource_len(dev, 5);
742 int rc;
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200743 struct ide_port_info d;
744 u8 idx = id->driver_data;
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200745 u8 BA5_EN;
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200746
747 d = siimage_chipsets[idx];
748
749 if (idx) {
750 static int first = 1;
751
752 if (first) {
Bartlomiej Zolnierkiewiczced3ec82008-07-24 22:53:32 +0200753 printk(KERN_INFO DRV_NAME ": For full SATA support you "
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200754 "should use the libata sata_sil module.\n");
755 first = 0;
756 }
757
758 d.host_flags |= IDE_HFLAG_NO_ATAPI_DMA;
759 }
760
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200761 rc = pci_enable_device(dev);
762 if (rc)
763 return rc;
764
765 pci_read_config_byte(dev, 0x8A, &BA5_EN);
766 if ((BA5_EN & 0x01) || bar5) {
767 /*
768 * Drop back to PIO if we can't map the MMIO. Some systems
769 * seem to get terminally confused in the PCI spaces.
770 */
771 if (!request_mem_region(bar5, barsize, d.name)) {
Bartlomiej Zolnierkiewiczced3ec82008-07-24 22:53:32 +0200772 printk(KERN_WARNING DRV_NAME " %s: MMIO ports not "
Bartlomiej Zolnierkiewicz28cfd8a2008-07-24 22:53:31 +0200773 "available\n", pci_name(dev));
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200774 } else {
Arjan van de Ven1f1ab272008-10-23 23:22:07 +0200775 ioaddr = pci_ioremap_bar(dev, 5);
Bartlomiej Zolnierkiewicz4c674232008-07-24 22:53:16 +0200776 if (ioaddr == NULL)
777 release_mem_region(bar5, barsize);
778 }
779 }
780
781 rc = ide_pci_init_one(dev, &d, ioaddr);
782 if (rc) {
783 if (ioaddr) {
784 iounmap(ioaddr);
785 release_mem_region(bar5, barsize);
786 }
787 pci_disable_device(dev);
788 }
789
790 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791}
792
Bartlomiej Zolnierkiewiczfe382582008-07-24 22:53:25 +0200793static void __devexit siimage_remove(struct pci_dev *dev)
794{
795 struct ide_host *host = pci_get_drvdata(dev);
796 void __iomem *ioaddr = host->host_priv;
797
798 ide_pci_remove(dev);
799
800 if (ioaddr) {
801 resource_size_t bar5 = pci_resource_start(dev, 5);
802 unsigned long barsize = pci_resource_len(dev, 5);
803
804 iounmap(ioaddr);
805 release_mem_region(bar5, barsize);
806 }
807
808 pci_disable_device(dev);
809}
810
Bartlomiej Zolnierkiewicz9cbcc5e2007-10-16 22:29:56 +0200811static const struct pci_device_id siimage_pci_tbl[] = {
812 { PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_680), 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813#ifdef CONFIG_BLK_DEV_IDE_SATA
Bartlomiej Zolnierkiewicz9cbcc5e2007-10-16 22:29:56 +0200814 { PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_3112), 1 },
Bartlomiej Zolnierkiewiczced3ec82008-07-24 22:53:32 +0200815 { PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_1210SA), 1 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816#endif
817 { 0, },
818};
819MODULE_DEVICE_TABLE(pci, siimage_pci_tbl);
820
Bartlomiej Zolnierkiewicza9ab09e2008-10-13 21:39:41 +0200821static struct pci_driver siimage_pci_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 .name = "SiI_IDE",
823 .id_table = siimage_pci_tbl,
824 .probe = siimage_init_one,
Adrian Bunka69999e2008-08-18 21:40:03 +0200825 .remove = __devexit_p(siimage_remove),
Bartlomiej Zolnierkiewiczfeb22b72008-10-10 22:39:32 +0200826 .suspend = ide_pci_suspend,
827 .resume = ide_pci_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828};
829
Bartlomiej Zolnierkiewicz82ab1ee2007-01-27 13:46:56 +0100830static int __init siimage_ide_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831{
Bartlomiej Zolnierkiewicza9ab09e2008-10-13 21:39:41 +0200832 return ide_pci_register_driver(&siimage_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833}
834
Bartlomiej Zolnierkiewiczfe382582008-07-24 22:53:25 +0200835static void __exit siimage_ide_exit(void)
836{
Bartlomiej Zolnierkiewicza9ab09e2008-10-13 21:39:41 +0200837 pci_unregister_driver(&siimage_pci_driver);
Bartlomiej Zolnierkiewiczfe382582008-07-24 22:53:25 +0200838}
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840module_init(siimage_ide_init);
Bartlomiej Zolnierkiewiczfe382582008-07-24 22:53:25 +0200841module_exit(siimage_ide_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
843MODULE_AUTHOR("Andre Hedrick, Alan Cox");
844MODULE_DESCRIPTION("PCI driver module for SiI IDE");
845MODULE_LICENSE("GPL");