drivers/ide/pci/cs5530.c

   1 /*
   2  * linux/drivers/ide/pci/cs5530.c               Version 0.7     Sept 10, 2002
   3  *
   4  * Copyright (C) 2000                   Andre Hedrick <andre@linux-ide.org>
   5  * Ditto of GNU General Public License.
   6  *
   7  * Copyright (C) 2000                   Mark Lord <mlord@pobox.com>
   8  * May be copied or modified under the terms of the GNU General Public License
   9  *
  10  * Development of this chipset driver was funded
  11  * by the nice folks at National Semiconductor.
  12  *
  13  * Documentation:
  14  *      CS5530 documentation available from National Semiconductor.
  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 #include <asm/io.h>
  32 #include <asm/irq.h>
  33
  34 #include "cs5530.h"
  35
  36 #if defined(DISPLAY_CS5530_TIMINGS) && defined(CONFIG_PROC_FS)
  37 #include <linux/stat.h>
  38 #include <linux/proc_fs.h>
  39
  40 static u8 cs5530_proc = 0;
  41
  42 static struct pci_dev *bmide_dev;
  43
  44 static int cs5530_get_info (char *buffer, char **addr, off_t offset, int count)
  45 {
  46         char *p = buffer;
  47         unsigned long bibma = pci_resource_start(bmide_dev, 4);
  48         u8  c0 = 0, c1 = 0;
  49
  50         /*
  51          * at that point bibma+0x2 et bibma+0xa are byte registers
  52          * to investigate:
  53          */
  54
  55         c0 = inb_p((u16)bibma + 0x02);
  56         c1 = inb_p((u16)bibma + 0x0a);
  57
  58         p += sprintf(p, "\n                                "
  59                         "Cyrix 5530 Chipset.\n");
  60         p += sprintf(p, "--------------- Primary Channel "
  61                         "---------------- Secondary Channel "
  62                         "-------------\n");
  63         p += sprintf(p, "                %sabled "
  64                         "                        %sabled\n",
  65                         (c0&0x80) ? "dis" : " en",
  66                         (c1&0x80) ? "dis" : " en");
  67         p += sprintf(p, "--------------- drive0 --------- drive1 "
  68                         "-------- drive0 ---------- drive1 ------\n");
  69         p += sprintf(p, "DMA enabled:    %s              %s "
  70                         "            %s               %s\n",
  71                         (c0&0x20) ? "yes" : "no ",
  72                         (c0&0x40) ? "yes" : "no ",
  73                         (c1&0x20) ? "yes" : "no ",
  74                         (c1&0x40) ? "yes" : "no " );
  75
  76         p += sprintf(p, "UDMA\n");
  77         p += sprintf(p, "DMA\n");
  78         p += sprintf(p, "PIO\n");
  79
  80         return p-buffer;
  81 }
  82 #endif /* DISPLAY_CS5530_TIMINGS && CONFIG_PROC_FS */
  83
  84 /**
  85  *      cs5530_xfer_set_mode    -       set a new transfer mode at the drive
  86  *      @drive: drive to tune
  87  *      @mode: new mode
  88  *
  89  *      Logging wrapper to the IDE driver speed configuration. This can
  90  *      probably go away now.
  91  */
  92
  93 static int cs5530_set_xfer_mode (ide_drive_t *drive, u8 mode)
  94 {
  95         printk(KERN_DEBUG "%s: cs5530_set_xfer_mode(%s)\n",
  96                 drive->name, ide_xfer_verbose(mode));
  97         return (ide_config_drive_speed(drive, mode));
  98 }
  99
 100 /*
 101  * Here are the standard PIO mode 0-4 timings for each "format".
 102  * Format-0 uses fast data reg timings, with slower command reg timings.
 103  * Format-1 uses fast timings for all registers, but won't work with all drives.
 104  */
 105 static unsigned int cs5530_pio_timings[2][5] = {
 106         {0x00009172, 0x00012171, 0x00020080, 0x00032010, 0x00040010},
 107         {0xd1329172, 0x71212171, 0x30200080, 0x20102010, 0x00100010}
 108 };
 109
 110 /*
 111  * After chip reset, the PIO timings are set to 0x0000e132, which is not valid.
 112  */
 113 #define CS5530_BAD_PIO(timings) (((timings)&~0x80000000)==0x0000e132)
 114 #define CS5530_BASEREG(hwif)    (((hwif)->dma_base & ~0xf) + ((hwif)->channel ? 0x30 : 0x20))
 115
 116 /**
 117  *      cs5530_tuneproc         -       select/set PIO modes
 118  *
 119  *      cs5530_tuneproc() handles selection/setting of PIO modes
 120  *      for both the chipset and drive.
 121  *
 122  *      The ide_init_cs5530() routine guarantees that all drives
 123  *      will have valid default PIO timings set up before we get here.
 124  */
 125
 126 static void cs5530_tuneproc (ide_drive_t *drive, u8 pio)        /* pio=255 means "autotune" */
 127 {
 128         ide_hwif_t      *hwif = HWIF(drive);
 129         unsigned int    format;
 130         unsigned long basereg = CS5530_BASEREG(hwif);
 131         static u8       modes[5] = { XFER_PIO_0, XFER_PIO_1, XFER_PIO_2, XFER_PIO_3, XFER_PIO_4};
 132
 133         pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
 134         if (!cs5530_set_xfer_mode(drive, modes[pio])) {
 135                 format = (hwif->INL(basereg+4) >> 31) & 1;
 136                 hwif->OUTL(cs5530_pio_timings[format][pio],
 137                         basereg+(drive->select.b.unit<<3));
 138         }
 139 }
 140
 141 /**
 142  *      cs5530_config_dma       -       select/set DMA and UDMA modes
 143  *      @drive: drive to tune
 144  *
 145  *      cs5530_config_dma() handles selection/setting of DMA/UDMA modes
 146  *      for both the chipset and drive. The CS5530 has limitations about
 147  *      mixing DMA/UDMA on the same cable.
 148  */
 149
 150 static int cs5530_config_dma (ide_drive_t *drive)
 151 {
 152         int                     udma_ok = 1, mode = 0;
 153         ide_hwif_t              *hwif = HWIF(drive);
 154         int                     unit = drive->select.b.unit;
 155         ide_drive_t             *mate = &hwif->drives[unit^1];
 156         struct hd_driveid       *id = drive->id;
 157         unsigned int            reg, timings;
 158         unsigned long           basereg;
 159
 160         /*
 161          * Default to DMA-off in case we run into trouble here.
 162          */
 163         hwif->ide_dma_off_quietly(drive);
 164         /* turn off DMA while we fiddle */
 165         hwif->ide_dma_host_off(drive);
 166         /* clear DMA_capable bit */
 167
 168         /*
 169          * The CS5530 specifies that two drives sharing a cable cannot
 170          * mix UDMA/MDMA.  It has to be one or the other, for the pair,
 171          * though different timings can still be chosen for each drive.
 172          * We could set the appropriate timing bits on the fly,
 173          * but that might be a bit confusing.  So, for now we statically
 174          * handle this requirement by looking at our mate drive to see
 175          * what it is capable of, before choosing a mode for our own drive.
 176          *
 177          * Note: This relies on the fact we never fail from UDMA to MWDMA_2
 178          * but instead drop to PIO
 179          */
 180         if (mate->present) {
 181                 struct hd_driveid *mateid = mate->id;
 182                 if (mateid && (mateid->capability & 1) &&
 183                     !__ide_dma_bad_drive(mate)) {
 184                         if ((mateid->field_valid & 4) &&
 185                             (mateid->dma_ultra & 7))
 186                                 udma_ok = 1;
 187                         else if ((mateid->field_valid & 2) &&
 188                                  (mateid->dma_mword & 7))
 189                                 udma_ok = 0;
 190                         else
 191                                 udma_ok = 1;
 192                 }
 193         }
 194
 195         /*
 196          * Now see what the current drive is capable of,
 197          * selecting UDMA only if the mate said it was ok.
 198          */
 199         if (id && (id->capability & 1) && drive->autodma &&
 200             !__ide_dma_bad_drive(drive)) {
 201                 if (udma_ok && (id->field_valid & 4) && (id->dma_ultra & 7)) {
 202                         if      (id->dma_ultra & 4)
 203                                 mode = XFER_UDMA_2;
 204                         else if (id->dma_ultra & 2)
 205                                 mode = XFER_UDMA_1;
 206                         else if (id->dma_ultra & 1)
 207                                 mode = XFER_UDMA_0;
 208                 }
 209                 if (!mode && (id->field_valid & 2) && (id->dma_mword & 7)) {
 210                         if      (id->dma_mword & 4)
 211                                 mode = XFER_MW_DMA_2;
 212                         else if (id->dma_mword & 2)
 213                                 mode = XFER_MW_DMA_1;
 214                         else if (id->dma_mword & 1)
 215                                 mode = XFER_MW_DMA_0;
 216                 }
 217         }
 218
 219         /*
 220          * Tell the drive to switch to the new mode; abort on failure.
 221          */
 222         if (!mode || cs5530_set_xfer_mode(drive, mode))
 223                 return 1;       /* failure */
 224
 225         /*
 226          * Now tune the chipset to match the drive:
 227          */
 228         switch (mode) {
 229                 case XFER_UDMA_0:       timings = 0x00921250; break;
 230                 case XFER_UDMA_1:       timings = 0x00911140; break;
 231                 case XFER_UDMA_2:       timings = 0x00911030; break;
 232                 case XFER_MW_DMA_0:     timings = 0x00077771; break;
 233                 case XFER_MW_DMA_1:     timings = 0x00012121; break;
 234                 case XFER_MW_DMA_2:     timings = 0x00002020; break;
 235                 default:
 236                         printk(KERN_ERR "%s: cs5530_config_dma: huh? mode=%02x\n",
 237                                 drive->name, mode);
 238                         return 1;       /* failure */
 239         }
 240         basereg = CS5530_BASEREG(hwif);
 241         reg = hwif->INL(basereg+4);             /* get drive0 config register */
 242         timings |= reg & 0x80000000;            /* preserve PIO format bit */
 243         if (unit == 0) {                        /* are we configuring drive0? */
 244                 hwif->OUTL(timings, basereg+4); /* write drive0 config register */
 245         } else {
 246                 if (timings & 0x00100000)
 247                         reg |=  0x00100000;     /* enable UDMA timings for both drives */
 248                 else
 249                         reg &= ~0x00100000;     /* disable UDMA timings for both drives */
 250                 hwif->OUTL(reg,     basereg+4); /* write drive0 config register */
 251                 hwif->OUTL(timings, basereg+12);        /* write drive1 config register */
 252         }
 253         (void) hwif->ide_dma_host_on(drive);
 254         /* set DMA_capable bit */
 255
 256         /*
 257          * Finally, turn DMA on in software, and exit.
 258          */
 259         return hwif->ide_dma_on(drive); /* success */
 260 }
 261
 262 /**
 263  *      init_chipset_5530       -       set up 5530 bridge
 264  *      @dev: PCI device
 265  *      @name: device name
 266  *
 267  *      Initialize the cs5530 bridge for reliable IDE DMA operation.
 268  */
 269
 270 static unsigned int __init init_chipset_cs5530 (struct pci_dev *dev, const char *name)
 271 {
 272         struct pci_dev *master_0 = NULL, *cs5530_0 = NULL;
 273         unsigned long flags;
 274
 275 #if defined(DISPLAY_CS5530_TIMINGS) && defined(CONFIG_PROC_FS)
 276         if (!cs5530_proc) {
 277                 cs5530_proc = 1;
 278                 bmide_dev = dev;
 279                 ide_pci_create_host_proc("cs5530", cs5530_get_info);
 280         }
 281 #endif /* DISPLAY_CS5530_TIMINGS && CONFIG_PROC_FS */
 282
 283         dev = NULL;
 284         while ((dev = pci_find_device(PCI_VENDOR_ID_CYRIX, PCI_ANY_ID, dev)) != NULL) {
 285                 switch (dev->device) {
 286                         case PCI_DEVICE_ID_CYRIX_PCI_MASTER:
 287                                 master_0 = dev;
 288                                 break;
 289                         case PCI_DEVICE_ID_CYRIX_5530_LEGACY:
 290                                 cs5530_0 = dev;
 291                                 break;
 292                 }
 293         }
 294         if (!master_0) {
 295                 printk(KERN_ERR "%s: unable to locate PCI MASTER function\n", name);
 296                 return 0;
 297         }
 298         if (!cs5530_0) {
 299                 printk(KERN_ERR "%s: unable to locate CS5530 LEGACY function\n", name);
 300                 return 0;
 301         }
 302
 303         spin_lock_irqsave(&ide_lock, flags);
 304                 /* all CPUs (there should only be one CPU with this chipset) */
 305
 306         /*
 307          * Enable BusMaster and MemoryWriteAndInvalidate for the cs5530:
 308          * -->  OR 0x14 into 16-bit PCI COMMAND reg of function 0 of the cs5530
 309          */
 310
 311         pci_set_master(cs5530_0);
 312         pci_set_mwi(cs5530_0);
 313
 314         /*
 315          * Set PCI CacheLineSize to 16-bytes:
 316          * --> Write 0x04 into 8-bit PCI CACHELINESIZE reg of function 0 of the cs5530
 317          */
 318
 319         pci_write_config_byte(cs5530_0, PCI_CACHE_LINE_SIZE, 0x04);
 320
 321         /*
 322          * Disable trapping of UDMA register accesses (Win98 hack):
 323          * --> Write 0x5006 into 16-bit reg at offset 0xd0 of function 0 of the cs5530
 324          */
 325
 326         pci_write_config_word(cs5530_0, 0xd0, 0x5006);
 327
 328         /*
 329          * Bit-1 at 0x40 enables MemoryWriteAndInvalidate on internal X-bus:
 330          * The other settings are what is necessary to get the register
 331          * into a sane state for IDE DMA operation.
 332          */
 333
 334         pci_write_config_byte(master_0, 0x40, 0x1e);
 335
 336         /*
 337          * Set max PCI burst size (16-bytes seems to work best):
 338          *         16bytes: set bit-1 at 0x41 (reg value of 0x16)
 339          *      all others: clear bit-1 at 0x41, and do:
 340          *        128bytes: OR 0x00 at 0x41
 341          *        256bytes: OR 0x04 at 0x41
 342          *        512bytes: OR 0x08 at 0x41
 343          *       1024bytes: OR 0x0c at 0x41
 344          */
 345
 346         pci_write_config_byte(master_0, 0x41, 0x14);
 347
 348         /*
 349          * These settings are necessary to get the chip
 350          * into a sane state for IDE DMA operation.
 351          */
 352
 353         pci_write_config_byte(master_0, 0x42, 0x00);
 354         pci_write_config_byte(master_0, 0x43, 0xc1);
 355
 356         spin_unlock_irqrestore(&ide_lock, flags);
 357
 358         return 0;
 359 }
 360
 361 /**
 362  *      init_hwif_cs5530        -       initialise an IDE channel
 363  *      @hwif: IDE to initialize
 364  *
 365  *      This gets invoked by the IDE driver once for each channel. It
 366  *      performs channel-specific pre-initialization before drive probing.
 367  */
 368
 369 static void __init init_hwif_cs5530 (ide_hwif_t *hwif)
 370 {
 371         unsigned long basereg;
 372         u32 d0_timings;
 373         hwif->autodma = 0;
 374
 375         if (hwif->mate)
 376                 hwif->serialized = hwif->mate->serialized = 1;
 377
 378         hwif->tuneproc = &cs5530_tuneproc;
 379         basereg = CS5530_BASEREG(hwif);
 380         d0_timings = hwif->INL(basereg+0);
 381         if (CS5530_BAD_PIO(d0_timings)) {
 382                 /* PIO timings not initialized? */
 383                 hwif->OUTL(cs5530_pio_timings[(d0_timings>>31)&1][0], basereg+0);
 384                 if (!hwif->drives[0].autotune)
 385                         hwif->drives[0].autotune = 1;
 386                         /* needs autotuning later */
 387         }
 388         if (CS5530_BAD_PIO(hwif->INL(basereg+8))) {
 389         /* PIO timings not initialized? */
 390                 hwif->OUTL(cs5530_pio_timings[(d0_timings>>31)&1][0], basereg+8);
 391                 if (!hwif->drives[1].autotune)
 392                         hwif->drives[1].autotune = 1;
 393                         /* needs autotuning later */
 394         }
 395
 396         hwif->atapi_dma = 1;
 397         hwif->ultra_mask = 0x07;
 398         hwif->mwdma_mask = 0x07;
 399
 400         hwif->ide_dma_check = &cs5530_config_dma;
 401         if (!noautodma)
 402                 hwif->autodma = 1;
 403         hwif->drives[0].autodma = hwif->autodma;
 404         hwif->drives[1].autodma = hwif->autodma;
 405 }
 406
 407 static int __devinit cs5530_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 408 {
 409         ide_pci_device_t *d = &cs5530_chipsets[id->driver_data];
 410         if (dev->device != d->device)
 411                 BUG();
 412         ide_setup_pci_device(dev, d);
 413         return 0;
 414 }
 415
 416 static struct pci_device_id cs5530_pci_tbl[] = {
 417         { PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 418         { 0, },
 419 };
 420 MODULE_DEVICE_TABLE(pci, cs5530_pci_tbl);
 421
 422 static struct pci_driver driver = {
 423         .name           = "CS5530 IDE",
 424         .id_table       = cs5530_pci_tbl,
 425         .probe          = cs5530_init_one,
 426 };
 427
 428 static int cs5530_ide_init(void)
 429 {
 430         return ide_pci_register_driver(&driver);
 431 }
 432
 433 module_init(cs5530_ide_init);
 434
 435 MODULE_AUTHOR("Mark Lord");
 436 MODULE_DESCRIPTION("PCI driver module for Cyrix/NS 5530 IDE");
 437 MODULE_LICENSE("GPL");