[PATCH] 2.5.7 IDE 27
[opensuse:kernel.git] / drivers / ide / sis5513.c
1 /*
2  * linux/drivers/ide/sis5513.c          Version 0.13    March 4, 2002
3  *
4  * Copyright (C) 1999-2000      Andre Hedrick <andre@linux-ide.org>
5  * Copyright (C) 2002           Lionel Bouton <Lionel.Bouton@inet6.fr>, Maintainer
6  * May be copied or modified under the terms of the GNU General Public License
7  *
8 */
9
10 /* Thanks :
11  * For direct support and hardware : SiS Taiwan.
12  * For ATA100 support advice       : Daniela Engert.
13  * For checking code correctness, providing patches :
14  * John Fremlin, Manfred Spraul
15  */
16
17 /*
18  * Original tests and design on the SiS620/5513 chipset.
19  * ATA100 tests and design on the SiS735/5513 chipset.
20  * ATA16/33 design from specs
21  */
22
23 /*
24  * TODO:
25  *      - Get ridden of SisHostChipInfo[] completness dependancy.
26  *      - Get ATA-133 datasheets, implement ATA-133 init code.
27  *      - Are there pre-ATA_16 SiS chips ? -> tune init code for them
28  *        or remove ATA_00 define
29  *      - More checks in the config registers (force values instead of
30  *        relying on the BIOS setting them correctly).
31  *      - Further optimisations ?
32  *        . for example ATA66+ regs 0x48 & 0x4A
33  */
34
35 #include <linux/config.h>
36 #include <linux/types.h>
37 #include <linux/kernel.h>
38 #include <linux/delay.h>
39 #include <linux/timer.h>
40 #include <linux/mm.h>
41 #include <linux/ioport.h>
42 #include <linux/blkdev.h>
43 #include <linux/hdreg.h>
44
45 #include <linux/interrupt.h>
46 #include <linux/pci.h>
47 #include <linux/init.h>
48 #include <linux/ide.h>
49
50 #include <asm/io.h>
51 #include <asm/irq.h>
52
53 #include "ata-timing.h"
54
55 // #define DEBUG
56 /* if BROKEN_LEVEL is defined it limits the DMA mode
57    at boot time to its value */
58 // #define BROKEN_LEVEL XFER_SW_DMA_0
59 #define DISPLAY_SIS_TIMINGS
60
61 /* Miscellaneaous flags */
62 #define SIS5513_LATENCY         0x01
63 /* ATA transfer mode capabilities */
64 #define ATA_00          0x00
65 #define ATA_16          0x01
66 #define ATA_33          0x02
67 #define ATA_66          0x03
68 #define ATA_100a        0x04
69 #define ATA_100         0x05
70 #define ATA_133         0x06
71
72 static unsigned char dma_capability = 0x00;
73
74
75 /*
76  * Debug code: following IDE config registers' changes
77  */
78 #ifdef DEBUG
79 /* Copy of IDE Config registers 0x00 -> 0x58
80    Fewer might be used depending on the actual chipset */
81 static unsigned char ide_regs_copy[] = {
82         0x0, 0x0, 0x0, 0x0,
83         0x0, 0x0, 0x0, 0x0,
84         0x0, 0x0, 0x0, 0x0,
85         0x0, 0x0, 0x0, 0x0,
86         0x0, 0x0, 0x0, 0x0,
87         0x0, 0x0, 0x0, 0x0,
88         0x0, 0x0, 0x0, 0x0,
89         0x0, 0x0, 0x0, 0x0,
90         0x0, 0x0, 0x0, 0x0,
91         0x0, 0x0, 0x0, 0x0,
92         0x0, 0x0, 0x0, 0x0,
93         0x0, 0x0, 0x0, 0x0,
94         0x0, 0x0, 0x0, 0x0,
95         0x0, 0x0, 0x0, 0x0,
96         0x0, 0x0, 0x0, 0x0,
97         0x0, 0x0, 0x0, 0x0,
98         0x0, 0x0, 0x0, 0x0,
99         0x0, 0x0, 0x0, 0x0,
100         0x0, 0x0, 0x0, 0x0,
101         0x0, 0x0, 0x0, 0x0,
102         0x0, 0x0, 0x0, 0x0,
103         0x0, 0x0, 0x0, 0x0
104 };
105
106 static byte sis5513_max_config_register(void) {
107         switch(dma_capability) {
108                 case ATA_00:
109                 case ATA_16:    return 0x4f;
110                 case ATA_33:    return 0x52;
111                 case ATA_66:
112                 case ATA_100a:
113                 case ATA_100:
114                 case ATA_133:
115                 default:        return 0x57;
116         }
117 }
118
119 /* Read config registers, print differences from previous read */
120 static void sis5513_load_verify_registers(struct pci_dev* dev, char* info) {
121         int i;
122         byte reg_val;
123         byte changed=0;
124         byte max = sis5513_max_config_register();
125
126         printk("SIS5513: %s, changed registers:\n", info);
127         for(i=0; i<=max; i++) {
128                 pci_read_config_byte(dev, i, &reg_val);
129                 if (reg_val != ide_regs_copy[i]) {
130                         printk("%0#x: %0#x -> %0#x\n",
131                                i, ide_regs_copy[i], reg_val);
132                         ide_regs_copy[i]=reg_val;
133                         changed=1;
134                 }
135         }
136
137         if (!changed) {
138                 printk("none\n");
139         }
140 }
141
142 /* Load config registers, no printing */
143 static void sis5513_load_registers(struct pci_dev* dev) {
144         int i;
145         byte max = sis5513_max_config_register();
146
147         for(i=0; i<=max; i++) {
148                 pci_read_config_byte(dev, i, &(ide_regs_copy[i]));
149         }
150 }
151
152 /* Print a register */
153 static void sis5513_print_register(int reg) {
154         printk(" %0#x:%0#x", reg, ide_regs_copy[reg]);
155 }
156
157 /* Print valuable registers */
158 static void sis5513_print_registers(struct pci_dev* dev, char* marker) {
159         int i;
160         byte max = sis5513_max_config_register();
161
162         sis5513_load_registers(dev);
163         printk("SIS5513 %s\n", marker);
164         printk("SIS5513 dump:");
165         for(i=0x00; i<0x40; i++) {
166                 if ((i % 0x10)==0) printk("\n             ");
167                 sis5513_print_register(i);
168         }
169         for(; i<49; i++) {
170                 sis5513_print_register(i);
171         }
172         printk("\n             ");
173
174         for(; i<=max; i++) {
175                 sis5513_print_register(i);
176         }
177         printk("\n");
178 }
179 #endif
180
181
182 /*
183  * Devices supported
184  */
185 static const struct {
186         const char *name;
187         unsigned short host_id;
188         unsigned char dma_capability;
189         unsigned char flags;
190 } SiSHostChipInfo[] = {
191         { "SiS750",     PCI_DEVICE_ID_SI_750,   ATA_100,        SIS5513_LATENCY },
192         { "SiS745",     PCI_DEVICE_ID_SI_745,   ATA_100,        SIS5513_LATENCY },
193         { "SiS740",     PCI_DEVICE_ID_SI_740,   ATA_100,        SIS5513_LATENCY },
194         { "SiS735",     PCI_DEVICE_ID_SI_735,   ATA_100,        SIS5513_LATENCY },
195         { "SiS730",     PCI_DEVICE_ID_SI_730,   ATA_100a,       SIS5513_LATENCY },
196         { "SiS650",     PCI_DEVICE_ID_SI_650,   ATA_100,        SIS5513_LATENCY },
197         { "SiS645",     PCI_DEVICE_ID_SI_645,   ATA_100,        SIS5513_LATENCY },
198         { "SiS635",     PCI_DEVICE_ID_SI_635,   ATA_100,        SIS5513_LATENCY },
199         { "SiS640",     PCI_DEVICE_ID_SI_640,   ATA_66,         SIS5513_LATENCY },
200         { "SiS630",     PCI_DEVICE_ID_SI_630,   ATA_66,         SIS5513_LATENCY },
201         { "SiS620",     PCI_DEVICE_ID_SI_620,   ATA_66,         SIS5513_LATENCY },
202         { "SiS540",     PCI_DEVICE_ID_SI_540,   ATA_66,         0},
203         { "SiS530",     PCI_DEVICE_ID_SI_530,   ATA_66,         0},
204         { "SiS5600",    PCI_DEVICE_ID_SI_5600,  ATA_33,         0},
205         { "SiS5598",    PCI_DEVICE_ID_SI_5598,  ATA_33,         0},
206         { "SiS5597",    PCI_DEVICE_ID_SI_5597,  ATA_33,         0},
207         { "SiS5591",    PCI_DEVICE_ID_SI_5591,  ATA_33,         0},
208         { "SiS5513",    PCI_DEVICE_ID_SI_5513,  ATA_16,         0},
209         { "SiS5511",    PCI_DEVICE_ID_SI_5511,  ATA_16,         0},
210 };
211
212 /* Cycle time bits and values vary accross chip dma capabilities
213    These three arrays hold the register layout and the values to set.
214    Indexed by dma_capability and (dma_mode - XFER_UDMA_0) */
215 static byte cycle_time_offset[] = {0,0,5,4,4,0,0};
216 static byte cycle_time_range[] = {0,0,2,3,3,4,4};
217 static byte cycle_time_value[][XFER_UDMA_5 - XFER_UDMA_0 + 1] = {
218         {0,0,0,0,0,0}, /* no udma */
219         {0,0,0,0,0,0}, /* no udma */
220         {3,2,1,0,0,0},
221         {7,5,3,2,1,0},
222         {7,5,3,2,1,0},
223         {11,7,5,4,2,1},
224         {0,0,0,0,0,0} /* not yet known, ask SiS */
225 };
226
227 static struct pci_dev *host_dev = NULL;
228
229
230 /*
231  * Printing configuration
232  */
233 #if defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS)
234 #include <linux/stat.h>
235 #include <linux/proc_fs.h>
236
237 static int sis_get_info(char *, char **, off_t, int);
238 extern int (*sis_display_info)(char *, char **, off_t, int); /* ide-proc.c */
239 static struct pci_dev *bmide_dev;
240
241 static char* cable_type[] = {
242         "80 pins",
243         "40 pins"
244 };
245
246 static char* recovery_time[] ={
247         "12 PCICLK", "1 PCICLK",
248         "2 PCICLK", "3 PCICLK",
249         "4 PCICLK", "5 PCICLCK",
250         "6 PCICLK", "7 PCICLCK",
251         "8 PCICLK", "9 PCICLCK",
252         "10 PCICLK", "11 PCICLK",
253         "13 PCICLK", "14 PCICLK",
254         "15 PCICLK", "15 PCICLK"
255 };
256
257 static char* active_time[] = {
258         "8 PCICLK", "1 PCICLCK",
259         "2 PCICLK", "3 PCICLK",
260         "4 PCICLK", "5 PCICLK",
261         "6 PCICLK", "12 PCICLK"
262 };
263
264 static char* cycle_time[] = {
265         "Reserved", "2 CLK",
266         "3 CLK", "4 CLK",
267         "5 CLK", "6 CLK",
268         "7 CLK", "8 CLK",
269         "9 CLK", "10 CLK",
270         "11 CLK", "12 CLK",
271         "Reserved", "Reserved",
272         "Reserved", "Reserved"
273 };
274
275 /* Generic add master or slave info function */
276 static char* get_drives_info (char *buffer, byte pos)
277 {
278         byte reg00, reg01, reg10, reg11; /* timing registers */
279         char* p = buffer;
280
281 /* Postwrite/Prefetch */
282         pci_read_config_byte(bmide_dev, 0x4b, &reg00);
283         p += sprintf(p, "Drive %d:        Postwrite %s \t \t Postwrite %s\n",
284                      pos, (reg00 & (0x10 << pos)) ? "Enabled" : "Disabled",
285                      (reg00 & (0x40 << pos)) ? "Enabled" : "Disabled");
286         p += sprintf(p, "                Prefetch  %s \t \t Prefetch  %s\n",
287                      (reg00 & (0x01 << pos)) ? "Enabled" : "Disabled",
288                      (reg00 & (0x04 << pos)) ? "Enabled" : "Disabled");
289
290         pci_read_config_byte(bmide_dev, 0x40+2*pos, &reg00);
291         pci_read_config_byte(bmide_dev, 0x41+2*pos, &reg01);
292         pci_read_config_byte(bmide_dev, 0x44+2*pos, &reg10);
293         pci_read_config_byte(bmide_dev, 0x45+2*pos, &reg11);
294
295 /* UDMA */
296         if (dma_capability >= ATA_33) {
297                 p += sprintf(p, "                UDMA %s \t \t \t UDMA %s\n",
298                              (reg01 & 0x80)  ? "Enabled" : "Disabled",
299                              (reg11 & 0x80) ? "Enabled" : "Disabled");
300
301                 p += sprintf(p, "                UDMA Cycle Time    ");
302                 switch(dma_capability) {
303                         case ATA_33:    p += sprintf(p, cycle_time[(reg01 & 0x60) >> 5]); break;
304                         case ATA_66:
305                         case ATA_100a:  p += sprintf(p, cycle_time[(reg01 & 0x70) >> 4]); break;
306                         case ATA_100:   p += sprintf(p, cycle_time[reg01 & 0x0F]); break;
307                         case ATA_133:
308                         default:        p += sprintf(p, "133+ ?"); break;
309                 }
310                 p += sprintf(p, " \t UDMA Cycle Time    ");
311                 switch(dma_capability) {
312                         case ATA_33:    p += sprintf(p, cycle_time[(reg11 & 0x60) >> 5]); break;
313                         case ATA_66:
314                         case ATA_100a:  p += sprintf(p, cycle_time[(reg11 & 0x70) >> 4]); break;
315                         case ATA_100:   p += sprintf(p, cycle_time[reg11 & 0x0F]); break;
316                         case ATA_133:
317                         default:        p += sprintf(p, "133+ ?"); break;
318                 }
319                 p += sprintf(p, "\n");
320         }
321
322 /* Data Active */
323         p += sprintf(p, "                Data Active Time   ");
324         switch(dma_capability) {
325                 case ATA_00:
326                 case ATA_16: /* confirmed */
327                 case ATA_33:
328                 case ATA_66:
329                 case ATA_100a: p += sprintf(p, active_time[reg01 & 0x07]); break;
330                 case ATA_100: p += sprintf(p, active_time[(reg00 & 0x70) >> 4]); break;
331                 case ATA_133:
332                 default: p += sprintf(p, "133+ ?"); break;
333         }
334         p += sprintf(p, " \t Data Active Time   ");
335         switch(dma_capability) {
336                 case ATA_00:
337                 case ATA_16:
338                 case ATA_33:
339                 case ATA_66:
340                 case ATA_100a: p += sprintf(p, active_time[reg11 & 0x07]); break;
341                 case ATA_100: p += sprintf(p, active_time[(reg10 & 0x70) >> 4]); break;
342                 case ATA_133:
343                 default: p += sprintf(p, "133+ ?"); break;
344         }
345         p += sprintf(p, "\n");
346
347 /* Data Recovery */
348         /* warning: may need (reg&0x07) for pre ATA66 chips */
349         p += sprintf(p, "                Data Recovery Time %s \t Data Recovery Time %s\n",
350                      recovery_time[reg00 & 0x0f], recovery_time[reg10 & 0x0f]);
351
352         return p;
353 }
354
355 static char* get_masters_info(char* buffer)
356 {
357         return get_drives_info(buffer, 0);
358 }
359
360 static char* get_slaves_info(char* buffer)
361 {
362         return get_drives_info(buffer, 1);
363 }
364
365 /* Main get_info, called on /proc/ide/sis reads */
366 static int sis_get_info (char *buffer, char **addr, off_t offset, int count)
367 {
368         char *p = buffer;
369         byte reg;
370         u16 reg2, reg3;
371
372         p += sprintf(p, "\nSiS 5513 ");
373         switch(dma_capability) {
374                 case ATA_00: p += sprintf(p, "Unknown???"); break;
375                 case ATA_16: p += sprintf(p, "DMA 16"); break;
376                 case ATA_33: p += sprintf(p, "Ultra 33"); break;
377                 case ATA_66: p += sprintf(p, "Ultra 66"); break;
378                 case ATA_100a:
379                 case ATA_100: p += sprintf(p, "Ultra 100"); break;
380                 case ATA_133:
381                 default: p+= sprintf(p, "Ultra 133+"); break;
382         }
383         p += sprintf(p, " chipset\n");
384         p += sprintf(p, "--------------- Primary Channel ---------------- Secondary Channel -------------\n");
385
386 /* Status */
387         pci_read_config_byte(bmide_dev, 0x4a, &reg);
388         p += sprintf(p, "Channel Status: ");
389         if (dma_capability < ATA_66) {
390                 p += sprintf(p, "%s \t \t \t \t %s\n",
391                              (reg & 0x04) ? "On" : "Off",
392                              (reg & 0x02) ? "On" : "Off");
393         } else {
394                 p += sprintf(p, "%s \t \t \t \t %s \n",
395                              (reg & 0x02) ? "On" : "Off",
396                              (reg & 0x04) ? "On" : "Off");
397         }
398
399 /* Operation Mode */
400         pci_read_config_byte(bmide_dev, 0x09, &reg);
401         p += sprintf(p, "Operation Mode: %s \t \t \t %s \n",
402                      (reg & 0x01) ? "Native" : "Compatible",
403                      (reg & 0x04) ? "Native" : "Compatible");
404
405 /* 80-pin cable ? */
406         if (dma_capability > ATA_33) {
407                 pci_read_config_byte(bmide_dev, 0x48, &reg);
408                 p += sprintf(p, "Cable Type:     %s \t \t \t %s\n",
409                              (reg & 0x10) ? cable_type[1] : cable_type[0],
410                              (reg & 0x20) ? cable_type[1] : cable_type[0]);
411         }
412
413 /* Prefetch Count */
414         pci_read_config_word(bmide_dev, 0x4c, &reg2);
415         pci_read_config_word(bmide_dev, 0x4e, &reg3);
416         p += sprintf(p, "Prefetch Count: %d \t \t \t \t %d\n",
417                      reg2, reg3);
418
419         p = get_masters_info(p);
420         p = get_slaves_info(p);
421
422         return p-buffer;
423 }
424 #endif /* defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS) */
425
426
427 byte sis_proc = 0;
428 extern char *ide_xfer_verbose (byte xfer_rate);
429
430
431 /*
432  * Configuration functions
433  */
434 /* Enables per-drive prefetch and postwrite */
435 static void config_drive_art_rwp (ide_drive_t *drive)
436 {
437         struct ata_channel *hwif = drive->channel;
438         struct pci_dev *dev     = hwif->pci_dev;
439
440         byte reg4bh             = 0;
441         byte rw_prefetch        = (0x11 << drive->dn);
442
443 #ifdef DEBUG
444         printk("SIS5513: config_drive_art_rwp, drive %d\n", drive->dn);
445         sis5513_load_verify_registers(dev, "config_drive_art_rwp start");
446 #endif
447
448         if (drive->type != ATA_DISK)
449                 return;
450         pci_read_config_byte(dev, 0x4b, &reg4bh);
451
452         if ((reg4bh & rw_prefetch) != rw_prefetch)
453                 pci_write_config_byte(dev, 0x4b, reg4bh|rw_prefetch);
454 #ifdef DEBUG
455         sis5513_load_verify_registers(dev, "config_drive_art_rwp end");
456 #endif
457 }
458
459
460 /* Set per-drive active and recovery time */
461 static void config_art_rwp_pio (ide_drive_t *drive, byte pio)
462 {
463         struct ata_channel *hwif = drive->channel;
464         struct pci_dev *dev     = hwif->pci_dev;
465
466         byte                    timing, drive_pci, test1, test2;
467
468         unsigned short eide_pio_timing[6] = {600, 390, 240, 180, 120, 90};
469         unsigned short xfer_pio = drive->id->eide_pio_modes;
470
471 #ifdef DEBUG
472         sis5513_load_verify_registers(dev, "config_drive_art_rwp_pio start");
473 #endif
474
475         config_drive_art_rwp(drive);
476
477         if (pio == 255)
478                 pio = ata_timing_mode(drive, XFER_PIO | XFER_EPIO) - XFER_PIO_0;
479
480         if (xfer_pio> 4)
481                 xfer_pio = 0;
482
483         if (drive->id->eide_pio_iordy > 0) {
484                 for (xfer_pio = 5;
485                         (xfer_pio > 0) &&
486                         (drive->id->eide_pio_iordy > eide_pio_timing[xfer_pio]);
487                         xfer_pio--);
488         } else {
489                 xfer_pio = (drive->id->eide_pio_modes & 4) ? 0x05 :
490                            (drive->id->eide_pio_modes & 2) ? 0x04 :
491                            (drive->id->eide_pio_modes & 1) ? 0x03 : xfer_pio;
492         }
493
494         timing = (xfer_pio >= pio) ? xfer_pio : pio;
495
496 #ifdef DEBUG
497         printk("SIS5513: config_drive_art_rwp_pio, drive %d, pio %d, timing %d\n",
498                drive->dn, pio, timing);
499 #endif
500
501         switch(drive->dn) {
502                 case 0:         drive_pci = 0x40; break;
503                 case 1:         drive_pci = 0x42; break;
504                 case 2:         drive_pci = 0x44; break;
505                 case 3:         drive_pci = 0x46; break;
506                 default:        return;
507         }
508
509         /* register layout changed with newer ATA100 chips */
510         if (dma_capability < ATA_100) {
511                 pci_read_config_byte(dev, drive_pci, &test1);
512                 pci_read_config_byte(dev, drive_pci+1, &test2);
513
514                 /* Clear active and recovery timings */
515                 test1 &= ~0x0F;
516                 test2 &= ~0x07;
517
518                 switch(timing) {
519                         case 4:         test1 |= 0x01; test2 |= 0x03; break;
520                         case 3:         test1 |= 0x03; test2 |= 0x03; break;
521                         case 2:         test1 |= 0x04; test2 |= 0x04; break;
522                         case 1:         test1 |= 0x07; test2 |= 0x06; break;
523                         default:        break;
524                 }
525                 pci_write_config_byte(dev, drive_pci, test1);
526                 pci_write_config_byte(dev, drive_pci+1, test2);
527         } else {
528                 switch(timing) { /*   active  recovery
529                                           v     v */
530                         case 4:         test1 = 0x30|0x01; break;
531                         case 3:         test1 = 0x30|0x03; break;
532                         case 2:         test1 = 0x40|0x04; break;
533                         case 1:         test1 = 0x60|0x07; break;
534                         default:        break;
535                 }
536                 pci_write_config_byte(dev, drive_pci, test1);
537         }
538
539 #ifdef DEBUG
540         sis5513_load_verify_registers(dev, "config_drive_art_rwp_pio start");
541 #endif
542 }
543
544 static int config_chipset_for_pio (ide_drive_t *drive, byte pio)
545 {
546         byte speed;
547
548         switch(pio) {
549                 case 4:         speed = XFER_PIO_4; break;
550                 case 3:         speed = XFER_PIO_3; break;
551                 case 2:         speed = XFER_PIO_2; break;
552                 case 1:         speed = XFER_PIO_1; break;
553                 default:        speed = XFER_PIO_0; break;
554         }
555
556         config_art_rwp_pio(drive, pio);
557         drive->current_speed = speed;
558         return ide_config_drive_speed(drive, speed);
559 }
560
561 static int sis5513_tune_chipset (ide_drive_t *drive, byte speed)
562 {
563         struct ata_channel *hwif = drive->channel;
564         struct pci_dev *dev     = hwif->pci_dev;
565
566         byte                    drive_pci, reg;
567
568 #ifdef DEBUG
569         sis5513_load_verify_registers(dev, "sis5513_tune_chipset start");
570         printk("SIS5513: sis5513_tune_chipset, drive %d, speed %d\n",
571                drive->dn, speed);
572 #endif
573         switch(drive->dn) {
574                 case 0:         drive_pci = 0x40; break;
575                 case 1:         drive_pci = 0x42; break;
576                 case 2:         drive_pci = 0x44; break;
577                 case 3:         drive_pci = 0x46; break;
578                 default:        return ide_dma_off;
579         }
580
581 #ifdef BROKEN_LEVEL
582 #ifdef DEBUG
583         printk("SIS5513: BROKEN_LEVEL activated, speed=%d -> speed=%d\n", speed, BROKEN_LEVEL);
584 #endif
585         if (speed > BROKEN_LEVEL) speed = BROKEN_LEVEL;
586 #endif
587
588         pci_read_config_byte(dev, drive_pci+1, &reg);
589         /* Disable UDMA bit for non UDMA modes on UDMA chips */
590         if ((speed < XFER_UDMA_0) && (dma_capability > ATA_16)) {
591                 reg &= 0x7F;
592                 pci_write_config_byte(dev, drive_pci+1, reg);
593         }
594
595         /* Config chip for mode */
596         switch(speed) {
597 #ifdef CONFIG_BLK_DEV_IDEDMA
598                 case XFER_UDMA_5:
599                 case XFER_UDMA_4:
600                 case XFER_UDMA_3:
601                 case XFER_UDMA_2:
602                 case XFER_UDMA_1:
603                 case XFER_UDMA_0:
604                         /* Force the UDMA bit on if we want to use UDMA */
605                         reg |= 0x80;
606                         /* clean reg cycle time bits */
607                         reg &= ~((0xFF >> (8 - cycle_time_range[dma_capability]))
608                                  << cycle_time_offset[dma_capability]);
609                         /* set reg cycle time bits */
610                         reg |= cycle_time_value[dma_capability-ATA_00][speed-XFER_UDMA_0]
611                                 << cycle_time_offset[dma_capability];
612                         pci_write_config_byte(dev, drive_pci+1, reg);
613                         break;
614                 case XFER_MW_DMA_2:
615                 case XFER_MW_DMA_1:
616                 case XFER_MW_DMA_0:
617                 case XFER_SW_DMA_2:
618                 case XFER_SW_DMA_1:
619                 case XFER_SW_DMA_0:
620                         break;
621 #endif /* CONFIG_BLK_DEV_IDEDMA */
622                 case XFER_PIO_4: return((int) config_chipset_for_pio(drive, 4));
623                 case XFER_PIO_3: return((int) config_chipset_for_pio(drive, 3));
624                 case XFER_PIO_2: return((int) config_chipset_for_pio(drive, 2));
625                 case XFER_PIO_1: return((int) config_chipset_for_pio(drive, 1));
626                 case XFER_PIO_0:
627                 default:         return((int) config_chipset_for_pio(drive, 0));        
628         }
629         drive->current_speed = speed;
630 #ifdef DEBUG
631         sis5513_load_verify_registers(dev, "sis5513_tune_chipset end");
632 #endif
633         return ((int) ide_config_drive_speed(drive, speed));
634 }
635
636 static void sis5513_tune_drive (ide_drive_t *drive, byte pio)
637 {
638         (void) config_chipset_for_pio(drive, pio);
639 }
640
641 #ifdef CONFIG_BLK_DEV_IDEDMA
642 /*
643  * ((id->hw_config & 0x4000|0x2000) && (drive->channel->udma_four))
644  */
645 static int config_chipset_for_dma (ide_drive_t *drive, byte ultra)
646 {
647         struct hd_driveid *id = drive->id;
648         struct ata_channel *hwif = drive->channel;
649
650         byte                    speed = 0;
651
652         byte unit               = (drive->select.b.unit & 0x01);
653         byte udma_66            = eighty_ninty_three(drive);
654
655 #ifdef DEBUG
656         printk("SIS5513: config_chipset_for_dma, drive %d, ultra %d\n",
657                drive->dn, ultra);
658 #endif
659
660         if ((id->dma_ultra & 0x0020) && ultra && udma_66 && (dma_capability >= ATA_100a))
661                 speed = XFER_UDMA_5;
662         else if ((id->dma_ultra & 0x0010) && ultra && udma_66 && (dma_capability >= ATA_66))
663                 speed = XFER_UDMA_4;
664         else if ((id->dma_ultra & 0x0008) && ultra && udma_66 && (dma_capability >= ATA_66))
665                 speed = XFER_UDMA_3;
666         else if ((id->dma_ultra & 0x0004) && ultra && (dma_capability >= ATA_33))
667                 speed = XFER_UDMA_2;
668         else if ((id->dma_ultra & 0x0002) && ultra && (dma_capability >= ATA_33))
669                 speed = XFER_UDMA_1;
670         else if ((id->dma_ultra & 0x0001) && ultra && (dma_capability >= ATA_33))
671                 speed = XFER_UDMA_0;
672         else if (id->dma_mword & 0x0004)
673                 speed = XFER_MW_DMA_2;
674         else if (id->dma_mword & 0x0002)
675                 speed = XFER_MW_DMA_1;
676         else if (id->dma_mword & 0x0001)
677                 speed = XFER_MW_DMA_0;
678         else if (id->dma_1word & 0x0004)
679                 speed = XFER_SW_DMA_2;
680         else if (id->dma_1word & 0x0002)
681                 speed = XFER_SW_DMA_1;
682         else if (id->dma_1word & 0x0001)
683                 speed = XFER_SW_DMA_0;
684         else
685                 return ((int) ide_dma_off_quietly);
686
687         outb(inb(hwif->dma_base+2)|(1<<(5+unit)), hwif->dma_base+2);
688
689         sis5513_tune_chipset(drive, speed);
690
691         return ((int)   ((id->dma_ultra >> 11) & 7) ? ide_dma_on :
692                         ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
693                         ((id->dma_mword >> 8) & 7) ? ide_dma_on :
694                         ((id->dma_1word >> 8) & 7) ? ide_dma_on :
695                                                      ide_dma_off_quietly);
696 }
697
698 static int config_drive_xfer_rate (ide_drive_t *drive)
699 {
700         struct hd_driveid *id           = drive->id;
701         ide_dma_action_t dma_func       = ide_dma_off_quietly;
702
703         if (id && (id->capability & 1) && drive->channel->autodma) {
704                 /* Consult the list of known "bad" drives */
705                 if (ide_dmaproc(ide_dma_bad_drive, drive)) {
706                         dma_func = ide_dma_off;
707                         goto fast_ata_pio;
708                 }
709                 dma_func = ide_dma_off_quietly;
710                 if (id->field_valid & 4) {
711                         if (id->dma_ultra & 0x003F) {
712                                 /* Force if Capable UltraDMA */
713                                 dma_func = config_chipset_for_dma(drive, 1);
714                                 if ((id->field_valid & 2) &&
715                                     (dma_func != ide_dma_on))
716                                         goto try_dma_modes;
717                         }
718                 } else if (id->field_valid & 2) {
719 try_dma_modes:
720                         if ((id->dma_mword & 0x0007) ||
721                             (id->dma_1word & 0x0007)) {
722                                 /* Force if Capable regular DMA modes */
723                                 dma_func = config_chipset_for_dma(drive, 0);
724                                 if (dma_func != ide_dma_on)
725                                         goto no_dma_set;
726                         }
727                 } else if ((ide_dmaproc(ide_dma_good_drive, drive)) &&
728                            (id->eide_dma_time > 150)) {
729                         /* Consult the list of known "good" drives */
730                         dma_func = config_chipset_for_dma(drive, 0);
731                         if (dma_func != ide_dma_on)
732                                 goto no_dma_set;
733                 } else {
734                         goto fast_ata_pio;
735                 }
736         } else if ((id->capability & 8) || (id->field_valid & 2)) {
737 fast_ata_pio:
738                 dma_func = ide_dma_off_quietly;
739 no_dma_set:
740                 (void) config_chipset_for_pio(drive, 5);
741         }
742
743         return drive->channel->dmaproc(dma_func, drive);
744 }
745
746 /* initiates/aborts (U)DMA read/write operations on a drive. */
747 int sis5513_dmaproc (ide_dma_action_t func, ide_drive_t *drive)
748 {
749         switch (func) {
750                 case ide_dma_check:
751                         config_drive_art_rwp(drive);
752                         config_art_rwp_pio(drive, 5);
753                         return config_drive_xfer_rate(drive);
754                 default:
755                         break;
756         }
757         return ide_dmaproc(func, drive);        /* use standard DMA stuff */
758 }
759 #endif /* CONFIG_BLK_DEV_IDEDMA */
760
761 /* Chip detection and general config */
762 unsigned int __init pci_init_sis5513(struct pci_dev *dev)
763 {
764         struct pci_dev *host;
765         int i = 0;
766
767 #ifdef DEBUG
768         sis5513_print_registers(dev, "pci_init_sis5513 start");
769 #endif
770
771         /* Find the chip */
772         for (i = 0; i < ARRAY_SIZE(SiSHostChipInfo) && !host_dev; i++) {
773                 host = pci_find_device (PCI_VENDOR_ID_SI,
774                                         SiSHostChipInfo[i].host_id,
775                                         NULL);
776                 if (!host)
777                         continue;
778
779                 host_dev = host;
780                 dma_capability = SiSHostChipInfo[i].dma_capability;
781                 printk(SiSHostChipInfo[i].name);
782                 printk("\n");
783
784                 if (SiSHostChipInfo[i].flags & SIS5513_LATENCY) {
785                         byte latency = (dma_capability == ATA_100)? 0x80 : 0x10; /* Lacking specs */
786                         pci_write_config_byte(dev, PCI_LATENCY_TIMER, latency);
787                 }
788         }
789
790         /* Make general config ops here
791            1/ tell IDE channels to operate in Compabitility mode only
792            2/ tell old chips to allow per drive IDE timings */
793         if (host_dev) {
794                 byte reg;
795                 switch(dma_capability) {
796                         case ATA_133:
797                         case ATA_100:
798                                 /* Set compatibility bit */
799                                 pci_read_config_byte(dev, 0x49, &reg);
800                                 if (!(reg & 0x01)) {
801                                         pci_write_config_byte(dev, 0x49, reg|0x01);
802                                 }
803                                 break;
804                         case ATA_100a:
805                         case ATA_66:
806                                 /* On ATA_66 chips the bit was elsewhere */
807                                 pci_read_config_byte(dev, 0x52, &reg);
808                                 if (!(reg & 0x04)) {
809                                         pci_write_config_byte(dev, 0x52, reg|0x04);
810                                 }
811                                 break;
812                         case ATA_33:
813                                 /* On ATA_33 we didn't have a single bit to set */
814                                 pci_read_config_byte(dev, 0x09, &reg);
815                                 if ((reg & 0x0f) != 0x00) {
816                                         pci_write_config_byte(dev, 0x09, reg&0xf0);
817                                 }
818                         case ATA_16:
819                                 /* force per drive recovery and active timings
820                                    needed on ATA_33 and below chips */
821                                 pci_read_config_byte(dev, 0x52, &reg);
822                                 if (!(reg & 0x08)) {
823                                         pci_write_config_byte(dev, 0x52, reg|0x08);
824                                 }
825                                 break;
826                         case ATA_00:
827                         default: break;
828                 }
829
830 #if defined(DISPLAY_SIS_TIMINGS) && defined(CONFIG_PROC_FS)
831                 if (!sis_proc) {
832                         sis_proc = 1;
833                         bmide_dev = dev;
834                         sis_display_info = &sis_get_info;
835                 }
836 #endif
837         }
838 #ifdef DEBUG
839         sis5513_load_verify_registers(dev, "pci_init_sis5513 end");
840 #endif
841         return 0;
842 }
843
844 unsigned int __init ata66_sis5513(struct ata_channel *hwif)
845 {
846         byte reg48h = 0, ata66 = 0;
847         byte mask = hwif->unit ? 0x20 : 0x10;
848         pci_read_config_byte(hwif->pci_dev, 0x48, &reg48h);
849
850         if (dma_capability >= ATA_66) {
851                 ata66 = (reg48h & mask) ? 0 : 1;
852         }
853         return ata66;
854 }
855
856 void __init ide_init_sis5513(struct ata_channel *hwif)
857 {
858
859         hwif->irq = hwif->unit ? 15 : 14;
860
861         hwif->tuneproc = &sis5513_tune_drive;
862         hwif->speedproc = &sis5513_tune_chipset;
863
864         if (!(hwif->dma_base))
865                 return;
866
867         if (host_dev) {
868 #ifdef CONFIG_BLK_DEV_IDEDMA
869                 if (dma_capability > ATA_16) {
870                         hwif->autodma = noautodma ? 0 : 1;
871                         hwif->highmem = 1;
872                         hwif->dmaproc = &sis5513_dmaproc;
873                 } else {
874 #endif
875                         hwif->autodma = 0;
876 #ifdef CONFIG_BLK_DEV_IDEDMA
877                 }
878 #endif
879         }
880         return;
881 }