Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 1 | /* |
| 2 | * ITE 8213 IDE driver |
| 3 | * |
| 4 | * Copyright (C) 2006 Jack Lee |
| 5 | * Copyright (C) 2006 Alan Cox |
| 6 | * Copyright (C) 2007 Bartlomiej Zolnierkiewicz |
| 7 | */ |
| 8 | |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 9 | #include <linux/kernel.h> |
| 10 | #include <linux/types.h> |
| 11 | #include <linux/module.h> |
| 12 | #include <linux/pci.h> |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 13 | #include <linux/hdreg.h> |
| 14 | #include <linux/ide.h> |
| 15 | #include <linux/init.h> |
| 16 | |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 17 | /** |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 18 | * it8213_set_pio_mode - set host controller for PIO mode |
| 19 | * @drive: drive |
| 20 | * @pio: PIO mode number |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 21 | * |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 22 | * Set the interface PIO mode. |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 23 | */ |
| 24 | |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 25 | static void it8213_set_pio_mode(ide_drive_t *drive, const u8 pio) |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 26 | { |
| 27 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 28 | struct pci_dev *dev = to_pci_dev(hwif->dev); |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 29 | int is_slave = drive->dn & 1; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 30 | int master_port = 0x40; |
| 31 | int slave_port = 0x44; |
| 32 | unsigned long flags; |
| 33 | u16 master_data; |
| 34 | u8 slave_data; |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 35 | static DEFINE_SPINLOCK(tune_lock); |
| 36 | int control = 0; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 37 | |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 38 | static const u8 timings[][2]= { |
| 39 | { 0, 0 }, |
| 40 | { 0, 0 }, |
| 41 | { 1, 0 }, |
| 42 | { 2, 1 }, |
| 43 | { 2, 3 }, }; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 44 | |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 45 | spin_lock_irqsave(&tune_lock, flags); |
| 46 | pci_read_config_word(dev, master_port, &master_data); |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 47 | |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 48 | if (pio > 1) |
| 49 | control |= 1; /* Programmable timing on */ |
| 50 | if (drive->media != ide_disk) |
| 51 | control |= 4; /* ATAPI */ |
| 52 | if (pio > 2) |
| 53 | control |= 2; /* IORDY */ |
| 54 | if (is_slave) { |
| 55 | master_data |= 0x4000; |
| 56 | master_data &= ~0x0070; |
| 57 | if (pio > 1) |
| 58 | master_data = master_data | (control << 4); |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 59 | pci_read_config_byte(dev, slave_port, &slave_data); |
| 60 | slave_data = slave_data & 0xf0; |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 61 | slave_data = slave_data | (timings[pio][0] << 2) | timings[pio][1]; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 62 | } else { |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 63 | master_data &= ~0x3307; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 64 | if (pio > 1) |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 65 | master_data = master_data | control; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 66 | master_data = master_data | (timings[pio][0] << 12) | (timings[pio][1] << 8); |
| 67 | } |
| 68 | pci_write_config_word(dev, master_port, master_data); |
| 69 | if (is_slave) |
| 70 | pci_write_config_byte(dev, slave_port, slave_data); |
| 71 | spin_unlock_irqrestore(&tune_lock, flags); |
| 72 | } |
| 73 | |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 74 | /** |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 75 | * it8213_set_dma_mode - set host controller for DMA mode |
| 76 | * @drive: drive |
| 77 | * @speed: DMA mode |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 78 | * |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 79 | * Tune the ITE chipset for the DMA mode. |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 80 | */ |
| 81 | |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 82 | static void it8213_set_dma_mode(ide_drive_t *drive, const u8 speed) |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 83 | { |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 84 | ide_hwif_t *hwif = HWIF(drive); |
Bartlomiej Zolnierkiewicz | 3650165 | 2008-02-01 23:09:31 +0100 | [diff] [blame] | 85 | struct pci_dev *dev = to_pci_dev(hwif->dev); |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 86 | u8 maslave = 0x40; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 87 | int a_speed = 3 << (drive->dn * 4); |
| 88 | int u_flag = 1 << drive->dn; |
| 89 | int v_flag = 0x01 << drive->dn; |
| 90 | int w_flag = 0x10 << drive->dn; |
| 91 | int u_speed = 0; |
| 92 | u16 reg4042, reg4a; |
Bartlomiej Zolnierkiewicz | 1c54a93 | 2007-10-16 22:29:56 +0200 | [diff] [blame] | 93 | u8 reg48, reg54, reg55; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 94 | |
| 95 | pci_read_config_word(dev, maslave, ®4042); |
| 96 | pci_read_config_byte(dev, 0x48, ®48); |
| 97 | pci_read_config_word(dev, 0x4a, ®4a); |
| 98 | pci_read_config_byte(dev, 0x54, ®54); |
| 99 | pci_read_config_byte(dev, 0x55, ®55); |
| 100 | |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 101 | if (speed >= XFER_UDMA_0) { |
Bartlomiej Zolnierkiewicz | 4db90a1 | 2008-01-25 22:17:18 +0100 | [diff] [blame] | 102 | u8 udma = speed - XFER_UDMA_0; |
| 103 | |
| 104 | u_speed = min_t(u8, 2 - (udma & 1), udma) << (drive->dn * 4); |
| 105 | |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 106 | if (!(reg48 & u_flag)) |
| 107 | pci_write_config_byte(dev, 0x48, reg48 | u_flag); |
| 108 | if (speed >= XFER_UDMA_5) { |
| 109 | pci_write_config_byte(dev, 0x55, (u8) reg55|w_flag); |
| 110 | } else { |
| 111 | pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag); |
| 112 | } |
| 113 | |
| 114 | if ((reg4a & a_speed) != u_speed) |
| 115 | pci_write_config_word(dev, 0x4a, (reg4a & ~a_speed) | u_speed); |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 116 | if (speed > XFER_UDMA_2) { |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 117 | if (!(reg54 & v_flag)) |
| 118 | pci_write_config_byte(dev, 0x54, reg54 | v_flag); |
| 119 | } else |
| 120 | pci_write_config_byte(dev, 0x54, reg54 & ~v_flag); |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 121 | } else { |
Bartlomiej Zolnierkiewicz | 8c91abf | 2007-10-16 22:29:54 +0200 | [diff] [blame] | 122 | const u8 mwdma_to_pio[] = { 0, 3, 4 }; |
Bartlomiej Zolnierkiewicz | 1c54a93 | 2007-10-16 22:29:56 +0200 | [diff] [blame] | 123 | u8 pio; |
Bartlomiej Zolnierkiewicz | 8c91abf | 2007-10-16 22:29:54 +0200 | [diff] [blame] | 124 | |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 125 | if (reg48 & u_flag) |
| 126 | pci_write_config_byte(dev, 0x48, reg48 & ~u_flag); |
| 127 | if (reg4a & a_speed) |
| 128 | pci_write_config_word(dev, 0x4a, reg4a & ~a_speed); |
| 129 | if (reg54 & v_flag) |
| 130 | pci_write_config_byte(dev, 0x54, reg54 & ~v_flag); |
| 131 | if (reg55 & w_flag) |
| 132 | pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag); |
Bartlomiej Zolnierkiewicz | 8c91abf | 2007-10-16 22:29:54 +0200 | [diff] [blame] | 133 | |
| 134 | if (speed >= XFER_MW_DMA_0) |
| 135 | pio = mwdma_to_pio[speed - XFER_MW_DMA_0]; |
| 136 | else |
| 137 | pio = 2; /* only SWDMA2 is allowed */ |
Bartlomiej Zolnierkiewicz | 68aaf81 | 2007-08-01 23:46:46 +0200 | [diff] [blame] | 138 | |
Bartlomiej Zolnierkiewicz | 1c54a93 | 2007-10-16 22:29:56 +0200 | [diff] [blame] | 139 | it8213_set_pio_mode(drive, pio); |
| 140 | } |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 141 | } |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 142 | |
Bartlomiej Zolnierkiewicz | bfa14b4 | 2008-02-02 19:56:31 +0100 | [diff] [blame] | 143 | static u8 __devinit it8213_cable_detect(ide_hwif_t *hwif) |
| 144 | { |
| 145 | struct pci_dev *dev = to_pci_dev(hwif->dev); |
| 146 | u8 reg42h = 0; |
| 147 | |
| 148 | pci_read_config_byte(dev, 0x42, ®42h); |
| 149 | |
| 150 | return (reg42h & 0x02) ? ATA_CBL_PATA40 : ATA_CBL_PATA80; |
| 151 | } |
| 152 | |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 153 | /** |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 154 | * init_hwif_it8213 - set up hwif structs |
| 155 | * @hwif: interface to set up |
| 156 | * |
Bartlomiej Zolnierkiewicz | 0ae2e17 | 2007-10-16 22:29:55 +0200 | [diff] [blame] | 157 | * We do the basic set up of the interface structure. |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 158 | */ |
| 159 | |
| 160 | static void __devinit init_hwif_it8213(ide_hwif_t *hwif) |
| 161 | { |
Bartlomiej Zolnierkiewicz | 88b2b32 | 2007-10-13 17:47:51 +0200 | [diff] [blame] | 162 | hwif->set_dma_mode = &it8213_set_dma_mode; |
Bartlomiej Zolnierkiewicz | 26bcb87 | 2007-10-11 23:54:00 +0200 | [diff] [blame] | 163 | hwif->set_pio_mode = &it8213_set_pio_mode; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 164 | |
Bartlomiej Zolnierkiewicz | bfa14b4 | 2008-02-02 19:56:31 +0100 | [diff] [blame] | 165 | hwif->cable_detect = it8213_cable_detect; |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | |
| 169 | #define DECLARE_ITE_DEV(name_str) \ |
| 170 | { \ |
| 171 | .name = name_str, \ |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 172 | .init_hwif = init_hwif_it8213, \ |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 173 | .enablebits = {{0x41,0x80,0x80}}, \ |
Bartlomiej Zolnierkiewicz | 5e71d9c | 2008-04-26 17:36:35 +0200 | [diff] [blame] | 174 | .host_flags = IDE_HFLAG_SINGLE, \ |
Bartlomiej Zolnierkiewicz | 4099d14 | 2007-07-20 01:11:59 +0200 | [diff] [blame] | 175 | .pio_mask = ATA_PIO4, \ |
Bartlomiej Zolnierkiewicz | 5f8b6c3 | 2007-10-19 00:30:07 +0200 | [diff] [blame] | 176 | .swdma_mask = ATA_SWDMA2_ONLY, \ |
| 177 | .mwdma_mask = ATA_MWDMA12_ONLY, \ |
| 178 | .udma_mask = ATA_UDMA6, \ |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 179 | } |
| 180 | |
Bartlomiej Zolnierkiewicz | 8562043 | 2007-10-20 00:32:34 +0200 | [diff] [blame] | 181 | static const struct ide_port_info it8213_chipsets[] __devinitdata = { |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 182 | /* 0 */ DECLARE_ITE_DEV("IT8213"), |
| 183 | }; |
| 184 | |
| 185 | |
| 186 | /** |
| 187 | * it8213_init_one - pci layer discovery entry |
| 188 | * @dev: PCI device |
| 189 | * @id: ident table entry |
| 190 | * |
| 191 | * Called by the PCI code when it finds an ITE8213 controller. As |
| 192 | * this device follows the standard interfaces we can use the |
| 193 | * standard helper functions to do almost all the work for us. |
| 194 | */ |
| 195 | |
| 196 | static int __devinit it8213_init_one(struct pci_dev *dev, const struct pci_device_id *id) |
| 197 | { |
| 198 | ide_setup_pci_device(dev, &it8213_chipsets[id->driver_data]); |
| 199 | return 0; |
| 200 | } |
| 201 | |
Bartlomiej Zolnierkiewicz | 9cbcc5e | 2007-10-16 22:29:56 +0200 | [diff] [blame] | 202 | static const struct pci_device_id it8213_pci_tbl[] = { |
| 203 | { PCI_VDEVICE(ITE, PCI_DEVICE_ID_ITE_8213), 0 }, |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 204 | { 0, }, |
| 205 | }; |
| 206 | |
| 207 | MODULE_DEVICE_TABLE(pci, it8213_pci_tbl); |
| 208 | |
| 209 | static struct pci_driver driver = { |
| 210 | .name = "ITE8213_IDE", |
| 211 | .id_table = it8213_pci_tbl, |
| 212 | .probe = it8213_init_one, |
| 213 | }; |
| 214 | |
| 215 | static int __init it8213_ide_init(void) |
| 216 | { |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 217 | return ide_pci_register_driver(&driver); |
| 218 | } |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 219 | |
| 220 | module_init(it8213_ide_init); |
| 221 | |
Bartlomiej Zolnierkiewicz | 6788182 | 2007-02-07 18:19:26 +0100 | [diff] [blame] | 222 | MODULE_AUTHOR("Jack Lee, Alan Cox"); |
Jack Lee | 9c6712c | 2007-02-07 18:19:09 +0100 | [diff] [blame] | 223 | MODULE_DESCRIPTION("PCI driver module for the ITE 8213"); |
| 224 | MODULE_LICENSE("GPL"); |