[PATCH] 2.5.7 IDE 27
[opensuse:kernel.git] / drivers / ide / sl82c105.c
1 /*
2  * linux/drivers/ide/sl82c105.c
3  *
4  * SL82C105/Winbond 553 IDE driver
5  *
6  * Maintainer unknown.
7  *
8  * Drive tuning added from Rebel.com's kernel sources
9  *  -- Russell King (15/11/98) linux@arm.linux.org.uk
10  */
11 #include <linux/types.h>
12 #include <linux/kernel.h>
13 #include <linux/timer.h>
14 #include <linux/mm.h>
15 #include <linux/ioport.h>
16 #include <linux/interrupt.h>
17 #include <linux/blkdev.h>
18 #include <linux/hdreg.h>
19 #include <linux/pci.h>
20 #include <linux/ide.h>
21
22 #include <asm/io.h>
23 #include <asm/dma.h>
24
25 #include "ata-timing.h"
26
27 extern char *ide_xfer_verbose (byte xfer_rate);
28
29 /*
30  * Convert a PIO mode and cycle time to the required on/off
31  * times for the interface.  This has protection against run-away
32  * timings.
33  */
34 static unsigned int get_timing_sl82c105(struct ata_timing *t)
35 {
36         unsigned int cmd_on;
37         unsigned int cmd_off;
38
39         cmd_on = (t->active + 29) / 30;
40         cmd_off = (t->cycle - 30 * cmd_on + 29) / 30;
41
42         if (cmd_on > 32)
43                 cmd_on = 32;
44         if (cmd_on == 0)
45                 cmd_on = 1;
46
47         if (cmd_off > 32)
48                 cmd_off = 32;
49         if (cmd_off == 0)
50                 cmd_off = 1;
51
52         return (cmd_on - 1) << 8 | (cmd_off - 1) | ((t->mode > XFER_PIO_2) ? 0x40 : 0x00);
53 }
54
55 /*
56  * Configure the drive and chipset for PIO
57  */
58 static void config_for_pio(ide_drive_t *drive, int pio, int report)
59 {
60         struct ata_channel *hwif = drive->channel;
61         struct pci_dev *dev = hwif->pci_dev;
62         struct ata_timing *t;
63         unsigned short drv_ctrl = 0x909;
64         unsigned int xfer_mode, reg;
65
66         reg = (hwif->unit ? 0x4c : 0x44) + (drive->select.b.unit ? 4 : 0);
67
68         if (pio == 255)
69                 xfer_mode = ata_timing_mode(drive, XFER_PIO | XFER_EPIO);
70         else
71                 xfer_mode = XFER_PIO_0 + min_t(byte, pio, 4);
72
73         t = ata_timing_data(xfer_mode);
74
75         if (ide_config_drive_speed(drive, xfer_mode) == 0)
76                 drv_ctrl = get_timing_sl82c105(t);
77
78         if (drive->using_dma == 0) {
79                 /*
80                  * If we are actually using MW DMA, then we can not
81                  * reprogram the interface drive control register.
82                  */
83                 pci_write_config_word(dev, reg, drv_ctrl);
84                 pci_read_config_word(dev, reg, &drv_ctrl);
85
86                 if (report) {
87                         printk("%s: selected %s (%dns) (%04X)\n", drive->name,
88                                ide_xfer_verbose(xfer_mode), t->cycle, drv_ctrl);
89                 }
90         }
91 }
92
93 /*
94  * Configure the drive and the chipset for DMA
95  */
96 static int config_for_dma(ide_drive_t *drive)
97 {
98         struct ata_channel *hwif = drive->channel;
99         struct pci_dev *dev = hwif->pci_dev;
100         unsigned short drv_ctrl = 0x909;
101         unsigned int reg;
102
103         reg = (hwif->unit ? 0x4c : 0x44) + (drive->select.b.unit ? 4 : 0);
104
105         if (ide_config_drive_speed(drive, XFER_MW_DMA_2) == 0)
106                 drv_ctrl = 0x0240;
107
108         pci_write_config_word(dev, reg, drv_ctrl);
109
110         return 0;
111 }
112
113 /*
114  * Check to see if the drive and
115  * chipset is capable of DMA mode
116  */
117 static int sl82c105_check_drive(ide_drive_t *drive)
118 {
119         ide_dma_action_t dma_func = ide_dma_off_quietly;
120
121         do {
122                 struct hd_driveid *id = drive->id;
123                 struct ata_channel *hwif = drive->channel;
124
125                 if (!hwif->autodma)
126                         break;
127
128                 if (!id || !(id->capability & 1))
129                         break;
130
131                 /* Consult the list of known "bad" drives */
132                 if (ide_dmaproc(ide_dma_bad_drive, drive)) {
133                         dma_func = ide_dma_off;
134                         break;
135                 }
136
137                 if (id->field_valid & 2) {
138                         if  (id->dma_mword & 7 || id->dma_1word & 7)
139                                 dma_func = ide_dma_on;
140                         break;
141                 }
142
143                 if (ide_dmaproc(ide_dma_good_drive, drive)) {
144                         dma_func = ide_dma_on;
145                         break;
146                 }
147         } while (0);
148
149         return drive->channel->dmaproc(dma_func, drive);
150 }
151
152 /*
153  * Our own dmaproc, only to intercept ide_dma_check
154  */
155 static int sl82c105_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
156 {
157         switch (func) {
158         case ide_dma_check:
159                 return sl82c105_check_drive(drive);
160         case ide_dma_on:
161                 if (config_for_dma(drive))
162                         func = ide_dma_off;
163                 /* fall through */
164         case ide_dma_off_quietly:
165         case ide_dma_off:
166                 config_for_pio(drive, 4, 0);
167                 break;
168         default:
169                 break;
170         }
171         return ide_dmaproc(func, drive);
172 }
173
174 /*
175  * We only deal with PIO mode here - DMA mode 'using_dma' is not
176  * initialised at the point that this function is called.
177  */
178 static void tune_sl82c105(ide_drive_t *drive, byte pio)
179 {
180         config_for_pio(drive, pio, 1);
181
182         /*
183          * We support 32-bit I/O on this interface, and it
184          * doesn't have problems with interrupts.
185          */
186         drive->io_32bit = 1;
187         drive->unmask = 1;
188 }
189
190 /*
191  * Return the revision of the Winbond bridge
192  * which this function is part of.
193  */
194 static unsigned int sl82c105_bridge_revision(struct pci_dev *dev)
195 {
196         struct pci_dev *bridge;
197         unsigned char rev;
198
199         bridge = pci_find_device(PCI_VENDOR_ID_WINBOND, PCI_DEVICE_ID_WINBOND_83C553, NULL);
200
201         /*
202          * If we are part of a Winbond 553
203          */
204         if (!bridge || bridge->class >> 8 != PCI_CLASS_BRIDGE_ISA)
205                 return -1;
206
207         if (bridge->bus != dev->bus ||
208             PCI_SLOT(bridge->devfn) != PCI_SLOT(dev->devfn))
209                 return -1;
210
211         /*
212          * We need to find function 0's revision, not function 1
213          */
214         pci_read_config_byte(bridge, PCI_REVISION_ID, &rev);
215
216         return rev;
217 }
218
219 /*
220  * Enable the PCI device
221  */
222 unsigned int __init pci_init_sl82c105(struct pci_dev *dev)
223 {
224         unsigned char ctrl_stat;
225
226         /*
227          * Enable the ports
228          */
229         pci_read_config_byte(dev, 0x40, &ctrl_stat);
230         pci_write_config_byte(dev, 0x40, ctrl_stat | 0x33);
231
232         return dev->irq;
233 }
234
235 void __init dma_init_sl82c105(struct ata_channel *hwif, unsigned long dma_base)
236 {
237         unsigned int rev;
238         byte dma_state;
239
240         dma_state = inb(dma_base + 2);
241         rev = sl82c105_bridge_revision(hwif->pci_dev);
242         if (rev <= 5) {
243                 hwif->autodma = 0;
244                 hwif->drives[0].autotune = 1;
245                 hwif->drives[1].autotune = 1;
246                 printk("    %s: Winbond 553 bridge revision %d, BM-DMA disabled\n",
247                        hwif->name, rev);
248                 dma_state &= ~0x60;
249         } else {
250                 dma_state |= 0x60;
251                 hwif->autodma = 1;
252         }
253         outb(dma_state, dma_base + 2);
254
255         hwif->dmaproc = NULL;
256         ide_setup_dma(hwif, dma_base, 8);
257         if (hwif->dmaproc)
258                 hwif->dmaproc = sl82c105_dmaproc;
259 }
260
261 /*
262  * Initialise the chip
263  */
264 void __init ide_init_sl82c105(struct ata_channel *hwif)
265 {
266         hwif->tuneproc = tune_sl82c105;
267 }
268