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