[PATCH] 2.5.17 IDE 70
[opensuse:kernel.git] / drivers / ide / it8172.c
1 /*
2  *
3  * BRIEF MODULE DESCRIPTION
4  *      IT8172 IDE controller support
5  *
6  * Copyright 2000 MontaVista Software Inc.
7  * Author: MontaVista Software, Inc.
8  *              stevel@mvista.com or source@mvista.com
9  *
10  *  This program is free software; you can redistribute  it and/or modify it
11  *  under  the terms of  the GNU General  Public License as published by the
12  *  Free Software Foundation;  either version 2 of the  License, or (at your
13  *  option) any later version.
14  *
15  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
16  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
17  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
18  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
19  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
21  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
22  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
23  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  *  You should have received a copy of the  GNU General Public License along
27  *  with this program; if not, write  to the Free Software Foundation, Inc.,
28  *  675 Mass Ave, Cambridge, MA 02139, USA.
29  */
30
31 #include <linux/config.h>
32 #include <linux/types.h>
33 #include <linux/kernel.h>
34 #include <linux/ioport.h>
35 #include <linux/pci.h>
36 #include <linux/hdreg.h>
37 #include <linux/ide.h>
38 #include <linux/delay.h>
39 #include <linux/init.h>
40 #include <linux/ide.h>
41
42 #include <asm/io.h>
43 #include <asm/it8172/it8172_int.h>
44
45 #include "ata-timing.h"
46 #include "pcihost.h"
47
48 /*
49  * Prototypes
50  */
51 static void it8172_tune_drive (struct ata_device *drive, byte pio);
52 #if defined(CONFIG_BLK_DEV_IDEDMA) && defined(CONFIG_IT8172_TUNING)
53 static byte it8172_dma_2_pio (byte xfer_rate);
54 static int it8172_tune_chipset (struct ata_device *drive, byte speed);
55 static int it8172_config_chipset_for_dma (struct ata_device *drive);
56 static int it8172_dmaproc(ide_dma_action_t func, struct ata_device *drive);
57 #endif
58 void __init ide_init_it8172(struct ata_channel *channel);
59
60
61 static void it8172_tune_drive (struct ata_device *drive, byte pio)
62 {
63     unsigned long flags;
64     u16 drive_enables;
65     u32 drive_timing;
66     int is_slave        = (&drive->channel->drives[1] == drive);
67     
68         if (pio == 255)
69                 pio = ata_timing_mode(drive, XFER_PIO | XFER_EPIO) - XFER_PIO_0;
70         else
71                 pio = min_t(byte, pio, 4);
72
73     pci_read_config_word(drive->channel->pci_dev, master_port, &master_data);
74     pci_read_config_dword(drive->channel->pci_dev, slave_port, &slave_data);
75
76     /*
77      * FIX! The DIOR/DIOW pulse width and recovery times in port 0x44
78      * are being left at the default values of 8 PCI clocks (242 nsec
79      * for a 33 MHz clock). These can be safely shortened at higher
80      * PIO modes. The DIOR/DIOW pulse width and recovery times only
81      * apply to PIO modes, not to the DMA modes.
82      */
83     
84     /*
85      * Enable port 0x44. The IT8172G spec is confused; it calls
86      * this register the "Slave IDE Timing Register", but in fact,
87      * it controls timing for both master and slave drives.
88      */
89     drive_enables |= 0x4000;
90
91     if (is_slave) {
92         drive_enables &= 0xc006;
93         if (pio > 1)
94             /* enable prefetch and IORDY sample-point */
95             drive_enables |= 0x0060;
96     } else {
97         drive_enables &= 0xc060;
98         if (pio > 1)
99             /* enable prefetch and IORDY sample-point */
100             drive_enables |= 0x0006;
101     }
102
103     save_flags(flags);
104     cli();
105     pci_write_config_word(drive->channel->pci_dev, master_port, master_data);
106     restore_flags(flags);
107 }
108
109 #if defined(CONFIG_BLK_DEV_IDEDMA) && defined(CONFIG_IT8172_TUNING)
110 /*
111  *
112  */
113 static byte it8172_dma_2_pio (byte xfer_rate)
114 {
115     switch(xfer_rate) {
116     case XFER_UDMA_5:
117     case XFER_UDMA_4:
118     case XFER_UDMA_3:
119     case XFER_UDMA_2:
120     case XFER_UDMA_1:
121     case XFER_UDMA_0:
122     case XFER_MW_DMA_2:
123     case XFER_PIO_4:
124         return 4;
125     case XFER_MW_DMA_1:
126     case XFER_PIO_3:
127         return 3;
128     case XFER_SW_DMA_2:
129     case XFER_PIO_2:
130         return 2;
131     case XFER_MW_DMA_0:
132     case XFER_SW_DMA_1:
133     case XFER_SW_DMA_0:
134     case XFER_PIO_1:
135     case XFER_PIO_0:
136     case XFER_PIO_SLOW:
137     default:
138         return 0;
139     }
140 }
141
142 static int it8172_tune_chipset (struct ata_device *drive, byte speed)
143 {
144     struct ata_channel *hwif = drive->channel;
145     struct pci_dev *dev = hwif->pci_dev;
146     int a_speed         = 3 << (drive->dn * 4);
147     int u_flag          = 1 << drive->dn;
148     int u_speed         = 0;
149     int err             = 0;
150     byte reg48, reg4a;
151
152     pci_read_config_byte(dev, 0x48, &reg48);
153     pci_read_config_byte(dev, 0x4a, &reg4a);
154
155     /*
156      * Setting the DMA cycle time to 2 or 3 PCI clocks (60 and 91 nsec
157      * at 33 MHz PCI clock) seems to cause BadCRC errors during DMA
158      * transfers on some drives, even though both numbers meet the minimum
159      * ATAPI-4 spec of 73 and 54 nsec for UDMA 1 and 2 respectively.
160      * So the faster times are just commented out here. The good news is
161      * that the slower cycle time has very little affect on transfer
162      * performance.
163      */
164     
165     switch(speed) {
166     case XFER_UDMA_4:
167     case XFER_UDMA_2:   //u_speed = 2 << (drive->dn * 4); break;
168     case XFER_UDMA_5:
169     case XFER_UDMA_3:
170     case XFER_UDMA_1:   //u_speed = 1 << (drive->dn * 4); break;
171     case XFER_UDMA_0:   u_speed = 0 << (drive->dn * 4); break;
172     case XFER_MW_DMA_2:
173     case XFER_MW_DMA_1:
174     case XFER_MW_DMA_0:
175     case XFER_SW_DMA_2: break;
176     default:            return -1;
177     }
178
179     if (speed >= XFER_UDMA_0) {
180         pci_write_config_byte(dev, 0x48, reg48 | u_flag);
181         reg4a &= ~a_speed;
182         pci_write_config_byte(dev, 0x4a, reg4a | u_speed);
183     } else {
184         pci_write_config_byte(dev, 0x48, reg48 & ~u_flag);
185         pci_write_config_byte(dev, 0x4a, reg4a & ~a_speed);
186     }
187
188     it8172_tune_drive(drive, it8172_dma_2_pio(speed));
189
190     if (!drive->init_speed)
191         drive->init_speed = speed;
192     err = ide_config_drive_speed(drive, speed);
193     drive->current_speed = speed;
194     return err;
195 }
196
197 static int it8172_config_chipset_for_dma(struct ata_device *drive)
198 {
199     struct hd_driveid *id = drive->id;
200     byte speed;
201
202     speed = ata_timing_mode(drive, XFER_PIO | XFER_EPIO | XFER_SWDMA | XFER_MWDMA | XFER_UDMA);
203
204     (void) it8172_tune_chipset(drive, speed);
205
206     return ((int)((id->dma_ultra >> 11) & 7) ? ide_dma_on :
207             ((id->dma_ultra >> 8) & 7) ? ide_dma_on :
208             ((id->dma_mword >> 8) & 7) ? ide_dma_on :
209             ((id->dma_1word >> 8) & 7) ? ide_dma_on :
210             ide_dma_off_quietly);
211 }
212
213 static int it8172_dmaproc(ide_dma_action_t func, struct ata_device *drive)
214 {
215     switch (func) {
216     case ide_dma_check:
217         return ide_dmaproc((ide_dma_action_t)it8172_config_chipset_for_dma(drive),
218                            drive);
219     default :
220         break;
221     }
222     /* Other cases are done by generic IDE-DMA code. */
223     return ide_dmaproc(func, drive);
224 }
225
226 #endif /* defined(CONFIG_BLK_DEV_IDEDMA) && (CONFIG_IT8172_TUNING) */
227
228
229 static unsigned int __init pci_init_it8172 (struct pci_dev *dev)
230 {
231     unsigned char progif;
232
233     /*
234      * Place both IDE interfaces into PCI "native" mode
235      */
236     (void)pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
237     (void)pci_write_config_byte(dev, PCI_CLASS_PROG, progif | 0x05);
238
239     return IT8172_IDE_IRQ;
240 }
241
242
243 static void __init ide_init_it8172(struct ata_channel *hwif)
244 {
245     struct pci_dev* dev = hwif->pci_dev;
246     unsigned long cmdBase, ctrlBase;
247
248     hwif->tuneproc = &it8172_tune_drive;
249     hwif->drives[0].autotune = 1;
250     hwif->drives[1].autotune = 1;
251
252     if (!hwif->dma_base)
253         return;
254
255 #ifndef CONFIG_BLK_DEV_IDEDMA
256     hwif->autodma = 0;
257 #else /* CONFIG_BLK_DEV_IDEDMA */
258 # ifdef CONFIG_IT8172_TUNING
259     hwif->autodma = 1;
260     hwif->dmaproc = &it8172_dmaproc;
261     hwif->speedproc = &it8172_tune_chipset;
262 # endif
263 #endif
264
265     cmdBase = dev->resource[0].start;
266     ctrlBase = dev->resource[1].start;
267
268     ide_init_hwif_ports(&hwif->hw, cmdBase, ctrlBase | 2, NULL);
269     memcpy(hwif->io_ports, hwif->hw.io_ports, sizeof(hwif->io_ports));
270     hwif->noprobe = 0;
271 }
272
273
274 /* module data table */
275 static struct ata_pci_device chipset __initdata = {
276         vendor: PCI_VENDOR_ID_ITE,
277         device: PCI_DEVICE_ID_ITE_IT8172G,
278         init_chipset: pci_init_it8172,
279         init_channel: ide_init_it8172,
280         exnablebits: {{0x00,0x00,0x00}, {0x40,0x00,0x01} },
281         bootable: ON_BOARD
282 };
283
284 int __init init_it8172(void)
285 {
286         ata_register_chipset(&chipset);
287
288         return 0;
289 }