Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * Copyright (C) 1998-2002 Andre Hedrick <andre@linux-ide.org> |
Sergei Shtylyov | fed2164 | 2007-02-17 02:40:22 +0100 | [diff] [blame] | 3 | * Copyright (C) 2006-2007 MontaVista Software, Inc. |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 4 | * Copyright (C) 2007 Bartlomiej Zolnierkiewicz |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | * Portions Copyright (C) 1999 Promise Technology, Inc. |
| 7 | * Author: Frank Tiernan (frankt@promise.com) |
| 8 | * Released under terms of General Public License |
| 9 | */ |
| 10 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include <linux/types.h> |
| 12 | #include <linux/module.h> |
| 13 | #include <linux/kernel.h> |
| 14 | #include <linux/delay.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/blkdev.h> |
| 16 | #include <linux/hdreg.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include <linux/pci.h> |
| 18 | #include <linux/init.h> |
| 19 | #include <linux/ide.h> |
| 20 | |
| 21 | #include <asm/io.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | #define PDC202XX_DEBUG_DRIVE_INFO 0 |
| 24 | |
| 25 | static const char *pdc_quirk_drives[] = { |
| 26 | "QUANTUM FIREBALLlct08 08", |
| 27 | "QUANTUM FIREBALLP KA6.4", |
| 28 | "QUANTUM FIREBALLP KA9.1", |
| 29 | "QUANTUM FIREBALLP LM20.4", |
| 30 | "QUANTUM FIREBALLP KX13.6", |
| 31 | "QUANTUM FIREBALLP KX20.5", |
| 32 | "QUANTUM FIREBALLP KX27.3", |
| 33 | "QUANTUM FIREBALLP LM20.5", |
| 34 | NULL |
| 35 | }; |
| 36 | |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 37 | static void pdc_old_disable_66MHz_clock(ide_hwif_t *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 39 | static void pdc202xx_set_mode(ide_drive_t *drive, const u8 speed) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | { |
| 41 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 42 | struct pci_dev *dev = to_pci_dev(hwif->dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | u8 drive_pci = 0x60 + (drive->dn << 2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 45 | u8 AP = 0, BP = 0, CP = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | u8 TA = 0, TB = 0, TC = 0; |
| 47 | |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 48 | #if PDC202XX_DEBUG_DRIVE_INFO |
| 49 | u32 drive_conf = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | pci_read_config_dword(dev, drive_pci, &drive_conf); |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 51 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 53 | /* |
| 54 | * TODO: do this once per channel |
| 55 | */ |
| 56 | if (dev->device != PCI_DEVICE_ID_PROMISE_20246) |
| 57 | pdc_old_disable_66MHz_clock(hwif); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 59 | pci_read_config_byte(dev, drive_pci, &AP); |
| 60 | pci_read_config_byte(dev, drive_pci + 1, &BP); |
| 61 | pci_read_config_byte(dev, drive_pci + 2, &CP); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | |
| 63 | switch(speed) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | case XFER_UDMA_5: |
| 65 | case XFER_UDMA_4: TB = 0x20; TC = 0x01; break; |
| 66 | case XFER_UDMA_2: TB = 0x20; TC = 0x01; break; |
| 67 | case XFER_UDMA_3: |
| 68 | case XFER_UDMA_1: TB = 0x40; TC = 0x02; break; |
| 69 | case XFER_UDMA_0: |
| 70 | case XFER_MW_DMA_2: TB = 0x60; TC = 0x03; break; |
| 71 | case XFER_MW_DMA_1: TB = 0x60; TC = 0x04; break; |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 72 | case XFER_MW_DMA_0: TB = 0xE0; TC = 0x0F; break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | case XFER_PIO_4: TA = 0x01; TB = 0x04; break; |
| 74 | case XFER_PIO_3: TA = 0x02; TB = 0x06; break; |
| 75 | case XFER_PIO_2: TA = 0x03; TB = 0x08; break; |
| 76 | case XFER_PIO_1: TA = 0x05; TB = 0x0C; break; |
| 77 | case XFER_PIO_0: |
| 78 | default: TA = 0x09; TB = 0x13; break; |
| 79 | } |
| 80 | |
| 81 | if (speed < XFER_SW_DMA_0) { |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 82 | /* |
| 83 | * preserve SYNC_INT / ERDDY_EN bits while clearing |
| 84 | * Prefetch_EN / IORDY_EN / PA[3:0] bits of register A |
| 85 | */ |
| 86 | AP &= ~0x3f; |
| 87 | if (drive->id->capability & 4) |
| 88 | AP |= 0x20; /* set IORDY_EN bit */ |
| 89 | if (drive->media == ide_disk) |
| 90 | AP |= 0x10; /* set Prefetch_EN bit */ |
| 91 | /* clear PB[4:0] bits of register B */ |
| 92 | BP &= ~0x1f; |
| 93 | pci_write_config_byte(dev, drive_pci, AP | TA); |
| 94 | pci_write_config_byte(dev, drive_pci + 1, BP | TB); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | } else { |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 96 | /* clear MB[2:0] bits of register B */ |
| 97 | BP &= ~0xe0; |
| 98 | /* clear MC[3:0] bits of register C */ |
| 99 | CP &= ~0x0f; |
| 100 | pci_write_config_byte(dev, drive_pci + 1, BP | TB); |
| 101 | pci_write_config_byte(dev, drive_pci + 2, CP | TC); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | #if PDC202XX_DEBUG_DRIVE_INFO |
| 105 | printk(KERN_DEBUG "%s: %s drive%d 0x%08x ", |
| 106 | drive->name, ide_xfer_verbose(speed), |
| 107 | drive->dn, drive_conf); |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 108 | pci_read_config_dword(dev, drive_pci, &drive_conf); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | printk("0x%08x\n", drive_conf); |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 110 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | } |
| 112 | |
Bartlomiej Zolnierkiewicz | 26bcb87 | 2007-10-11 23:54:00 +0200 | [diff] [blame] | 113 | static void pdc202xx_set_pio_mode(ide_drive_t *drive, const u8 pio) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | { |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 115 | pdc202xx_set_mode(drive, XFER_PIO_0 + pio); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | } |
| 117 | |
Bartlomiej Zolnierkiewicz | bfa14b4 | 2008-02-02 19:56:31 +0100 | [diff] [blame] | 118 | static u8 __devinit pdc2026x_old_cable_detect(ide_hwif_t *hwif) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | { |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 120 | struct pci_dev *dev = to_pci_dev(hwif->dev); |
Alan Cox | 1bee4d1 | 2008-02-02 19:56:38 +0100 | [diff] [blame] | 121 | u16 CIS, mask = hwif->channel ? (1 << 11) : (1 << 10); |
Bartlomiej Zolnierkiewicz | 49521f9 | 2007-07-09 23:17:58 +0200 | [diff] [blame] | 122 | |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 123 | pci_read_config_word(dev, 0x50, &CIS); |
Bartlomiej Zolnierkiewicz | 49521f9 | 2007-07-09 23:17:58 +0200 | [diff] [blame] | 124 | |
| 125 | return (CIS & mask) ? ATA_CBL_PATA40 : ATA_CBL_PATA80; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | /* |
| 129 | * Set the control register to use the 66MHz system |
| 130 | * clock for UDMA 3/4/5 mode operation when necessary. |
| 131 | * |
Bartlomiej Zolnierkiewicz | 4fce316 | 2007-05-16 00:51:41 +0200 | [diff] [blame] | 132 | * FIXME: this register is shared by both channels, some locking is needed |
| 133 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | * It may also be possible to leave the 66MHz clock on |
| 135 | * and readjust the timing parameters. |
| 136 | */ |
| 137 | static void pdc_old_enable_66MHz_clock(ide_hwif_t *hwif) |
| 138 | { |
Bartlomiej Zolnierkiewicz | 1c029fd | 2008-01-25 22:17:05 +0100 | [diff] [blame] | 139 | unsigned long clock_reg = hwif->extra_base + 0x01; |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 140 | u8 clock = inb(clock_reg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 142 | outb(clock | (hwif->channel ? 0x08 : 0x02), clock_reg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | static void pdc_old_disable_66MHz_clock(ide_hwif_t *hwif) |
| 146 | { |
Bartlomiej Zolnierkiewicz | 1c029fd | 2008-01-25 22:17:05 +0100 | [diff] [blame] | 147 | unsigned long clock_reg = hwif->extra_base + 0x01; |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 148 | u8 clock = inb(clock_reg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 150 | outb(clock & ~(hwif->channel ? 0x08 : 0x02), clock_reg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Bartlomiej Zolnierkiewicz | f01393e | 2008-01-26 20:13:03 +0100 | [diff] [blame] | 153 | static void pdc202xx_quirkproc(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | { |
Sergei Shtylyov | d24ec42 | 2007-02-07 18:18:39 +0100 | [diff] [blame] | 155 | const char **list, *model = drive->id->model; |
| 156 | |
| 157 | for (list = pdc_quirk_drives; *list != NULL; list++) |
Bartlomiej Zolnierkiewicz | f01393e | 2008-01-26 20:13:03 +0100 | [diff] [blame] | 158 | if (strstr(model, *list) != NULL) { |
| 159 | drive->quirk_list = 2; |
| 160 | return; |
| 161 | } |
| 162 | |
| 163 | drive->quirk_list = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | } |
| 165 | |
| 166 | static void pdc202xx_old_ide_dma_start(ide_drive_t *drive) |
| 167 | { |
| 168 | if (drive->current_speed > XFER_UDMA_2) |
| 169 | pdc_old_enable_66MHz_clock(drive->hwif); |
Tobias Oed | f3d5b34 | 2006-10-03 01:14:17 -0700 | [diff] [blame] | 170 | if (drive->media != ide_disk || drive->addressing == 1) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | struct request *rq = HWGROUP(drive)->rq; |
| 172 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 1c029fd | 2008-01-25 22:17:05 +0100 | [diff] [blame] | 173 | unsigned long high_16 = hwif->extra_base - 16; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | unsigned long atapi_reg = high_16 + (hwif->channel ? 0x24 : 0x20); |
| 175 | u32 word_count = 0; |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 176 | u8 clock = inb(high_16 + 0x11); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 178 | outb(clock | (hwif->channel ? 0x08 : 0x02), high_16 + 0x11); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | word_count = (rq->nr_sectors << 8); |
| 180 | word_count = (rq_data_dir(rq) == READ) ? |
| 181 | word_count | 0x05000000 : |
| 182 | word_count | 0x06000000; |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 183 | outl(word_count, atapi_reg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | } |
| 185 | ide_dma_start(drive); |
| 186 | } |
| 187 | |
| 188 | static int pdc202xx_old_ide_dma_end(ide_drive_t *drive) |
| 189 | { |
Tobias Oed | f3d5b34 | 2006-10-03 01:14:17 -0700 | [diff] [blame] | 190 | if (drive->media != ide_disk || drive->addressing == 1) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 1c029fd | 2008-01-25 22:17:05 +0100 | [diff] [blame] | 192 | unsigned long high_16 = hwif->extra_base - 16; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | unsigned long atapi_reg = high_16 + (hwif->channel ? 0x24 : 0x20); |
| 194 | u8 clock = 0; |
| 195 | |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 196 | outl(0, atapi_reg); /* zero out extra */ |
| 197 | clock = inb(high_16 + 0x11); |
| 198 | outb(clock & ~(hwif->channel ? 0x08:0x02), high_16 + 0x11); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | } |
| 200 | if (drive->current_speed > XFER_UDMA_2) |
| 201 | pdc_old_disable_66MHz_clock(drive->hwif); |
| 202 | return __ide_dma_end(drive); |
| 203 | } |
| 204 | |
| 205 | static int pdc202xx_old_ide_dma_test_irq(ide_drive_t *drive) |
| 206 | { |
| 207 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 1c029fd | 2008-01-25 22:17:05 +0100 | [diff] [blame] | 208 | unsigned long high_16 = hwif->extra_base - 16; |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 209 | u8 dma_stat = inb(hwif->dma_status); |
| 210 | u8 sc1d = inb(high_16 + 0x001d); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | |
| 212 | if (hwif->channel) { |
| 213 | /* bit7: Error, bit6: Interrupting, bit5: FIFO Full, bit4: FIFO Empty */ |
| 214 | if ((sc1d & 0x50) == 0x50) |
| 215 | goto somebody_else; |
| 216 | else if ((sc1d & 0x40) == 0x40) |
| 217 | return (dma_stat & 4) == 4; |
| 218 | } else { |
| 219 | /* bit3: Error, bit2: Interrupting, bit1: FIFO Full, bit0: FIFO Empty */ |
| 220 | if ((sc1d & 0x05) == 0x05) |
| 221 | goto somebody_else; |
| 222 | else if ((sc1d & 0x04) == 0x04) |
| 223 | return (dma_stat & 4) == 4; |
| 224 | } |
| 225 | somebody_else: |
| 226 | return (dma_stat & 4) == 4; /* return 1 if INTR asserted */ |
| 227 | } |
| 228 | |
Sergei Shtylyov | 841d2a9 | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 229 | static void pdc202xx_dma_lost_irq(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | { |
Sergei Shtylyov | 841d2a9 | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 231 | ide_hwif_t *hwif = HWIF(drive); |
| 232 | |
| 233 | if (hwif->resetproc != NULL) |
| 234 | hwif->resetproc(drive); |
| 235 | |
| 236 | ide_dma_lost_irq(drive); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | } |
| 238 | |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 239 | static void pdc202xx_dma_timeout(ide_drive_t *drive) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | { |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 241 | ide_hwif_t *hwif = HWIF(drive); |
| 242 | |
| 243 | if (hwif->resetproc != NULL) |
| 244 | hwif->resetproc(drive); |
| 245 | |
| 246 | ide_dma_timeout(drive); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | static void pdc202xx_reset_host (ide_hwif_t *hwif) |
| 250 | { |
Bartlomiej Zolnierkiewicz | 1c029fd | 2008-01-25 22:17:05 +0100 | [diff] [blame] | 251 | unsigned long high_16 = hwif->extra_base - 16; |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 252 | u8 udma_speed_flag = inb(high_16 | 0x001f); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 254 | outb(udma_speed_flag | 0x10, high_16 | 0x001f); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | mdelay(100); |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 256 | outb(udma_speed_flag & ~0x10, high_16 | 0x001f); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | mdelay(2000); /* 2 seconds ?! */ |
| 258 | |
| 259 | printk(KERN_WARNING "PDC202XX: %s channel reset.\n", |
| 260 | hwif->channel ? "Secondary" : "Primary"); |
| 261 | } |
| 262 | |
| 263 | static void pdc202xx_reset (ide_drive_t *drive) |
| 264 | { |
| 265 | ide_hwif_t *hwif = HWIF(drive); |
| 266 | ide_hwif_t *mate = hwif->mate; |
Bartlomiej Zolnierkiewicz | 26bcb87 | 2007-10-11 23:54:00 +0200 | [diff] [blame] | 267 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | pdc202xx_reset_host(hwif); |
| 269 | pdc202xx_reset_host(mate); |
Bartlomiej Zolnierkiewicz | 26bcb87 | 2007-10-11 23:54:00 +0200 | [diff] [blame] | 270 | |
| 271 | ide_set_max_pio(drive); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | } |
| 273 | |
Alan Cox | 57e834e | 2006-06-28 04:27:03 -0700 | [diff] [blame] | 274 | static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev, |
| 275 | const char *name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | return dev->irq; |
| 278 | } |
| 279 | |
| 280 | static void __devinit init_hwif_pdc202xx(ide_hwif_t *hwif) |
| 281 | { |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 282 | struct pci_dev *dev = to_pci_dev(hwif->dev); |
| 283 | |
Bartlomiej Zolnierkiewicz | 26bcb87 | 2007-10-11 23:54:00 +0200 | [diff] [blame] | 284 | hwif->set_pio_mode = &pdc202xx_set_pio_mode; |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 285 | hwif->set_dma_mode = &pdc202xx_set_mode; |
Bartlomiej Zolnierkiewicz | 26bcb87 | 2007-10-11 23:54:00 +0200 | [diff] [blame] | 286 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | hwif->quirkproc = &pdc202xx_quirkproc; |
| 288 | |
Bartlomiej Zolnierkiewicz | bfa14b4 | 2008-02-02 19:56:31 +0100 | [diff] [blame] | 289 | if (dev->device != PCI_DEVICE_ID_PROMISE_20246) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | hwif->resetproc = &pdc202xx_reset; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | |
Bartlomiej Zolnierkiewicz | bfa14b4 | 2008-02-02 19:56:31 +0100 | [diff] [blame] | 292 | hwif->cable_detect = pdc2026x_old_cable_detect; |
| 293 | } |
| 294 | |
Bartlomiej Zolnierkiewicz | e98d6e5 | 2007-08-20 22:42:56 +0200 | [diff] [blame] | 295 | if (hwif->dma_base == 0) |
| 296 | return; |
| 297 | |
Sergei Shtylyov | 841d2a9 | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 298 | hwif->dma_lost_irq = &pdc202xx_dma_lost_irq; |
Sergei Shtylyov | c283f5d | 2007-07-09 23:17:54 +0200 | [diff] [blame] | 299 | hwif->dma_timeout = &pdc202xx_dma_timeout; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 301 | if (dev->device != PCI_DEVICE_ID_PROMISE_20246) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | hwif->dma_start = &pdc202xx_old_ide_dma_start; |
| 303 | hwif->ide_dma_end = &pdc202xx_old_ide_dma_end; |
| 304 | } |
| 305 | hwif->ide_dma_test_irq = &pdc202xx_old_ide_dma_test_irq; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | } |
| 307 | |
| 308 | static void __devinit init_dma_pdc202xx(ide_hwif_t *hwif, unsigned long dmabase) |
| 309 | { |
| 310 | u8 udma_speed_flag = 0, primary_mode = 0, secondary_mode = 0; |
| 311 | |
| 312 | if (hwif->channel) { |
Sergei Shtylyov | ecf32796 | 2008-02-01 23:09:30 +0100 | [diff] [blame] | 313 | ide_setup_dma(hwif, dmabase); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 314 | return; |
| 315 | } |
| 316 | |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 317 | udma_speed_flag = inb(dmabase | 0x1f); |
| 318 | primary_mode = inb(dmabase | 0x1a); |
| 319 | secondary_mode = inb(dmabase | 0x1b); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | printk(KERN_INFO "%s: (U)DMA Burst Bit %sABLED " \ |
| 321 | "Primary %s Mode " \ |
| 322 | "Secondary %s Mode.\n", hwif->cds->name, |
| 323 | (udma_speed_flag & 1) ? "EN" : "DIS", |
| 324 | (primary_mode & 1) ? "MASTER" : "PCI", |
| 325 | (secondary_mode & 1) ? "MASTER" : "PCI" ); |
| 326 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | if (!(udma_speed_flag & 1)) { |
| 328 | printk(KERN_INFO "%s: FORCING BURST BIT 0x%02x->0x%02x ", |
| 329 | hwif->cds->name, udma_speed_flag, |
| 330 | (udma_speed_flag|1)); |
Bartlomiej Zolnierkiewicz | 0ecdca2 | 2007-02-17 02:40:25 +0100 | [diff] [blame] | 331 | outb(udma_speed_flag | 1, dmabase | 0x1f); |
| 332 | printk("%sACTIVE\n", (inb(dmabase | 0x1f) & 1) ? "" : "IN"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | |
Sergei Shtylyov | ecf32796 | 2008-02-01 23:09:30 +0100 | [diff] [blame] | 335 | ide_setup_dma(hwif, dmabase); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | } |
| 337 | |
Bartlomiej Zolnierkiewicz | 97f84ba | 2007-10-19 00:30:09 +0200 | [diff] [blame] | 338 | static void __devinit pdc202ata4_fixup_irq(struct pci_dev *dev, |
| 339 | const char *name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | { |
| 341 | if ((dev->class >> 8) != PCI_CLASS_STORAGE_IDE) { |
| 342 | u8 irq = 0, irq2 = 0; |
| 343 | pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq); |
| 344 | /* 0xbc */ |
| 345 | pci_read_config_byte(dev, (PCI_INTERRUPT_LINE)|0x80, &irq2); |
| 346 | if (irq != irq2) { |
| 347 | pci_write_config_byte(dev, |
| 348 | (PCI_INTERRUPT_LINE)|0x80, irq); /* 0xbc */ |
Bartlomiej Zolnierkiewicz | 97f84ba | 2007-10-19 00:30:09 +0200 | [diff] [blame] | 349 | printk(KERN_INFO "%s: PCI config space interrupt " |
| 350 | "mirror fixed\n", name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | } |
| 352 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | } |
| 354 | |
Bartlomiej Zolnierkiewicz | 4db90a1 | 2008-01-25 22:17:18 +0100 | [diff] [blame] | 355 | #define IDE_HFLAGS_PDC202XX \ |
| 356 | (IDE_HFLAG_ERROR_STOPS_FIFO | \ |
| 357 | IDE_HFLAG_ABUSE_SET_DMA_MODE | \ |
| 358 | IDE_HFLAG_OFF_BOARD) |
| 359 | |
Bartlomiej Zolnierkiewicz | 272a370 | 2007-10-20 00:32:30 +0200 | [diff] [blame] | 360 | #define DECLARE_PDC2026X_DEV(name_str, udma, extra_flags) \ |
Bartlomiej Zolnierkiewicz | 5ef8cb5 | 2007-10-19 00:30:10 +0200 | [diff] [blame] | 361 | { \ |
| 362 | .name = name_str, \ |
| 363 | .init_chipset = init_chipset_pdc202xx, \ |
| 364 | .init_hwif = init_hwif_pdc202xx, \ |
| 365 | .init_dma = init_dma_pdc202xx, \ |
| 366 | .extra = 48, \ |
Bartlomiej Zolnierkiewicz | 4db90a1 | 2008-01-25 22:17:18 +0100 | [diff] [blame] | 367 | .host_flags = IDE_HFLAGS_PDC202XX | extra_flags, \ |
Bartlomiej Zolnierkiewicz | 5ef8cb5 | 2007-10-19 00:30:10 +0200 | [diff] [blame] | 368 | .pio_mask = ATA_PIO4, \ |
| 369 | .mwdma_mask = ATA_MWDMA2, \ |
| 370 | .udma_mask = udma, \ |
| 371 | } |
| 372 | |
Bartlomiej Zolnierkiewicz | 8562043 | 2007-10-20 00:32:34 +0200 | [diff] [blame] | 373 | static const struct ide_port_info pdc202xx_chipsets[] __devinitdata = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | { /* 0 */ |
| 375 | .name = "PDC20246", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | .init_chipset = init_chipset_pdc202xx, |
| 377 | .init_hwif = init_hwif_pdc202xx, |
| 378 | .init_dma = init_dma_pdc202xx, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | .extra = 16, |
Bartlomiej Zolnierkiewicz | 4db90a1 | 2008-01-25 22:17:18 +0100 | [diff] [blame] | 380 | .host_flags = IDE_HFLAGS_PDC202XX, |
Bartlomiej Zolnierkiewicz | 4099d14 | 2007-07-20 01:11:59 +0200 | [diff] [blame] | 381 | .pio_mask = ATA_PIO4, |
Bartlomiej Zolnierkiewicz | 5f8b6c3 | 2007-10-19 00:30:07 +0200 | [diff] [blame] | 382 | .mwdma_mask = ATA_MWDMA2, |
| 383 | .udma_mask = ATA_UDMA2, |
Bartlomiej Zolnierkiewicz | 5ef8cb5 | 2007-10-19 00:30:10 +0200 | [diff] [blame] | 384 | }, |
| 385 | |
Bartlomiej Zolnierkiewicz | 272a370 | 2007-10-20 00:32:30 +0200 | [diff] [blame] | 386 | /* 1 */ DECLARE_PDC2026X_DEV("PDC20262", ATA_UDMA4, 0), |
| 387 | /* 2 */ DECLARE_PDC2026X_DEV("PDC20263", ATA_UDMA4, 0), |
| 388 | /* 3 */ DECLARE_PDC2026X_DEV("PDC20265", ATA_UDMA5, IDE_HFLAG_RQSIZE_256), |
| 389 | /* 4 */ DECLARE_PDC2026X_DEV("PDC20267", ATA_UDMA5, IDE_HFLAG_RQSIZE_256), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | }; |
| 391 | |
| 392 | /** |
| 393 | * pdc202xx_init_one - called when a PDC202xx is found |
| 394 | * @dev: the pdc202xx device |
| 395 | * @id: the matching pci id |
| 396 | * |
| 397 | * Called when the PCI registration layer (or the IDE initialization) |
| 398 | * finds a device matching our IDE device tables. |
| 399 | */ |
| 400 | |
| 401 | static int __devinit pdc202xx_init_one(struct pci_dev *dev, const struct pci_device_id *id) |
| 402 | { |
Bartlomiej Zolnierkiewicz | 8562043 | 2007-10-20 00:32:34 +0200 | [diff] [blame] | 403 | const struct ide_port_info *d; |
Bartlomiej Zolnierkiewicz | 97f84ba | 2007-10-19 00:30:09 +0200 | [diff] [blame] | 404 | u8 idx = id->driver_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 405 | |
Bartlomiej Zolnierkiewicz | 97f84ba | 2007-10-19 00:30:09 +0200 | [diff] [blame] | 406 | d = &pdc202xx_chipsets[idx]; |
| 407 | |
| 408 | if (idx < 3) |
| 409 | pdc202ata4_fixup_irq(dev, d->name); |
| 410 | |
| 411 | if (idx == 3) { |
| 412 | struct pci_dev *bridge = dev->bus->self; |
| 413 | |
| 414 | if (bridge && |
| 415 | bridge->vendor == PCI_VENDOR_ID_INTEL && |
| 416 | (bridge->device == PCI_DEVICE_ID_INTEL_I960 || |
| 417 | bridge->device == PCI_DEVICE_ID_INTEL_I960RM)) { |
| 418 | printk(KERN_INFO "ide: Skipping Promise PDC20265 " |
| 419 | "attached to I2O RAID controller\n"); |
| 420 | return -ENODEV; |
| 421 | } |
| 422 | } |
| 423 | |
| 424 | return ide_setup_pci_device(dev, d); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 425 | } |
| 426 | |
Bartlomiej Zolnierkiewicz | 9cbcc5e | 2007-10-16 22:29:56 +0200 | [diff] [blame] | 427 | static const struct pci_device_id pdc202xx_pci_tbl[] = { |
| 428 | { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20246), 0 }, |
| 429 | { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20262), 1 }, |
| 430 | { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20263), 2 }, |
| 431 | { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20265), 3 }, |
| 432 | { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20267), 4 }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | { 0, }, |
| 434 | }; |
| 435 | MODULE_DEVICE_TABLE(pci, pdc202xx_pci_tbl); |
| 436 | |
| 437 | static struct pci_driver driver = { |
| 438 | .name = "Promise_Old_IDE", |
| 439 | .id_table = pdc202xx_pci_tbl, |
| 440 | .probe = pdc202xx_init_one, |
| 441 | }; |
| 442 | |
Bartlomiej Zolnierkiewicz | 82ab1ee | 2007-01-27 13:46:56 +0100 | [diff] [blame] | 443 | static int __init pdc202xx_ide_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 444 | { |
| 445 | return ide_pci_register_driver(&driver); |
| 446 | } |
| 447 | |
| 448 | module_init(pdc202xx_ide_init); |
| 449 | |
| 450 | MODULE_AUTHOR("Andre Hedrick, Frank Tiernan"); |
| 451 | MODULE_DESCRIPTION("PCI driver module for older Promise IDE"); |
| 452 | MODULE_LICENSE("GPL"); |