1 /* 2 * pata_triflex.c - Compaq PATA for new ATA layer 3 * (C) 2005 Red Hat Inc 4 * Alan Cox <alan@redhat.com> 5 * 6 * based upon 7 * 8 * triflex.c 9 * 10 * IDE Chipset driver for the Compaq TriFlex IDE controller. 11 * 12 * Known to work with the Compaq Workstation 5x00 series. 13 * 14 * Copyright (C) 2002 Hewlett-Packard Development Group, L.P. 15 * Author: Torben Mathiasen <torben.mathiasen@hp.com> 16 * 17 * This program is free software; you can redistribute it and/or modify 18 * it under the terms of the GNU General Public License version 2 as 19 * published by the Free Software Foundation. 20 * 21 * This program is distributed in the hope that it will be useful, 22 * but WITHOUT ANY WARRANTY; without even the implied warranty of 23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24 * GNU General Public License for more details. 25 * 26 * You should have received a copy of the GNU General Public License 27 * along with this program; if not, write to the Free Software 28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 29 * 30 * Loosely based on the piix & svwks drivers. 31 * 32 * Documentation: 33 * Not publically available. 34 */ 35 36 #include <linux/kernel.h> 37 #include <linux/module.h> 38 #include <linux/pci.h> 39 #include <linux/init.h> 40 #include <linux/blkdev.h> 41 #include <linux/delay.h> 42 #include <scsi/scsi_host.h> 43 #include <linux/libata.h> 44 45 #define DRV_NAME "pata_triflex" 46 #define DRV_VERSION "0.2.7" 47 48 /** 49 * triflex_prereset - probe begin 50 * @ap: ATA port 51 * 52 * Set up cable type and use generic probe init 53 */ 54 55 static int triflex_prereset(struct ata_port *ap) 56 { 57 static const struct pci_bits triflex_enable_bits[] = { 58 { 0x80, 1, 0x01, 0x01 }, 59 { 0x80, 1, 0x02, 0x02 } 60 }; 61 62 struct pci_dev *pdev = to_pci_dev(ap->host->dev); 63 64 if (!pci_test_config_bits(pdev, &triflex_enable_bits[ap->port_no])) 65 return -ENOENT; 66 ap->cbl = ATA_CBL_PATA40; 67 return ata_std_prereset(ap); 68 } 69 70 71 72 static void triflex_error_handler(struct ata_port *ap) 73 { 74 ata_bmdma_drive_eh(ap, triflex_prereset, ata_std_softreset, NULL, ata_std_postreset); 75 } 76 77 /** 78 * triflex_load_timing - timing configuration 79 * @ap: ATA interface 80 * @adev: Device on the bus 81 * @speed: speed to configure 82 * 83 * The Triflex has one set of timings per device per channel. This 84 * means we must do some switching. As the PIO and DMA timings don't 85 * match we have to do some reloading unlike PIIX devices where tuning 86 * tricks can avoid it. 87 */ 88 89 static void triflex_load_timing(struct ata_port *ap, struct ata_device *adev, int speed) 90 { 91 struct pci_dev *pdev = to_pci_dev(ap->host->dev); 92 u32 timing = 0; 93 u32 triflex_timing, old_triflex_timing; 94 int channel_offset = ap->port_no ? 0x74: 0x70; 95 unsigned int is_slave = (adev->devno != 0); 96 97 98 pci_read_config_dword(pdev, channel_offset, &old_triflex_timing); 99 triflex_timing = old_triflex_timing; 100 101 switch(speed) 102 { 103 case XFER_MW_DMA_2: 104 timing = 0x0103;break; 105 case XFER_MW_DMA_1: 106 timing = 0x0203;break; 107 case XFER_MW_DMA_0: 108 timing = 0x0808;break; 109 case XFER_SW_DMA_2: 110 case XFER_SW_DMA_1: 111 case XFER_SW_DMA_0: 112 timing = 0x0F0F;break; 113 case XFER_PIO_4: 114 timing = 0x0202;break; 115 case XFER_PIO_3: 116 timing = 0x0204;break; 117 case XFER_PIO_2: 118 timing = 0x0404;break; 119 case XFER_PIO_1: 120 timing = 0x0508;break; 121 case XFER_PIO_0: 122 timing = 0x0808;break; 123 default: 124 BUG(); 125 } 126 triflex_timing &= ~ (0xFFFF << (16 * is_slave)); 127 triflex_timing |= (timing << (16 * is_slave)); 128 129 if (triflex_timing != old_triflex_timing) 130 pci_write_config_dword(pdev, channel_offset, triflex_timing); 131 } 132 133 /** 134 * triflex_set_piomode - set initial PIO mode data 135 * @ap: ATA interface 136 * @adev: ATA device 137 * 138 * Use the timing loader to set up the PIO mode. We have to do this 139 * because DMA start/stop will only be called once DMA occurs. If there 140 * has been no DMA then the PIO timings are still needed. 141 */ 142 static void triflex_set_piomode(struct ata_port *ap, struct ata_device *adev) 143 { 144 triflex_load_timing(ap, adev, adev->pio_mode); 145 } 146 147 /** 148 * triflex_dma_start - DMA start callback 149 * @qc: Command in progress 150 * 151 * Usually drivers set the DMA timing at the point the set_dmamode call 152 * is made. Triflex however requires we load new timings on the 153 * transition or keep matching PIO/DMA pairs (ie MWDMA2/PIO4 etc). 154 * We load the DMA timings just before starting DMA and then restore 155 * the PIO timing when the DMA is finished. 156 */ 157 158 static void triflex_bmdma_start(struct ata_queued_cmd *qc) 159 { 160 triflex_load_timing(qc->ap, qc->dev, qc->dev->dma_mode); 161 ata_bmdma_start(qc); 162 } 163 164 /** 165 * triflex_dma_stop - DMA stop callback 166 * @ap: ATA interface 167 * @adev: ATA device 168 * 169 * We loaded new timings in dma_start, as a result we need to restore 170 * the PIO timings in dma_stop so that the next command issue gets the 171 * right clock values. 172 */ 173 174 static void triflex_bmdma_stop(struct ata_queued_cmd *qc) 175 { 176 ata_bmdma_stop(qc); 177 triflex_load_timing(qc->ap, qc->dev, qc->dev->pio_mode); 178 } 179 180 static struct scsi_host_template triflex_sht = { 181 .module = THIS_MODULE, 182 .name = DRV_NAME, 183 .ioctl = ata_scsi_ioctl, 184 .queuecommand = ata_scsi_queuecmd, 185 .can_queue = ATA_DEF_QUEUE, 186 .this_id = ATA_SHT_THIS_ID, 187 .sg_tablesize = LIBATA_MAX_PRD, 188 .cmd_per_lun = ATA_SHT_CMD_PER_LUN, 189 .emulated = ATA_SHT_EMULATED, 190 .use_clustering = ATA_SHT_USE_CLUSTERING, 191 .proc_name = DRV_NAME, 192 .dma_boundary = ATA_DMA_BOUNDARY, 193 .slave_configure = ata_scsi_slave_config, 194 .slave_destroy = ata_scsi_slave_destroy, 195 .bios_param = ata_std_bios_param, 196 #ifdef CONFIG_PM 197 .resume = ata_scsi_device_resume, 198 .suspend = ata_scsi_device_suspend, 199 #endif 200 }; 201 202 static struct ata_port_operations triflex_port_ops = { 203 .port_disable = ata_port_disable, 204 .set_piomode = triflex_set_piomode, 205 .mode_filter = ata_pci_default_filter, 206 207 .tf_load = ata_tf_load, 208 .tf_read = ata_tf_read, 209 .check_status = ata_check_status, 210 .exec_command = ata_exec_command, 211 .dev_select = ata_std_dev_select, 212 213 .freeze = ata_bmdma_freeze, 214 .thaw = ata_bmdma_thaw, 215 .error_handler = triflex_error_handler, 216 .post_internal_cmd = ata_bmdma_post_internal_cmd, 217 218 .bmdma_setup = ata_bmdma_setup, 219 .bmdma_start = triflex_bmdma_start, 220 .bmdma_stop = triflex_bmdma_stop, 221 .bmdma_status = ata_bmdma_status, 222 223 .qc_prep = ata_qc_prep, 224 .qc_issue = ata_qc_issue_prot, 225 226 .data_xfer = ata_data_xfer, 227 228 .irq_handler = ata_interrupt, 229 .irq_clear = ata_bmdma_irq_clear, 230 .irq_on = ata_irq_on, 231 .irq_ack = ata_irq_ack, 232 233 .port_start = ata_port_start, 234 }; 235 236 static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id) 237 { 238 static struct ata_port_info info = { 239 .sht = &triflex_sht, 240 .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST, 241 .pio_mask = 0x1f, 242 .mwdma_mask = 0x07, 243 .port_ops = &triflex_port_ops 244 }; 245 static struct ata_port_info *port_info[2] = { &info, &info }; 246 static int printed_version; 247 248 if (!printed_version++) 249 dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n"); 250 251 return ata_pci_init_one(dev, port_info, 2); 252 } 253 254 static const struct pci_device_id triflex[] = { 255 { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE), }, 256 257 { }, 258 }; 259 260 static struct pci_driver triflex_pci_driver = { 261 .name = DRV_NAME, 262 .id_table = triflex, 263 .probe = triflex_init_one, 264 .remove = ata_pci_remove_one, 265 #ifdef CONFIG_PM 266 .suspend = ata_pci_device_suspend, 267 .resume = ata_pci_device_resume, 268 #endif 269 }; 270 271 static int __init triflex_init(void) 272 { 273 return pci_register_driver(&triflex_pci_driver); 274 } 275 276 static void __exit triflex_exit(void) 277 { 278 pci_unregister_driver(&triflex_pci_driver); 279 } 280 281 MODULE_AUTHOR("Alan Cox"); 282 MODULE_DESCRIPTION("low-level driver for Compaq Triflex"); 283 MODULE_LICENSE("GPL"); 284 MODULE_DEVICE_TABLE(pci, triflex); 285 MODULE_VERSION(DRV_VERSION); 286 287 module_init(triflex_init); 288 module_exit(triflex_exit); 289