[PATCH] turn "const static" into "static const"
[linux-2.6.git] / drivers / ide / pci / pdc202xx_new.c
1 /*
2  *  Promise TX2/TX4/TX2000/133 IDE driver
3  *
4  *  This program is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU General Public License
6  *  as published by the Free Software Foundation; either version
7  *  2 of the License, or (at your option) any later version.
8  *
9  *  Split from:
10  *  linux/drivers/ide/pdc202xx.c        Version 0.35    Mar. 30, 2002
11  *  Copyright (C) 1998-2002             Andre Hedrick <andre@linux-ide.org>
12  *  Portions Copyright (C) 1999 Promise Technology, Inc.
13  *  Author: Frank Tiernan (frankt@promise.com)
14  *  Released under terms of General Public License
15  */
16
17 #include <linux/config.h>
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/kernel.h>
21 #include <linux/delay.h>
22 #include <linux/timer.h>
23 #include <linux/mm.h>
24 #include <linux/ioport.h>
25 #include <linux/blkdev.h>
26 #include <linux/hdreg.h>
27 #include <linux/interrupt.h>
28 #include <linux/pci.h>
29 #include <linux/init.h>
30 #include <linux/ide.h>
31
32 #include <asm/io.h>
33 #include <asm/irq.h>
34
35 #ifdef CONFIG_PPC_PMAC
36 #include <asm/prom.h>
37 #include <asm/pci-bridge.h>
38 #endif
39
40 #define PDC202_DEBUG_CABLE      0
41
42 static const char *pdc_quirk_drives[] = {
43         "QUANTUM FIREBALLlct08 08",
44         "QUANTUM FIREBALLP KA6.4",
45         "QUANTUM FIREBALLP KA9.1",
46         "QUANTUM FIREBALLP LM20.4",
47         "QUANTUM FIREBALLP KX13.6",
48         "QUANTUM FIREBALLP KX20.5",
49         "QUANTUM FIREBALLP KX27.3",
50         "QUANTUM FIREBALLP LM20.5",
51         NULL
52 };
53
54 #define set_2regs(a, b)                                 \
55         do {                                            \
56                 hwif->OUTB((a + adj), indexreg);        \
57                 hwif->OUTB(b, datareg);                 \
58         } while(0)
59
60 #define set_ultra(a, b, c)                              \
61         do {                                            \
62                 set_2regs(0x10,(a));                    \
63                 set_2regs(0x11,(b));                    \
64                 set_2regs(0x12,(c));                    \
65         } while(0)
66
67 #define set_ata2(a, b)                                  \
68         do {                                            \
69                 set_2regs(0x0e,(a));                    \
70                 set_2regs(0x0f,(b));                    \
71         } while(0)
72
73 #define set_pio(a, b, c)                                \
74         do {                                            \
75                 set_2regs(0x0c,(a));                    \
76                 set_2regs(0x0d,(b));                    \
77                 set_2regs(0x13,(c));                    \
78         } while(0)
79
80 static u8 pdcnew_ratemask (ide_drive_t *drive)
81 {
82         u8 mode;
83
84         switch(HWIF(drive)->pci_dev->device) {
85                 case PCI_DEVICE_ID_PROMISE_20277:
86                 case PCI_DEVICE_ID_PROMISE_20276:
87                 case PCI_DEVICE_ID_PROMISE_20275:
88                 case PCI_DEVICE_ID_PROMISE_20271:
89                 case PCI_DEVICE_ID_PROMISE_20269:
90                         mode = 4;
91                         break;
92                 case PCI_DEVICE_ID_PROMISE_20270:
93                 case PCI_DEVICE_ID_PROMISE_20268:
94                         mode = 3;
95                         break;
96                 default:
97                         return 0;
98         }
99         if (!eighty_ninty_three(drive))
100                 mode = min(mode, (u8)1);
101         return mode;
102 }
103
104 static int check_in_drive_lists (ide_drive_t *drive, const char **list)
105 {
106         struct hd_driveid *id = drive->id;
107
108         if (pdc_quirk_drives == list) {
109                 while (*list) {
110                         if (strstr(id->model, *list++)) {
111                                 return 2;
112                         }
113                 }
114         } else {
115                 while (*list) {
116                         if (!strcmp(*list++,id->model)) {
117                                 return 1;
118                         }
119                 }
120         }
121         return 0;
122 }
123
124 static int pdcnew_new_tune_chipset (ide_drive_t *drive, u8 xferspeed)
125 {
126         ide_hwif_t *hwif        = HWIF(drive);
127         unsigned long indexreg  = hwif->dma_vendor1;
128         unsigned long datareg   = hwif->dma_vendor3;
129         u8 thold                = 0x10;
130         u8 adj                  = (drive->dn%2) ? 0x08 : 0x00;
131         u8 speed                = ide_rate_filter(pdcnew_ratemask(drive), xferspeed);
132
133         if (speed == XFER_UDMA_2) {
134                 hwif->OUTB((thold + adj), indexreg);
135                 hwif->OUTB((hwif->INB(datareg) & 0x7f), datareg);
136         }
137
138         switch (speed) {
139                 case XFER_UDMA_7:
140                         speed = XFER_UDMA_6;
141                 case XFER_UDMA_6:       set_ultra(0x1a, 0x01, 0xcb); break;
142                 case XFER_UDMA_5:       set_ultra(0x1a, 0x02, 0xcb); break;
143                 case XFER_UDMA_4:       set_ultra(0x1a, 0x03, 0xcd); break;
144                 case XFER_UDMA_3:       set_ultra(0x1a, 0x05, 0xcd); break;
145                 case XFER_UDMA_2:       set_ultra(0x2a, 0x07, 0xcd); break;
146                 case XFER_UDMA_1:       set_ultra(0x3a, 0x0a, 0xd0); break;
147                 case XFER_UDMA_0:       set_ultra(0x4a, 0x0f, 0xd5); break;
148                 case XFER_MW_DMA_2:     set_ata2(0x69, 0x25); break;
149                 case XFER_MW_DMA_1:     set_ata2(0x6b, 0x27); break;
150                 case XFER_MW_DMA_0:     set_ata2(0xdf, 0x5f); break;
151                 case XFER_PIO_4:        set_pio(0x23, 0x09, 0x25); break;
152                 case XFER_PIO_3:        set_pio(0x27, 0x0d, 0x35); break;
153                 case XFER_PIO_2:        set_pio(0x23, 0x26, 0x64); break;
154                 case XFER_PIO_1:        set_pio(0x46, 0x29, 0xa4); break;
155                 case XFER_PIO_0:        set_pio(0xfb, 0x2b, 0xac); break;
156                 default:
157                         ;
158         }
159
160         return (ide_config_drive_speed(drive, speed));
161 }
162
163 /*   0    1    2    3    4    5    6   7   8
164  * 960, 480, 390, 300, 240, 180, 120, 90, 60
165  *           180, 150, 120,  90,  60
166  * DMA_Speed
167  * 180, 120,  90,  90,  90,  60,  30
168  *  11,   5,   4,   3,   2,   1,   0
169  */
170 static void pdcnew_tune_drive(ide_drive_t *drive, u8 pio)
171 {
172         u8 speed;
173
174         if (pio == 5) pio = 4;
175         speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, pio, NULL);
176
177         (void)pdcnew_new_tune_chipset(drive, speed);
178 }
179
180 static u8 pdcnew_new_cable_detect (ide_hwif_t *hwif)
181 {
182         hwif->OUTB(0x0b, hwif->dma_vendor1);
183         return ((u8)((hwif->INB(hwif->dma_vendor3) & 0x04)));
184 }
185 static int config_chipset_for_dma (ide_drive_t *drive)
186 {
187         struct hd_driveid *id   = drive->id;
188         ide_hwif_t *hwif        = HWIF(drive);
189         u8 speed                = -1;
190         u8 cable;
191
192         u8 ultra_66             = ((id->dma_ultra & 0x0010) ||
193                                    (id->dma_ultra & 0x0008)) ? 1 : 0;
194
195         cable = pdcnew_new_cable_detect(hwif);
196
197         if (ultra_66 && cable) {
198                 printk(KERN_WARNING "Warning: %s channel requires an 80-pin cable for operation.\n", hwif->channel ? "Secondary":"Primary");
199                 printk(KERN_WARNING "%s reduced to Ultra33 mode.\n", drive->name);
200         }
201
202         if (drive->media != ide_disk)
203                 return 0;
204         if (id->capability & 4) {       /* IORDY_EN & PREFETCH_EN */
205                 hwif->OUTB((0x13 + ((drive->dn%2) ? 0x08 : 0x00)), hwif->dma_vendor1);
206                 hwif->OUTB((hwif->INB(hwif->dma_vendor3)|0x03), hwif->dma_vendor3);
207         }
208
209         speed = ide_dma_speed(drive, pdcnew_ratemask(drive));
210
211         if (!(speed)) {
212                 hwif->tuneproc(drive, 5);
213                 return 0;
214         }
215
216         (void) hwif->speedproc(drive, speed);
217         return ide_dma_enable(drive);
218 }
219
220 static int pdcnew_config_drive_xfer_rate (ide_drive_t *drive)
221 {
222         ide_hwif_t *hwif        = HWIF(drive);
223         struct hd_driveid *id   = drive->id;
224
225         drive->init_speed = 0;
226
227         if (id && (id->capability & 1) && drive->autodma) {
228
229                 if (ide_use_dma(drive)) {
230                         if (config_chipset_for_dma(drive))
231                                 return hwif->ide_dma_on(drive);
232                 }
233
234                 goto fast_ata_pio;
235
236         } else if ((id->capability & 8) || (id->field_valid & 2)) {
237 fast_ata_pio:
238                 hwif->tuneproc(drive, 5);
239                 return hwif->ide_dma_off_quietly(drive);
240         }
241         /* IORDY not supported */
242         return 0;
243 }
244
245 static int pdcnew_quirkproc (ide_drive_t *drive)
246 {
247         return ((int) check_in_drive_lists(drive, pdc_quirk_drives));
248 }
249
250 static int pdcnew_ide_dma_lostirq(ide_drive_t *drive)
251 {
252         if (HWIF(drive)->resetproc != NULL)
253                 HWIF(drive)->resetproc(drive);
254         return __ide_dma_lostirq(drive);
255 }
256
257 static int pdcnew_ide_dma_timeout(ide_drive_t *drive)
258 {
259         if (HWIF(drive)->resetproc != NULL)
260                 HWIF(drive)->resetproc(drive);
261         return __ide_dma_timeout(drive);
262 }
263
264 static void pdcnew_new_reset (ide_drive_t *drive)
265 {
266         /*
267          * Deleted this because it is redundant from the caller.
268          */
269         printk(KERN_WARNING "PDC202XX: %s channel reset.\n",
270                 HWIF(drive)->channel ? "Secondary" : "Primary");
271 }
272
273 #ifdef CONFIG_PPC_PMAC
274 static void __devinit apple_kiwi_init(struct pci_dev *pdev)
275 {
276         struct device_node *np = pci_device_to_OF_node(pdev);
277         unsigned int class_rev = 0;
278         void __iomem *mmio;
279         u8 conf;
280
281         if (np == NULL || !device_is_compatible(np, "kiwi-root"))
282                 return;
283
284         pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
285         class_rev &= 0xff;
286
287         if (class_rev >= 0x03) {
288                 /* Setup chip magic config stuff (from darwin) */
289                 pci_read_config_byte(pdev, 0x40, &conf);
290                 pci_write_config_byte(pdev, 0x40, conf | 0x01);
291         }
292         mmio = ioremap(pci_resource_start(pdev, 5),
293                                       pci_resource_len(pdev, 5));
294
295         /* Setup some PLL stuffs */
296         switch (pdev->device) {
297         case PCI_DEVICE_ID_PROMISE_20270:
298                 writew(0x0d2b, mmio + 0x1202);
299                 mdelay(30);
300                 break;
301         case PCI_DEVICE_ID_PROMISE_20271:
302                 writew(0x0826, mmio + 0x1202);
303                 mdelay(30);
304                 break;
305         }
306
307         iounmap(mmio);
308 }
309 #endif /* CONFIG_PPC_PMAC */
310
311 static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const char *name)
312 {
313         if (dev->resource[PCI_ROM_RESOURCE].start) {
314                 pci_write_config_dword(dev, PCI_ROM_ADDRESS,
315                         dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
316                 printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n",
317                         name, dev->resource[PCI_ROM_RESOURCE].start);
318         }
319
320 #ifdef CONFIG_PPC_PMAC
321         apple_kiwi_init(dev);
322 #endif
323
324         return dev->irq;
325 }
326
327 static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
328 {
329         hwif->autodma = 0;
330
331         hwif->tuneproc  = &pdcnew_tune_drive;
332         hwif->quirkproc = &pdcnew_quirkproc;
333         hwif->speedproc = &pdcnew_new_tune_chipset;
334         hwif->resetproc = &pdcnew_new_reset;
335
336         hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
337
338         hwif->ultra_mask = 0x7f;
339         hwif->mwdma_mask = 0x07;
340
341         hwif->ide_dma_check = &pdcnew_config_drive_xfer_rate;
342         hwif->ide_dma_lostirq = &pdcnew_ide_dma_lostirq;
343         hwif->ide_dma_timeout = &pdcnew_ide_dma_timeout;
344         if (!(hwif->udma_four))
345                 hwif->udma_four = (pdcnew_new_cable_detect(hwif)) ? 0 : 1;
346         if (!noautodma)
347                 hwif->autodma = 1;
348         hwif->drives[0].autodma = hwif->drives[1].autodma = hwif->autodma;
349 #if PDC202_DEBUG_CABLE
350         printk(KERN_DEBUG "%s: %s-pin cable\n",
351                 hwif->name, hwif->udma_four ? "80" : "40");
352 #endif /* PDC202_DEBUG_CABLE */
353 }
354
355 static int __devinit init_setup_pdcnew(struct pci_dev *dev, ide_pci_device_t *d)
356 {
357         return ide_setup_pci_device(dev, d);
358 }
359
360 static int __devinit init_setup_pdc20270(struct pci_dev *dev,
361                                          ide_pci_device_t *d)
362 {
363         struct pci_dev *findev = NULL;
364
365         if ((dev->bus->self &&
366              dev->bus->self->vendor == PCI_VENDOR_ID_DEC) &&
367             (dev->bus->self->device == PCI_DEVICE_ID_DEC_21150)) {
368                 if (PCI_SLOT(dev->devfn) & 2)
369                         return -ENODEV;
370                 d->extra = 0;
371                 while ((findev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, findev)) != NULL) {
372                         if ((findev->vendor == dev->vendor) &&
373                             (findev->device == dev->device) &&
374                             (PCI_SLOT(findev->devfn) & 2)) {
375                                 if (findev->irq != dev->irq) {
376                                         findev->irq = dev->irq;
377                                 }
378                                 return ide_setup_pci_devices(dev, findev, d);
379                         }
380                 }
381         }
382         return ide_setup_pci_device(dev, d);
383 }
384
385 static int __devinit init_setup_pdc20276(struct pci_dev *dev,
386                                          ide_pci_device_t *d)
387 {
388         if ((dev->bus->self) &&
389             (dev->bus->self->vendor == PCI_VENDOR_ID_INTEL) &&
390             ((dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960) ||
391              (dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960RM))) {
392                 printk(KERN_INFO "ide: Skipping Promise PDC20276 "
393                         "attached to I2O RAID controller.\n");
394                 return -ENODEV;
395         }
396         return ide_setup_pci_device(dev, d);
397 }
398
399 static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
400         {       /* 0 */
401                 .name           = "PDC20268",
402                 .init_setup     = init_setup_pdcnew,
403                 .init_chipset   = init_chipset_pdcnew,
404                 .init_hwif      = init_hwif_pdc202new,
405                 .channels       = 2,
406                 .autodma        = AUTODMA,
407                 .bootable       = OFF_BOARD,
408         },{     /* 1 */
409                 .name           = "PDC20269",
410                 .init_setup     = init_setup_pdcnew,
411                 .init_chipset   = init_chipset_pdcnew,
412                 .init_hwif      = init_hwif_pdc202new,
413                 .channels       = 2,
414                 .autodma        = AUTODMA,
415                 .bootable       = OFF_BOARD,
416         },{     /* 2 */
417                 .name           = "PDC20270",
418                 .init_setup     = init_setup_pdc20270,
419                 .init_chipset   = init_chipset_pdcnew,
420                 .init_hwif      = init_hwif_pdc202new,
421                 .channels       = 2,
422                 .autodma        = AUTODMA,
423 #ifndef CONFIG_PDC202XX_FORCE
424                 .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
425 #endif
426                 .bootable       = OFF_BOARD,
427         },{     /* 3 */
428                 .name           = "PDC20271",
429                 .init_setup     = init_setup_pdcnew,
430                 .init_chipset   = init_chipset_pdcnew,
431                 .init_hwif      = init_hwif_pdc202new,
432                 .channels       = 2,
433                 .autodma        = AUTODMA,
434                 .bootable       = OFF_BOARD,
435         },{     /* 4 */
436                 .name           = "PDC20275",
437                 .init_setup     = init_setup_pdcnew,
438                 .init_chipset   = init_chipset_pdcnew,
439                 .init_hwif      = init_hwif_pdc202new,
440                 .channels       = 2,
441                 .autodma        = AUTODMA,
442                 .bootable       = OFF_BOARD,
443         },{     /* 5 */
444                 .name           = "PDC20276",
445                 .init_setup     = init_setup_pdc20276,
446                 .init_chipset   = init_chipset_pdcnew,
447                 .init_hwif      = init_hwif_pdc202new,
448                 .channels       = 2,
449                 .autodma        = AUTODMA,
450 #ifndef CONFIG_PDC202XX_FORCE
451                 .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
452 #endif
453                 .bootable       = OFF_BOARD,
454         },{     /* 6 */
455                 .name           = "PDC20277",
456                 .init_setup     = init_setup_pdcnew,
457                 .init_chipset   = init_chipset_pdcnew,
458                 .init_hwif      = init_hwif_pdc202new,
459                 .channels       = 2,
460                 .autodma        = AUTODMA,
461                 .bootable       = OFF_BOARD,
462         }
463 };
464
465 /**
466  *      pdc202new_init_one      -       called when a pdc202xx is found
467  *      @dev: the pdc202new device
468  *      @id: the matching pci id
469  *
470  *      Called when the PCI registration layer (or the IDE initialization)
471  *      finds a device matching our IDE device tables.
472  */
473  
474 static int __devinit pdc202new_init_one(struct pci_dev *dev, const struct pci_device_id *id)
475 {
476         ide_pci_device_t *d = &pdcnew_chipsets[id->driver_data];
477
478         return d->init_setup(dev, d);
479 }
480
481 static struct pci_device_id pdc202new_pci_tbl[] = {
482         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20268, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
483         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20269, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
484         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20270, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
485         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20271, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
486         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20275, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
487         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20276, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
488         { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20277, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6},
489         { 0, },
490 };
491 MODULE_DEVICE_TABLE(pci, pdc202new_pci_tbl);
492
493 static struct pci_driver driver = {
494         .name           = "Promise_IDE",
495         .id_table       = pdc202new_pci_tbl,
496         .probe          = pdc202new_init_one,
497 };
498
499 static int pdc202new_ide_init(void)
500 {
501         return ide_pci_register_driver(&driver);
502 }
503
504 module_init(pdc202new_ide_init);
505
506 MODULE_AUTHOR("Andre Hedrick, Frank Tiernan");
507 MODULE_DESCRIPTION("PCI driver module for Promise PDC20268 and higher");
508 MODULE_LICENSE("GPL");