drivers/ide/pci/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/module.h>
  33 #include <linux/types.h>
  34 #include <linux/kernel.h>
  35 #include <linux/ioport.h>
  36 #include <linux/pci.h>
  37 #include <linux/hdreg.h>
  38 #include <linux/ide.h>
  39 #include <linux/delay.h>
  40 #include <linux/init.h>
  41
  42 #include <asm/io.h>
  43 #include <asm/it8172/it8172_int.h>
  44
  45 #include "it8172.h"
  46
  47 /*
  48  * Prototypes
  49  */
  50 static u8 it8172_ratemask (ide_drive_t *drive)
  51 {
  52         return 1;
  53 }
  54
  55 static void it8172_tune_drive (ide_drive_t *drive, u8 pio)
  56 {
  57         ide_hwif_t *hwif        = HWIF(drive);
  58         struct pci_dev *dev     = hwif->pci_dev;
  59         int is_slave            = (hwif->drives[1] == drive);
  60         unsigned long flags;
  61         u16 drive_enables;
  62         u32 drive_timing;
  63
  64         pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
  65         spin_lock_irqsave(&ide_lock, flags);
  66         pci_read_config_word(dev, 0x40, &drive_enables);
  67         pci_read_config_dword(dev, 0x44, &drive_timing);
  68
  69         /*
  70          * FIX! The DIOR/DIOW pulse width and recovery times in port 0x44
  71          * are being left at the default values of 8 PCI clocks (242 nsec
  72          * for a 33 MHz clock). These can be safely shortened at higher
  73          * PIO modes. The DIOR/DIOW pulse width and recovery times only
  74          * apply to PIO modes, not to the DMA modes.
  75          */
  76
  77         /*
  78          * Enable port 0x44. The IT8172G spec is confused; it calls
  79          * this register the "Slave IDE Timing Register", but in fact,
  80          * it controls timing for both master and slave drives.
  81          */
  82         drive_enables |= 0x4000;
  83
  84         if (is_slave) {
  85                 drive_enables &= 0xc006;
  86                 if (pio > 1)
  87                         /* enable prefetch and IORDY sample-point */
  88                         drive_enables |= 0x0060;
  89         } else {
  90                 drive_enables &= 0xc060;
  91                 if (pio > 1)
  92                         /* enable prefetch and IORDY sample-point */
  93                         drive_enables |= 0x0006;
  94         }
  95
  96         pci_write_config_word(dev, 0x40, drive_enables);
  97         spin_unlock_irqrestore(&ide_lock, flags)
  98 }
  99
 100 static u8 it8172_dma_2_pio (u8 xfer_rate)
 101 {
 102         switch(xfer_rate) {
 103                 case XFER_UDMA_5:
 104                 case XFER_UDMA_4:
 105                 case XFER_UDMA_3:
 106                 case XFER_UDMA_2:
 107                 case XFER_UDMA_1:
 108                 case XFER_UDMA_0:
 109                 case XFER_MW_DMA_2:
 110                 case XFER_PIO_4:
 111                         return 4;
 112                 case XFER_MW_DMA_1:
 113                 case XFER_PIO_3:
 114                         return 3;
 115                 case XFER_SW_DMA_2:
 116                 case XFER_PIO_2:
 117                         return 2;
 118                 case XFER_MW_DMA_0:
 119                 case XFER_SW_DMA_1:
 120                 case XFER_SW_DMA_0:
 121                 case XFER_PIO_1:
 122                 case XFER_PIO_0:
 123                 case XFER_PIO_SLOW:
 124                 default:
 125                         return 0;
 126         }
 127 }
 128
 129 static int it8172_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 130 {
 131         ide_hwif_t *hwif        = HWIF(drive);
 132         struct pci_dev *dev     = hwif->pci_dev;
 133         u8 speed        = ide_rate_filter(it8172_ratemask(drive), xferspeed);
 134         int a_speed             = 3 << (drive->dn * 4);
 135         int u_flag              = 1 << drive->dn;
 136         int u_speed             = 0;
 137         u8 reg48, reg4a;
 138
 139         pci_read_config_byte(dev, 0x48, &reg48);
 140         pci_read_config_byte(dev, 0x4a, &reg4a);
 141
 142     /*
 143      * Setting the DMA cycle time to 2 or 3 PCI clocks (60 and 91 nsec
 144      * at 33 MHz PCI clock) seems to cause BadCRC errors during DMA
 145      * transfers on some drives, even though both numbers meet the minimum
 146      * ATAPI-4 spec of 73 and 54 nsec for UDMA 1 and 2 respectively.
 147      * So the faster times are just commented out here. The good news is
 148      * that the slower cycle time has very little affect on transfer
 149      * performance.
 150      */
 151
 152         switch(speed) {
 153                 case XFER_UDMA_4:
 154                 case XFER_UDMA_2:       //u_speed = 2 << (drive->dn * 4); break;
 155                 case XFER_UDMA_5:
 156                 case XFER_UDMA_3:
 157                 case XFER_UDMA_1:       //u_speed = 1 << (drive->dn * 4); break;
 158                 case XFER_UDMA_0:       u_speed = 0 << (drive->dn * 4); break;
 159                 case XFER_MW_DMA_2:
 160                 case XFER_MW_DMA_1:
 161                 case XFER_MW_DMA_0:
 162                 case XFER_SW_DMA_2:     break;
 163                 case XFER_PIO_4:
 164                 case XFER_PIO_3:
 165                 case XFER_PIO_2:
 166                 case XFER_PIO_0:        break;
 167                 default:                return -1;
 168         }
 169
 170         if (speed >= XFER_UDMA_0) {
 171                 pci_write_config_byte(dev, 0x48, reg48 | u_flag);
 172                 reg4a &= ~a_speed;
 173                 pci_write_config_byte(dev, 0x4a, reg4a | u_speed);
 174         } else {
 175                 pci_write_config_byte(dev, 0x48, reg48 & ~u_flag);
 176                 pci_write_config_byte(dev, 0x4a, reg4a & ~a_speed);
 177         }
 178
 179         it8172_tune_drive(drive, it8172_dma_2_pio(speed));
 180         return (ide_config_drive_speed(drive, speed));
 181 }
 182
 183 static int it8172_config_chipset_for_dma (ide_drive_t *drive)
 184 {
 185         u8 speed = ide_dma_speed(drive, it8172_ratemask(drive));
 186
 187         if (!(speed)) {
 188                 u8 tspeed = ide_get_best_pio_mode(drive, 255, 4, NULL);
 189                 speed = it8172_dma_2_pio(XFER_PIO_0 + tspeed);
 190         }
 191
 192         (void) it8172_tune_chipset(drive, speed);
 193         return ide_dma_enable(drive);
 194 }
 195
 196 static int it8172_config_drive_xfer_rate (ide_drive_t *drive)
 197 {
 198         ide_hwif_t *hwif        = HWIF(drive);
 199         struct hd_driveid *id   = drive->id;
 200
 201         drive->init_speed = 0;
 202
 203         if (id && (id->capability & 1) && drive->autodma) {
 204                 /* Consult the list of known "bad" drives */
 205                 if (__ide_dma_bad_drive(drive))
 206                         goto fast_ata_pio;
 207                 if (id->field_valid & 4) {
 208                         if (id->dma_ultra & hwif->ultra_mask) {
 209                                 /* Force if Capable UltraDMA */
 210                                 int dma = it8172_config_chipset_for_dma(drive);
 211                                 if ((id->field_valid & 2) && !dma)
 212                                         goto try_dma_modes;
 213                         }
 214                 } else if (id->field_valid & 2) {
 215 try_dma_modes:
 216                         if ((id->dma_mword & hwif->mwdma_mask) ||
 217                             (id->dma_1word & hwif->swdma_mask)) {
 218                                 /* Force if Capable regular DMA modes */
 219                                 if (!it8172_config_chipset_for_dma(drive))
 220                                         goto no_dma_set;
 221                         }
 222                 } else if (__ide_dma_good_drive(drive) &&
 223                            (id->eide_dma_time < 150)) {
 224                         /* Consult the list of known "good" drives */
 225                         if (!it8172_config_chipset_for_dma(drive))
 226                                 goto no_dma_set;
 227                 } else {
 228                         goto fast_ata_pio;
 229                 }
 230                 return hwif->ide_dma_on(drive);
 231         } else if ((id->capability & 8) || (id->field_valid & 2)) {
 232 fast_ata_pio:
 233 no_dma_set:
 234                 it8172_tune_drive(drive, 5);
 235                 return hwif->ide_dma_off_quietly(drive);
 236         }
 237         /* IORDY not supported */
 238         return 0;
 239 }
 240
 241 static unsigned int __init init_chipset_it8172 (struct pci_dev *dev, const char *name)
 242 {
 243         unsigned char progif;
 244
 245         /*
 246          * Place both IDE interfaces into PCI "native" mode
 247          */
 248         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
 249         pci_write_config_byte(dev, PCI_CLASS_PROG, progif | 0x05);
 250
 251         return IT8172_IDE_IRQ;
 252 }
 253
 254
 255 static void __init init_hwif_it8172 (ide_hwif_t *hwif)
 256 {
 257         struct pci_dev* dev = hwif->pci_dev;
 258         unsigned long cmdBase, ctrlBase;
 259
 260         hwif->autodma = 0;
 261         hwif->tuneproc = &it8172_tune_drive;
 262         hwif->speedproc = &it8172_tune_chipset;
 263
 264         cmdBase = dev->resource[0].start;
 265         ctrlBase = dev->resource[1].start;
 266
 267         ide_init_hwif_ports(&hwif->hw, cmdBase, ctrlBase | 2, NULL);
 268         memcpy(hwif->io_ports, hwif->hw.io_ports, sizeof(hwif->io_ports));
 269         hwif->noprobe = 0;
 270
 271         if (!hwif->dma_base) {
 272                 hwif->drives[0].autotune = 1;
 273                 hwif->drives[1].autotune = 1;
 274                 return;
 275         }
 276
 277         hwif->atapi_dma = 1;
 278         hwif->ultra_mask = 0x07;
 279         hwif->mwdma_mask = 0x06;
 280         hwif->swdma_mask = 0x04;
 281
 282         hwif->ide_dma_check = &it8172_config_drive_xfer_rate;
 283         if (!noautodma)
 284                 hwif->autodma = 1;
 285         hwif->drives[0].autodma = hwif->autodma;
 286         hwif->drives[1].autodma = hwif->autodma;
 287 }
 288
 289 static int __devinit it8172_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 290 {
 291         if ((!(PCI_FUNC(dev->devfn) & 1) ||
 292             (!((dev->class >> 8) == PCI_CLASS_STORAGE_IDE))))
 293                 return 1; /* IT8172 is more than only a IDE controller */
 294         ide_setup_pci_device(dev, &it8172_chipsets[id->driver_data]);
 295         return 0;
 296 }
 297
 298 static struct pci_device_id it8172_pci_tbl[] = {
 299         { PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_IT8172G, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 300         { 0, },
 301 };
 302 MODULE_DEVICE_TABLE(pci, it8172_pci_tbl);
 303
 304 static struct pci_driver driver = {
 305         .name           = "IT8172IDE",
 306         .id_table       = it8172_pci_tbl,
 307         .probe          = it8172_init_one,
 308 };
 309
 310 static int it8172_ide_init(void)
 311 {
 312         return ide_pci_register_driver(&driver);
 313 }
 314
 315 module_init(it8172_ide_init);
 316
 317 MODULE_AUTHOR("SteveL@mvista.com");
 318 MODULE_DESCRIPTION("PCI driver module for ITE 8172 IDE");
 319 MODULE_LICENSE("GPL");