1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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"
38#define DRV_VERSION "0.7.8"
39
40static int ali_atapi_dma = 0;
41module_param_named(atapi_dma, ali_atapi_dma, int, 0644);
42MODULE_PARM_DESC(atapi_dma, "Enable ATAPI DMA (0=disable, 1=enable)");
43
44static struct pci_dev *ali_isa_bridge;
45
46
47
48
49
50static const struct dmi_system_id cable_dmi_table[] = {
51 {
52 .ident = "HP Pavilion N5430",
53 .matches = {
54 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
55 DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
56 },
57 },
58 {
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 },
65 { }
66};
67
68static int ali_cable_override(struct pci_dev *pdev)
69{
70
71 if (pdev->subsystem_vendor == 0x10CF && pdev->subsystem_device == 0x10AF)
72 return 1;
73
74 if (pdev->subsystem_vendor == 0x1071 && pdev->subsystem_device == 0x8317)
75 return 1;
76
77 if (dmi_check_system(cable_dmi_table))
78 return 1;
79 return 0;
80}
81
82
83
84
85
86
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
95
96
97 if (ali_cable_override(pdev))
98 return ATA_CBL_PATA40_SHORT;
99
100
101
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
110
111
112
113
114
115
116
117
118static unsigned long ali_20_filter(struct ata_device *adev, unsigned long mask)
119{
120 char model_num[ATA_ID_PROD_LEN + 1];
121
122 if (adev->class != ATA_DEV_ATA)
123 mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
124 ata_id_c_string(adev->id, model_num, ATA_ID_PROD, sizeof(model_num));
125 if (strstr(model_num, "WDC"))
126 return mask &= ~ATA_MASK_UDMA;
127 return ata_bmdma_mode_filter(adev, mask);
128}
129
130
131
132
133
134
135
136
137
138
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
149
150
151
152 pci_read_config_byte(pdev, pio_fifo, &fifo);
153 fifo &= ~(0x0F << shift);
154 fifo |= (on << shift);
155 pci_write_config_byte(pdev, pio_fifo, fifo);
156}
157
158
159
160
161
162
163
164
165
166
167
168
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;
175 int cbt = 0x59 + 4 * ap->port_no;
176 int drwt = 0x5A + 4 * ap->port_no + adev->devno;
177 int udmat = 0x56 + ap->port_no;
178 int shift = 4 * adev->devno;
179 u8 udma;
180
181 if (t != NULL) {
182 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;
187
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
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
202
203
204
205
206
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;
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
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
237
238
239
240
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;
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, ®4b);
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
279
280
281
282
283
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 reliability 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
300
301
302
303
304
305
306
307
308
309
310static void ali_lock_sectors(struct ata_device *adev)
311{
312 adev->max_sectors = 255;
313 ali_warn_atapi_dma(adev);
314}
315
316
317
318
319
320
321
322
323static int ali_check_atapi_dma(struct ata_queued_cmd *qc)
324{
325 if (!ali_atapi_dma) {
326
327
328
329
330
331
332
333
334 return -EOPNOTSUPP;
335 }
336
337
338 if (atapi_cmd_type(qc->cdb[0]) == ATAPI_MISC)
339 return -EOPNOTSUPP;
340 return 0;
341}
342
343static 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
349 if (ali_isa_bridge) {
350
351 pci_read_config_byte(ali_isa_bridge, 0x58, &r);
352 r &= ~port_bit;
353 pci_write_config_byte(ali_isa_bridge, 0x58, r);
354 r |= port_bit;
355 pci_write_config_byte(ali_isa_bridge, 0x58, r);
356 }
357 ata_sff_postreset(link, classes);
358}
359
360static struct scsi_host_template ali_sht = {
361 ATA_BMDMA_SHT(DRV_NAME),
362};
363
364
365
366
367
368static struct ata_port_operations ali_early_port_ops = {
369 .inherits = &ata_sff_port_ops,
370 .cable_detect = ata_cable_40wire,
371 .set_piomode = ali_set_piomode,
372 .sff_data_xfer = ata_sff_data_xfer32,
373};
374
375static const struct ata_port_operations ali_dma_base_ops = {
376 .inherits = &ata_bmdma32_port_ops,
377 .set_piomode = ali_set_piomode,
378 .set_dmamode = ali_set_dmamode,
379};
380
381
382
383
384
385static struct ata_port_operations ali_20_port_ops = {
386 .inherits = &ali_dma_base_ops,
387 .cable_detect = ata_cable_40wire,
388 .mode_filter = ali_20_filter,
389 .check_atapi_dma = ali_check_atapi_dma,
390 .dev_config = ali_lock_sectors,
391};
392
393
394
395
396static struct ata_port_operations ali_c2_port_ops = {
397 .inherits = &ali_dma_base_ops,
398 .check_atapi_dma = ali_check_atapi_dma,
399 .cable_detect = ali_c2_cable_detect,
400 .dev_config = ali_lock_sectors,
401 .postreset = ali_c2_c3_postreset,
402};
403
404
405
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,
412};
413
414
415
416
417static struct ata_port_operations ali_c5_port_ops = {
418 .inherits = &ali_dma_base_ops,
419 .check_atapi_dma = ali_check_atapi_dma,
420 .dev_config = ali_warn_atapi_dma,
421 .cable_detect = ali_c2_cable_detect,
422};
423
424
425
426
427
428
429
430
431
432
433static void ali_init_chipset(struct pci_dev *pdev)
434{
435 u8 tmp;
436 struct pci_dev *north;
437
438
439
440
441
442
443 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);
450 pci_read_config_byte(pdev, 0x4B, &tmp);
451 if (pdev->revision < 0xC2)
452
453
454 tmp &= 0x7F;
455
456 pci_write_config_byte(pdev, 0x4B, tmp | 0x09);
457
458
459
460
461
462 pci_read_config_byte(pdev, 0x53, &tmp);
463 if (pdev->revision >= 0xc7)
464 tmp |= 0x03;
465 else
466 tmp |= 0x01;
467 pci_write_config_byte(pdev, 0x53, tmp);
468 }
469 north = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
470 if (north && north->vendor == PCI_VENDOR_ID_AL && ali_isa_bridge) {
471
472
473 pci_read_config_byte(ali_isa_bridge, 0x79, &tmp);
474 if (pdev->revision == 0xC2)
475 pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x04);
476 else if (pdev->revision > 0xC2 && pdev->revision < 0xC5)
477 pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x02);
478 }
479 pci_dev_put(north);
480 ata_pci_bmdma_clear_simplex(pdev);
481}
482
483
484
485
486
487
488
489
490
491static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
492{
493 static const struct ata_port_info info_early = {
494 .flags = ATA_FLAG_SLAVE_POSS,
495 .pio_mask = ATA_PIO4,
496 .port_ops = &ali_early_port_ops
497 };
498
499 static const struct ata_port_info info_20 = {
500 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
501 ATA_FLAG_IGN_SIMPLEX,
502 .pio_mask = ATA_PIO4,
503 .mwdma_mask = ATA_MWDMA2,
504 .port_ops = &ali_20_port_ops
505 };
506
507 static const struct ata_port_info info_20_udma = {
508 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
509 ATA_FLAG_IGN_SIMPLEX,
510 .pio_mask = ATA_PIO4,
511 .mwdma_mask = ATA_MWDMA2,
512 .udma_mask = ATA_UDMA2,
513 .port_ops = &ali_20_port_ops
514 };
515
516 static const struct ata_port_info info_c2 = {
517 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
518 ATA_FLAG_IGN_SIMPLEX,
519 .pio_mask = ATA_PIO4,
520 .mwdma_mask = ATA_MWDMA2,
521 .udma_mask = ATA_UDMA4,
522 .port_ops = &ali_c2_port_ops
523 };
524
525 static const struct ata_port_info info_c3 = {
526 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
527 ATA_FLAG_IGN_SIMPLEX,
528 .pio_mask = ATA_PIO4,
529 .mwdma_mask = ATA_MWDMA2,
530 .udma_mask = ATA_UDMA4,
531 .port_ops = &ali_c2_port_ops
532 };
533
534 static const struct ata_port_info info_c4 = {
535 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
536 ATA_FLAG_IGN_SIMPLEX,
537 .pio_mask = ATA_PIO4,
538 .mwdma_mask = ATA_MWDMA2,
539 .udma_mask = ATA_UDMA5,
540 .port_ops = &ali_c4_port_ops
541 };
542
543 static const struct ata_port_info info_c5 = {
544 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_IGN_SIMPLEX,
545 .pio_mask = ATA_PIO4,
546 .mwdma_mask = ATA_MWDMA2,
547 .udma_mask = ATA_UDMA6,
548 .port_ops = &ali_c5_port_ops
549 };
550
551 const struct ata_port_info *ppi[] = { NULL, NULL };
552 u8 tmp;
553 int rc;
554
555 rc = pcim_enable_device(pdev);
556 if (rc)
557 return rc;
558
559
560
561
562
563
564 if (pdev->revision < 0x20) {
565 ppi[0] = &info_early;
566 } else if (pdev->revision < 0xC2) {
567 ppi[0] = &info_20;
568 } else if (pdev->revision == 0xC2) {
569 ppi[0] = &info_c2;
570 } else if (pdev->revision == 0xC3) {
571 ppi[0] = &info_c3;
572 } else if (pdev->revision == 0xC4) {
573 ppi[0] = &info_c4;
574 } else
575 ppi[0] = &info_c5;
576
577 ali_init_chipset(pdev);
578
579 if (ali_isa_bridge && pdev->revision >= 0x20 && pdev->revision < 0xC2) {
580
581 pci_read_config_byte(ali_isa_bridge, 0x5E, &tmp);
582 if ((tmp & 0x1E) == 0x12)
583 ppi[0] = &info_20_udma;
584 }
585
586 return ata_pci_sff_init_one(pdev, ppi, &ali_sht, NULL);
587}
588
589#ifdef CONFIG_PM
590static int ali_reinit_one(struct pci_dev *pdev)
591{
592 struct ata_host *host = dev_get_drvdata(&pdev->dev);
593 int rc;
594
595 rc = ata_pci_device_do_resume(pdev);
596 if (rc)
597 return rc;
598 ali_init_chipset(pdev);
599 ata_host_resume(host);
600 return 0;
601}
602#endif
603
604static const struct pci_device_id ali[] = {
605 { PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5228), },
606 { PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5229), },
607
608 { },
609};
610
611static struct pci_driver ali_pci_driver = {
612 .name = DRV_NAME,
613 .id_table = ali,
614 .probe = ali_init_one,
615 .remove = ata_pci_remove_one,
616#ifdef CONFIG_PM
617 .suspend = ata_pci_device_suspend,
618 .resume = ali_reinit_one,
619#endif
620};
621
622static int __init ali_init(void)
623{
624 int ret;
625 ali_isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
626
627 ret = pci_register_driver(&ali_pci_driver);
628 if (ret < 0)
629 pci_dev_put(ali_isa_bridge);
630 return ret;
631}
632
633
634static void __exit ali_exit(void)
635{
636 pci_unregister_driver(&ali_pci_driver);
637 pci_dev_put(ali_isa_bridge);
638}
639
640
641MODULE_AUTHOR("Alan Cox");
642MODULE_DESCRIPTION("low-level driver for ALi PATA");
643MODULE_LICENSE("GPL");
644MODULE_DEVICE_TABLE(pci, ali);
645MODULE_VERSION(DRV_VERSION);
646
647module_init(ali_init);
648module_exit(ali_exit);
649