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