blob: eb99dbe78081087a79f8e3d578b494b29f9dfa76 [file] [log] [blame]
Jeff Garzik669a5db2006-08-29 18:12:40 -04001/*
2 * pata_ali.c - ALI 15x3 PATA for new ATA layer
3 * (C) 2005 Red Hat Inc
Jeff Garzik669a5db2006-08-29 18:12:40 -04004 *
5 * based in part upon
6 * linux/drivers/ide/pci/alim15x3.c Version 0.17 2003/01/02
7 *
8 * Copyright (C) 1998-2000 Michel Aubry, Maintainer
9 * Copyright (C) 1998-2000 Andrzej Krzysztofowicz, Maintainer
10 * Copyright (C) 1999-2000 CJ, cjtsai@ali.com.tw, Maintainer
11 *
12 * Copyright (C) 1998-2000 Andre Hedrick (andre@linux-ide.org)
13 * May be copied or modified under the terms of the GNU General Public License
14 * Copyright (C) 2002 Alan Cox <alan@redhat.com>
15 * ALi (now ULi M5228) support by Clear Zhang <Clear.Zhang@ali.com.tw>
16 *
17 * Documentation
18 * Chipset documentation available under NDA only
19 *
20 * TODO/CHECK
21 * Cannot have ATAPI on both master & slave for rev < c2 (???) but
Alan Cox1b2c3572009-01-05 14:13:22 +000022 * otherwise should do atapi DMA (For now for old we do PIO only for
23 * ATAPI)
24 * Review Sunblade workaround.
Jeff Garzik669a5db2006-08-29 18:12:40 -040025 */
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/pci.h>
30#include <linux/init.h>
31#include <linux/blkdev.h>
32#include <linux/delay.h>
33#include <scsi/scsi_host.h>
34#include <linux/libata.h>
35#include <linux/dmi.h>
36
37#define DRV_NAME "pata_ali"
Alan Coxfc809022009-01-05 14:13:53 +000038#define DRV_VERSION "0.7.8"
Jeff Garzik669a5db2006-08-29 18:12:40 -040039
Adrian Bunk18922252008-04-11 20:28:27 +030040static int ali_atapi_dma = 0;
Tejun Heo8243e632008-04-03 14:40:55 +090041module_param_named(atapi_dma, ali_atapi_dma, int, 0644);
42MODULE_PARM_DESC(atapi_dma, "Enable ATAPI DMA (0=disable, 1=enable)");
43
Andrew Mortonbc42b242009-01-14 16:48:42 -080044static struct pci_dev *ali_isa_bridge;
Alan Cox1b2c3572009-01-05 14:13:22 +000045
Jeff Garzik669a5db2006-08-29 18:12:40 -040046/*
47 * Cable special cases
48 */
49
Jeff Garzik18552562007-10-03 15:15:40 -040050static const struct dmi_system_id cable_dmi_table[] = {
Jeff Garzik669a5db2006-08-29 18:12:40 -040051 {
52 .ident = "HP Pavilion N5430",
53 .matches = {
54 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Alan Cox5c8d5202007-07-20 15:34:49 +010055 DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
Jeff Garzik669a5db2006-08-29 18:12:40 -040056 },
57 },
Daniel Exner03e6f482007-09-11 22:28:36 +020058 {
59 .ident = "Toshiba Satelite S1800-814",
60 .matches = {
61 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
62 DMI_MATCH(DMI_PRODUCT_NAME, "S1800-814"),
63 },
64 },
Jeff Garzik669a5db2006-08-29 18:12:40 -040065 { }
66};
67
68static int ali_cable_override(struct pci_dev *pdev)
69{
70 /* Fujitsu P2000 */
71 if (pdev->subsystem_vendor == 0x10CF && pdev->subsystem_device == 0x10AF)
72 return 1;
Alan Cox8f59a132007-11-19 14:36:28 +000073 /* Mitac 8317 (Winbook-A) and relatives */
Jeff Garzik11b7bec2007-11-23 21:12:14 -050074 if (pdev->subsystem_vendor == 0x1071 && pdev->subsystem_device == 0x8317)
Alan Cox8f59a132007-11-19 14:36:28 +000075 return 1;
Jeff Garzik669a5db2006-08-29 18:12:40 -040076 /* Systems by DMI */
77 if (dmi_check_system(cable_dmi_table))
78 return 1;
79 return 0;
80}
81
82/**
83 * ali_c2_cable_detect - cable detection
84 * @ap: ATA port
85 *
86 * Perform cable detection for C2 and later revisions
87 */
88
89static int ali_c2_cable_detect(struct ata_port *ap)
90{
91 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
92 u8 ata66;
93
94 /* Certain laptops use short but suitable cables and don't
95 implement the detect logic */
96
97 if (ali_cable_override(pdev))
Alan Coxfc085152006-10-10 14:28:11 -070098 return ATA_CBL_PATA40_SHORT;
Jeff Garzik669a5db2006-08-29 18:12:40 -040099
100 /* Host view cable detect 0x4A bit 0 primary bit 1 secondary
101 Bit set for 40 pin */
102 pci_read_config_byte(pdev, 0x4A, &ata66);
103 if (ata66 & (1 << ap->port_no))
104 return ATA_CBL_PATA40;
105 else
106 return ATA_CBL_PATA80;
107}
108
109/**
Jeff Garzik669a5db2006-08-29 18:12:40 -0400110 * ali_20_filter - filter for earlier ALI DMA
111 * @ap: ALi ATA port
112 * @adev: attached device
113 *
114 * Ensure that we do not do DMA on CD devices. We may be able to
115 * fix that later on. Also ensure we do not do UDMA on WDC drives
116 */
117
Alan Coxa76b62c2007-03-09 09:34:07 -0500118static unsigned long ali_20_filter(struct ata_device *adev, unsigned long mask)
Jeff Garzik669a5db2006-08-29 18:12:40 -0400119{
Tejun Heo8bfa79f2007-01-02 20:19:40 +0900120 char model_num[ATA_ID_PROD_LEN + 1];
Jeff Garzik669a5db2006-08-29 18:12:40 -0400121 /* No DMA on anything but a disk for now */
122 if (adev->class != ATA_DEV_ATA)
123 mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
Tejun Heo8bfa79f2007-01-02 20:19:40 +0900124 ata_id_c_string(adev->id, model_num, ATA_ID_PROD, sizeof(model_num));
Jeff Garzik669a5db2006-08-29 18:12:40 -0400125 if (strstr(model_num, "WDC"))
126 return mask &= ~ATA_MASK_UDMA;
Tejun Heo9363c382008-04-07 22:47:16 +0900127 return ata_bmdma_mode_filter(adev, mask);
Jeff Garzik669a5db2006-08-29 18:12:40 -0400128}
129
130/**
131 * ali_fifo_control - FIFO manager
132 * @ap: ALi channel to control
133 * @adev: device for FIFO control
134 * @on: 0 for off 1 for on
135 *
136 * Enable or disable the FIFO on a given device. Because of the way the
137 * ALi FIFO works it provides a boost on ATA disk but can be confused by
138 * ATAPI and we must therefore manage it.
139 */
140
141static void ali_fifo_control(struct ata_port *ap, struct ata_device *adev, int on)
142{
143 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
144 int pio_fifo = 0x54 + ap->port_no;
145 u8 fifo;
146 int shift = 4 * adev->devno;
147
148 /* ATA - FIFO on set nibble to 0x05, ATAPI - FIFO off, set nibble to
149 0x00. Not all the docs agree but the behaviour we now use is the
150 one stated in the BIOS Programming Guide */
Jeff Garzik85cd7252006-08-31 00:03:49 -0400151
Jeff Garzik669a5db2006-08-29 18:12:40 -0400152 pci_read_config_byte(pdev, pio_fifo, &fifo);
153 fifo &= ~(0x0F << shift);
Alan Cox871af122009-01-05 14:16:39 +0000154 fifo |= (on << shift);
Jeff Garzik669a5db2006-08-29 18:12:40 -0400155 pci_write_config_byte(pdev, pio_fifo, fifo);
156}
157
158/**
159 * ali_program_modes - load mode registers
160 * @ap: ALi channel to load
161 * @adev: Device the timing is for
162 * @cmd: Command timing
163 * @data: Data timing
164 * @ultra: UDMA timing or zero for off
165 *
166 * Loads the timing registers for cmd/data and disable UDMA if
167 * ultra is zero. If ultra is set then load and enable the UDMA
168 * timing but do not touch the command/data timing.
169 */
170
171static void ali_program_modes(struct ata_port *ap, struct ata_device *adev, struct ata_timing *t, u8 ultra)
172{
173 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
174 int cas = 0x58 + 4 * ap->port_no; /* Command timing */
175 int cbt = 0x59 + 4 * ap->port_no; /* Command timing */
176 int drwt = 0x5A + 4 * ap->port_no + adev->devno; /* R/W timing */
177 int udmat = 0x56 + ap->port_no; /* UDMA timing */
178 int shift = 4 * adev->devno;
179 u8 udma;
180
181 if (t != NULL) {
Harvey Harrison07633b52008-05-14 16:17:00 -0700182 t->setup = clamp_val(t->setup, 1, 8) & 7;
183 t->act8b = clamp_val(t->act8b, 1, 8) & 7;
184 t->rec8b = clamp_val(t->rec8b, 1, 16) & 15;
185 t->active = clamp_val(t->active, 1, 8) & 7;
186 t->recover = clamp_val(t->recover, 1, 16) & 15;
Jeff Garzik669a5db2006-08-29 18:12:40 -0400187
188 pci_write_config_byte(pdev, cas, t->setup);
189 pci_write_config_byte(pdev, cbt, (t->act8b << 4) | t->rec8b);
190 pci_write_config_byte(pdev, drwt, (t->active << 4) | t->recover);
191 }
192
193 /* Set up the UDMA enable */
194 pci_read_config_byte(pdev, udmat, &udma);
195 udma &= ~(0x0F << shift);
196 udma |= ultra << shift;
197 pci_write_config_byte(pdev, udmat, udma);
198}
199
200/**
201 * ali_set_piomode - set initial PIO mode data
202 * @ap: ATA interface
203 * @adev: ATA device
204 *
205 * Program the ALi registers for PIO mode. FIXME: add timings for
206 * PIO5.
207 */
208
209static void ali_set_piomode(struct ata_port *ap, struct ata_device *adev)
210{
211 struct ata_device *pair = ata_dev_pair(adev);
212 struct ata_timing t;
213 unsigned long T = 1000000000 / 33333; /* PCI clock based */
214
215 ata_timing_compute(adev, adev->pio_mode, &t, T, 1);
216 if (pair) {
217 struct ata_timing p;
218 ata_timing_compute(pair, pair->pio_mode, &p, T, 1);
219 ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
220 if (pair->dma_mode) {
221 ata_timing_compute(pair, pair->dma_mode, &p, T, 1);
222 ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
223 }
224 }
225
226 /* PIO FIFO is only permitted on ATA disk */
227 if (adev->class != ATA_DEV_ATA)
228 ali_fifo_control(ap, adev, 0x00);
229 ali_program_modes(ap, adev, &t, 0);
230 if (adev->class == ATA_DEV_ATA)
231 ali_fifo_control(ap, adev, 0x05);
232
233}
234
235/**
236 * ali_set_dmamode - set initial DMA mode data
237 * @ap: ATA interface
238 * @adev: ATA device
239 *
240 * FIXME: MWDMA timings
241 */
242
243static void ali_set_dmamode(struct ata_port *ap, struct ata_device *adev)
244{
245 static u8 udma_timing[7] = { 0xC, 0xB, 0xA, 0x9, 0x8, 0xF, 0xD };
246 struct ata_device *pair = ata_dev_pair(adev);
247 struct ata_timing t;
248 unsigned long T = 1000000000 / 33333; /* PCI clock based */
249 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
250
251
252 if (adev->class == ATA_DEV_ATA)
253 ali_fifo_control(ap, adev, 0x08);
254
255 if (adev->dma_mode >= XFER_UDMA_0) {
256 ali_program_modes(ap, adev, NULL, udma_timing[adev->dma_mode - XFER_UDMA_0]);
257 if (adev->dma_mode >= XFER_UDMA_3) {
258 u8 reg4b;
259 pci_read_config_byte(pdev, 0x4B, &reg4b);
260 reg4b |= 1;
261 pci_write_config_byte(pdev, 0x4B, reg4b);
262 }
263 } else {
264 ata_timing_compute(adev, adev->dma_mode, &t, T, 1);
265 if (pair) {
266 struct ata_timing p;
267 ata_timing_compute(pair, pair->pio_mode, &p, T, 1);
268 ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
269 if (pair->dma_mode) {
270 ata_timing_compute(pair, pair->dma_mode, &p, T, 1);
271 ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
272 }
273 }
274 ali_program_modes(ap, adev, &t, 0);
275 }
276}
277
278/**
Tejun Heo8243e632008-04-03 14:40:55 +0900279 * ali_warn_atapi_dma - Warn about ATAPI DMA disablement
280 * @adev: Device
281 *
282 * Whine about ATAPI DMA disablement if @adev is an ATAPI device.
283 * Can be used as ->dev_config.
284 */
285
286static void ali_warn_atapi_dma(struct ata_device *adev)
287{
288 struct ata_eh_context *ehc = &adev->link->eh_context;
289 int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
290
291 if (print_info && adev->class == ATA_DEV_ATAPI && !ali_atapi_dma) {
292 ata_dev_printk(adev, KERN_WARNING,
293 "WARNING: ATAPI DMA disabled for reliablity issues. It can be enabled\n");
294 ata_dev_printk(adev, KERN_WARNING,
295 "WARNING: via pata_ali.atapi_dma modparam or corresponding sysfs node.\n");
296 }
297}
298
299/**
Jeff Garzik669a5db2006-08-29 18:12:40 -0400300 * ali_lock_sectors - Keep older devices to 255 sector mode
Jeff Garzik669a5db2006-08-29 18:12:40 -0400301 * @adev: Device
302 *
303 * Called during the bus probe for each device that is found. We use
304 * this call to lock the sector count of the device to 255 or less on
305 * older ALi controllers. If we didn't do this then large I/O's would
306 * require LBA48 commands which the older ALi requires are issued by
307 * slower PIO methods
308 */
309
Alancd0d3bb2007-03-02 00:56:15 +0000310static void ali_lock_sectors(struct ata_device *adev)
Jeff Garzik669a5db2006-08-29 18:12:40 -0400311{
312 adev->max_sectors = 255;
Tejun Heo8243e632008-04-03 14:40:55 +0900313 ali_warn_atapi_dma(adev);
Jeff Garzik669a5db2006-08-29 18:12:40 -0400314}
315
Alan Cox498222f2007-11-19 14:37:58 +0000316/**
317 * ali_check_atapi_dma - DMA check for most ALi controllers
318 * @adev: Device
319 *
320 * Called to decide whether commands should be sent by DMA or PIO
321 */
Jeff Garzik2541d0c2007-11-23 21:08:42 -0500322
Alan Cox498222f2007-11-19 14:37:58 +0000323static int ali_check_atapi_dma(struct ata_queued_cmd *qc)
324{
Tejun Heo8243e632008-04-03 14:40:55 +0900325 if (!ali_atapi_dma) {
326 /* FIXME: pata_ali can't do ATAPI DMA reliably but the
327 * IDE alim15x3 driver can. I tried lots of things
328 * but couldn't find what the actual difference was.
329 * If you got an idea, please write it to
330 * linux-ide@vger.kernel.org and cc htejun@gmail.com.
331 *
332 * Disable ATAPI DMA for now.
333 */
334 return -EOPNOTSUPP;
335 }
336
Alan Cox498222f2007-11-19 14:37:58 +0000337 /* If its not a media command, its not worth it */
Tejun Heo4a38e732008-03-11 11:35:00 +0900338 if (atapi_cmd_type(qc->cdb[0]) == ATAPI_MISC)
Alan Cox498222f2007-11-19 14:37:58 +0000339 return -EOPNOTSUPP;
340 return 0;
341}
342
Alan Coxfc809022009-01-05 14:13:53 +0000343static void ali_c2_c3_postreset(struct ata_link *link, unsigned int *classes)
344{
345 u8 r;
346 int port_bit = 4 << link->ap->port_no;
347
348 /* If our bridge is an ALI 1533 then do the extra work */
Andrew Mortonbc42b242009-01-14 16:48:42 -0800349 if (ali_isa_bridge) {
Alan Coxfc809022009-01-05 14:13:53 +0000350 /* Tristate and re-enable the bus signals */
Andrew Mortonbc42b242009-01-14 16:48:42 -0800351 pci_read_config_byte(ali_isa_bridge, 0x58, &r);
Alan Coxfc809022009-01-05 14:13:53 +0000352 r &= ~port_bit;
Andrew Mortonbc42b242009-01-14 16:48:42 -0800353 pci_write_config_byte(ali_isa_bridge, 0x58, r);
Alan Coxfc809022009-01-05 14:13:53 +0000354 r |= port_bit;
Andrew Mortonbc42b242009-01-14 16:48:42 -0800355 pci_write_config_byte(ali_isa_bridge, 0x58, r);
Alan Coxfc809022009-01-05 14:13:53 +0000356 }
357 ata_sff_postreset(link, classes);
358}
359
Jeff Garzik669a5db2006-08-29 18:12:40 -0400360static struct scsi_host_template ali_sht = {
Tejun Heo68d1d072008-03-25 12:22:49 +0900361 ATA_BMDMA_SHT(DRV_NAME),
Jeff Garzik669a5db2006-08-29 18:12:40 -0400362};
363
364/*
365 * Port operations for PIO only ALi
366 */
367
368static struct ata_port_operations ali_early_port_ops = {
Tejun Heo029cfd62008-03-25 12:22:49 +0900369 .inherits = &ata_sff_port_ops,
Alan Coxb723d142007-03-26 21:43:37 -0800370 .cable_detect = ata_cable_40wire,
Tejun Heo029cfd62008-03-25 12:22:49 +0900371 .set_piomode = ali_set_piomode,
Alan Cox871af122009-01-05 14:16:39 +0000372 .sff_data_xfer = ata_sff_data_xfer32,
Tejun Heo029cfd62008-03-25 12:22:49 +0900373};
Jeff Garzik669a5db2006-08-29 18:12:40 -0400374
Tejun Heo029cfd62008-03-25 12:22:49 +0900375static const struct ata_port_operations ali_dma_base_ops = {
Alan Cox871af122009-01-05 14:16:39 +0000376 .inherits = &ata_bmdma32_port_ops,
Tejun Heo029cfd62008-03-25 12:22:49 +0900377 .set_piomode = ali_set_piomode,
378 .set_dmamode = ali_set_dmamode,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400379};
380
381/*
382 * Port operations for DMA capable ALi without cable
383 * detect
384 */
385static struct ata_port_operations ali_20_port_ops = {
Tejun Heo029cfd62008-03-25 12:22:49 +0900386 .inherits = &ali_dma_base_ops,
Alan Coxb723d142007-03-26 21:43:37 -0800387 .cable_detect = ata_cable_40wire,
Tejun Heo029cfd62008-03-25 12:22:49 +0900388 .mode_filter = ali_20_filter,
389 .check_atapi_dma = ali_check_atapi_dma,
390 .dev_config = ali_lock_sectors,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400391};
392
393/*
394 * Port operations for DMA capable ALi with cable detect
395 */
396static struct ata_port_operations ali_c2_port_ops = {
Tejun Heo029cfd62008-03-25 12:22:49 +0900397 .inherits = &ali_dma_base_ops,
Alan Cox498222f2007-11-19 14:37:58 +0000398 .check_atapi_dma = ali_check_atapi_dma,
Alan Coxb723d142007-03-26 21:43:37 -0800399 .cable_detect = ali_c2_cable_detect,
Tejun Heo029cfd62008-03-25 12:22:49 +0900400 .dev_config = ali_lock_sectors,
Alan Coxfc809022009-01-05 14:13:53 +0000401 .postreset = ali_c2_c3_postreset,
402};
403
404/*
405 * Port operations for DMA capable ALi with cable detect
406 */
407static struct ata_port_operations ali_c4_port_ops = {
408 .inherits = &ali_dma_base_ops,
409 .check_atapi_dma = ali_check_atapi_dma,
410 .cable_detect = ali_c2_cable_detect,
411 .dev_config = ali_lock_sectors,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400412};
413
414/*
415 * Port operations for DMA capable ALi with cable detect and LBA48
416 */
417static struct ata_port_operations ali_c5_port_ops = {
Tejun Heo029cfd62008-03-25 12:22:49 +0900418 .inherits = &ali_dma_base_ops,
Alan Cox498222f2007-11-19 14:37:58 +0000419 .check_atapi_dma = ali_check_atapi_dma,
Tejun Heo8243e632008-04-03 14:40:55 +0900420 .dev_config = ali_warn_atapi_dma,
Alan Coxb723d142007-03-26 21:43:37 -0800421 .cable_detect = ali_c2_cable_detect,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400422};
423
Alan34d8dfb2006-11-22 17:26:06 +0000424
425/**
426 * ali_init_chipset - chip setup function
427 * @pdev: PCI device of ATA controller
428 *
429 * Perform the setup on the device that must be done both at boot
430 * and at resume time.
431 */
Jeff Garzikf20b16f2006-12-11 11:14:06 -0500432
Alan34d8dfb2006-11-22 17:26:06 +0000433static void ali_init_chipset(struct pci_dev *pdev)
434{
Auke Kok44c10132007-06-08 15:46:36 -0700435 u8 tmp;
Alan Cox1b2c3572009-01-05 14:13:22 +0000436 struct pci_dev *north;
Alan34d8dfb2006-11-22 17:26:06 +0000437
Alan34d8dfb2006-11-22 17:26:06 +0000438 /*
439 * The chipset revision selects the driver operations and
440 * mode data.
441 */
442
Alan Cox1b2c3572009-01-05 14:13:22 +0000443 if (pdev->revision <= 0x20) {
444 pci_read_config_byte(pdev, 0x53, &tmp);
445 tmp |= 0x03;
446 pci_write_config_byte(pdev, 0x53, tmp);
447 } else {
448 pci_read_config_byte(pdev, 0x4a, &tmp);
449 pci_write_config_byte(pdev, 0x4a, tmp | 0x20);
Alan34d8dfb2006-11-22 17:26:06 +0000450 pci_read_config_byte(pdev, 0x4B, &tmp);
Alan Cox1b2c3572009-01-05 14:13:22 +0000451 if (pdev->revision < 0xC2)
452 /* 1543-E/F, 1543C-C, 1543C-D, 1543C-E */
453 /* Clear CD-ROM DMA write bit */
454 tmp &= 0x7F;
455 /* Cable and UDMA */
456 pci_write_config_byte(pdev, 0x4B, tmp | 0x09);
457 /*
458 * CD_ROM DMA on (0x53 bit 0). Enable this even if we want
459 * to use PIO. 0x53 bit 1 (rev 20 only) - enable FIFO control
460 * via 0x54/55.
461 */
462 pci_read_config_byte(pdev, 0x53, &tmp);
463 if (pdev->revision >= 0xc7)
464 tmp |= 0x03;
465 else
466 tmp |= 0x01; /* CD_ROM enable for DMA */
467 pci_write_config_byte(pdev, 0x53, tmp);
Alan34d8dfb2006-11-22 17:26:06 +0000468 }
Alan8e42a5a2006-12-04 16:36:05 +0000469 north = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
Andrew Mortonbc42b242009-01-14 16:48:42 -0800470 if (north && north->vendor == PCI_VENDOR_ID_AL && ali_isa_bridge) {
Alan34d8dfb2006-11-22 17:26:06 +0000471 /* Configure the ALi bridge logic. For non ALi rely on BIOS.
472 Set the south bridge enable bit */
Andrew Mortonbc42b242009-01-14 16:48:42 -0800473 pci_read_config_byte(ali_isa_bridge, 0x79, &tmp);
Auke Kok44c10132007-06-08 15:46:36 -0700474 if (pdev->revision == 0xC2)
Andrew Mortonbc42b242009-01-14 16:48:42 -0800475 pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x04);
Auke Kok44c10132007-06-08 15:46:36 -0700476 else if (pdev->revision > 0xC2 && pdev->revision < 0xC5)
Andrew Mortonbc42b242009-01-14 16:48:42 -0800477 pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x02);
Alan34d8dfb2006-11-22 17:26:06 +0000478 }
Alan34d8dfb2006-11-22 17:26:06 +0000479 pci_dev_put(north);
Tejun Heo9363c382008-04-07 22:47:16 +0900480 ata_pci_bmdma_clear_simplex(pdev);
Alan34d8dfb2006-11-22 17:26:06 +0000481}
Jeff Garzik669a5db2006-08-29 18:12:40 -0400482/**
483 * ali_init_one - discovery callback
484 * @pdev: PCI device ID
485 * @id: PCI table info
486 *
487 * An ALi IDE interface has been discovered. Figure out what revision
488 * and perform configuration work before handing it to the ATA layer
489 */
490
491static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
492{
Tejun Heo1626aeb2007-05-04 12:43:58 +0200493 static const struct ata_port_info info_early = {
Jeff Garzik1d2808f2007-05-28 06:59:48 -0400494 .flags = ATA_FLAG_SLAVE_POSS,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400495 .pio_mask = 0x1f,
496 .port_ops = &ali_early_port_ops
497 };
498 /* Revision 0x20 added DMA */
Tejun Heo1626aeb2007-05-04 12:43:58 +0200499 static const struct ata_port_info info_20 = {
Jeff Garzik1d2808f2007-05-28 06:59:48 -0400500 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400501 .pio_mask = 0x1f,
502 .mwdma_mask = 0x07,
503 .port_ops = &ali_20_port_ops
504 };
505 /* Revision 0x20 with support logic added UDMA */
Tejun Heo1626aeb2007-05-04 12:43:58 +0200506 static const struct ata_port_info info_20_udma = {
Jeff Garzik1d2808f2007-05-28 06:59:48 -0400507 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400508 .pio_mask = 0x1f,
Jeff Garzik85cd7252006-08-31 00:03:49 -0400509 .mwdma_mask = 0x07,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400510 .udma_mask = 0x07, /* UDMA33 */
511 .port_ops = &ali_20_port_ops
512 };
513 /* Revision 0xC2 adds UDMA66 */
Tejun Heo1626aeb2007-05-04 12:43:58 +0200514 static const struct ata_port_info info_c2 = {
Jeff Garzik1d2808f2007-05-28 06:59:48 -0400515 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400516 .pio_mask = 0x1f,
517 .mwdma_mask = 0x07,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400518 .udma_mask = ATA_UDMA4,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400519 .port_ops = &ali_c2_port_ops
520 };
Chuck Ebbertee581502007-06-25 19:13:32 -0400521 /* Revision 0xC3 is UDMA66 for now */
Tejun Heo1626aeb2007-05-04 12:43:58 +0200522 static const struct ata_port_info info_c3 = {
Jeff Garzik1d2808f2007-05-28 06:59:48 -0400523 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400524 .pio_mask = 0x1f,
525 .mwdma_mask = 0x07,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400526 .udma_mask = ATA_UDMA4,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400527 .port_ops = &ali_c2_port_ops
528 };
Chuck Ebbertee581502007-06-25 19:13:32 -0400529 /* Revision 0xC4 is UDMA100 */
Tejun Heo1626aeb2007-05-04 12:43:58 +0200530 static const struct ata_port_info info_c4 = {
Jeff Garzik1d2808f2007-05-28 06:59:48 -0400531 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400532 .pio_mask = 0x1f,
533 .mwdma_mask = 0x07,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400534 .udma_mask = ATA_UDMA5,
Alan Coxfc809022009-01-05 14:13:53 +0000535 .port_ops = &ali_c4_port_ops
Jeff Garzik669a5db2006-08-29 18:12:40 -0400536 };
537 /* Revision 0xC5 is UDMA133 with LBA48 DMA */
Tejun Heo1626aeb2007-05-04 12:43:58 +0200538 static const struct ata_port_info info_c5 = {
Jeff Garzik1d2808f2007-05-28 06:59:48 -0400539 .flags = ATA_FLAG_SLAVE_POSS,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400540 .pio_mask = 0x1f,
541 .mwdma_mask = 0x07,
Jeff Garzikbf6263a2007-07-09 12:16:50 -0400542 .udma_mask = ATA_UDMA6,
Jeff Garzik669a5db2006-08-29 18:12:40 -0400543 .port_ops = &ali_c5_port_ops
544 };
545
Tejun Heo1626aeb2007-05-04 12:43:58 +0200546 const struct ata_port_info *ppi[] = { NULL, NULL };
Auke Kok44c10132007-06-08 15:46:36 -0700547 u8 tmp;
Tejun Heof08048e2008-03-25 12:22:47 +0900548 int rc;
549
550 rc = pcim_enable_device(pdev);
551 if (rc)
552 return rc;
Jeff Garzik669a5db2006-08-29 18:12:40 -0400553
Jeff Garzik669a5db2006-08-29 18:12:40 -0400554 /*
555 * The chipset revision selects the driver operations and
556 * mode data.
557 */
558
Auke Kok44c10132007-06-08 15:46:36 -0700559 if (pdev->revision < 0x20) {
Tejun Heo1626aeb2007-05-04 12:43:58 +0200560 ppi[0] = &info_early;
Auke Kok44c10132007-06-08 15:46:36 -0700561 } else if (pdev->revision < 0xC2) {
Tejun Heo1626aeb2007-05-04 12:43:58 +0200562 ppi[0] = &info_20;
Auke Kok44c10132007-06-08 15:46:36 -0700563 } else if (pdev->revision == 0xC2) {
Tejun Heo1626aeb2007-05-04 12:43:58 +0200564 ppi[0] = &info_c2;
Auke Kok44c10132007-06-08 15:46:36 -0700565 } else if (pdev->revision == 0xC3) {
Tejun Heo1626aeb2007-05-04 12:43:58 +0200566 ppi[0] = &info_c3;
Auke Kok44c10132007-06-08 15:46:36 -0700567 } else if (pdev->revision == 0xC4) {
Tejun Heo1626aeb2007-05-04 12:43:58 +0200568 ppi[0] = &info_c4;
Jeff Garzik669a5db2006-08-29 18:12:40 -0400569 } else
Tejun Heo1626aeb2007-05-04 12:43:58 +0200570 ppi[0] = &info_c5;
Jeff Garzik669a5db2006-08-29 18:12:40 -0400571
Alan34d8dfb2006-11-22 17:26:06 +0000572 ali_init_chipset(pdev);
Jeff Garzikf20b16f2006-12-11 11:14:06 -0500573
Andrew Mortonbc42b242009-01-14 16:48:42 -0800574 if (ali_isa_bridge && pdev->revision >= 0x20 && pdev->revision < 0xC2) {
Alan34d8dfb2006-11-22 17:26:06 +0000575 /* Are we paired with a UDMA capable chip */
Andrew Mortonbc42b242009-01-14 16:48:42 -0800576 pci_read_config_byte(ali_isa_bridge, 0x5E, &tmp);
Alan34d8dfb2006-11-22 17:26:06 +0000577 if ((tmp & 0x1E) == 0x12)
Tejun Heo1626aeb2007-05-04 12:43:58 +0200578 ppi[0] = &info_20_udma;
Jeff Garzik669a5db2006-08-29 18:12:40 -0400579 }
Ben Dookse8389f02008-07-24 16:38:06 +0100580
Tejun Heo9363c382008-04-07 22:47:16 +0900581 return ata_pci_sff_init_one(pdev, ppi, &ali_sht, NULL);
Jeff Garzik669a5db2006-08-29 18:12:40 -0400582}
583
Tejun Heo438ac6d2007-03-02 17:31:26 +0900584#ifdef CONFIG_PM
Alan34d8dfb2006-11-22 17:26:06 +0000585static int ali_reinit_one(struct pci_dev *pdev)
586{
Tejun Heof08048e2008-03-25 12:22:47 +0900587 struct ata_host *host = dev_get_drvdata(&pdev->dev);
588 int rc;
589
590 rc = ata_pci_device_do_resume(pdev);
591 if (rc)
592 return rc;
Alan34d8dfb2006-11-22 17:26:06 +0000593 ali_init_chipset(pdev);
Tejun Heof08048e2008-03-25 12:22:47 +0900594 ata_host_resume(host);
595 return 0;
Alan34d8dfb2006-11-22 17:26:06 +0000596}
Tejun Heo438ac6d2007-03-02 17:31:26 +0900597#endif
Alan34d8dfb2006-11-22 17:26:06 +0000598
Jeff Garzik2d2744f2006-09-28 20:21:59 -0400599static const struct pci_device_id ali[] = {
600 { PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5228), },
601 { PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5229), },
602
603 { },
Jeff Garzik669a5db2006-08-29 18:12:40 -0400604};
605
606static struct pci_driver ali_pci_driver = {
607 .name = DRV_NAME,
608 .id_table = ali,
609 .probe = ali_init_one,
Alan34d8dfb2006-11-22 17:26:06 +0000610 .remove = ata_pci_remove_one,
Tejun Heo438ac6d2007-03-02 17:31:26 +0900611#ifdef CONFIG_PM
Alan34d8dfb2006-11-22 17:26:06 +0000612 .suspend = ata_pci_device_suspend,
613 .resume = ali_reinit_one,
Tejun Heo438ac6d2007-03-02 17:31:26 +0900614#endif
Jeff Garzik669a5db2006-08-29 18:12:40 -0400615};
616
617static int __init ali_init(void)
618{
Alan Cox1b2c3572009-01-05 14:13:22 +0000619 int ret;
Andrew Mortonbc42b242009-01-14 16:48:42 -0800620 ali_isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
Alan Cox1b2c3572009-01-05 14:13:22 +0000621
622 ret = pci_register_driver(&ali_pci_driver);
623 if (ret < 0)
Andrew Mortonbc42b242009-01-14 16:48:42 -0800624 pci_dev_put(ali_isa_bridge);
Alan Cox1b2c3572009-01-05 14:13:22 +0000625 return ret;
Jeff Garzik669a5db2006-08-29 18:12:40 -0400626}
627
628
629static void __exit ali_exit(void)
630{
631 pci_unregister_driver(&ali_pci_driver);
Andrew Mortonbc42b242009-01-14 16:48:42 -0800632 pci_dev_put(ali_isa_bridge);
Jeff Garzik669a5db2006-08-29 18:12:40 -0400633}
634
635
636MODULE_AUTHOR("Alan Cox");
637MODULE_DESCRIPTION("low-level driver for ALi PATA");
638MODULE_LICENSE("GPL");
639MODULE_DEVICE_TABLE(pci, ali);
640MODULE_VERSION(DRV_VERSION);
641
642module_init(ali_init);
643module_exit(ali_exit);