Commit | Line | Data |
---|---|---|
669a5db4 JG |
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.5" | |
47 | ||
48 | /** | |
c961922b | 49 | * triflex_prereset - probe begin |
669a5db4 JG |
50 | * @ap: ATA port |
51 | * | |
52 | * Set up cable type and use generic probe init | |
53 | */ | |
54 | ||
c961922b | 55 | static int triflex_prereset(struct ata_port *ap) |
669a5db4 JG |
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); | |
85cd7251 | 63 | |
c961922b AC |
64 | if (!pci_test_config_bits(pdev, &triflex_enable_bits[ap->port_no])) |
65 | return -ENOENT; | |
669a5db4 JG |
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 | { | |
c961922b | 74 | ata_bmdma_drive_eh(ap, triflex_prereset, ata_std_softreset, NULL, ata_std_postreset); |
669a5db4 JG |
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 | .max_sectors = ATA_MAX_SECTORS, | |
189 | .cmd_per_lun = ATA_SHT_CMD_PER_LUN, | |
190 | .emulated = ATA_SHT_EMULATED, | |
191 | .use_clustering = ATA_SHT_USE_CLUSTERING, | |
192 | .proc_name = DRV_NAME, | |
193 | .dma_boundary = ATA_DMA_BOUNDARY, | |
194 | .slave_configure = ata_scsi_slave_config, | |
afdfe899 | 195 | .slave_destroy = ata_scsi_slave_destroy, |
669a5db4 JG |
196 | .bios_param = ata_std_bios_param, |
197 | }; | |
198 | ||
199 | static struct ata_port_operations triflex_port_ops = { | |
200 | .port_disable = ata_port_disable, | |
201 | .set_piomode = triflex_set_piomode, | |
202 | .mode_filter = ata_pci_default_filter, | |
203 | ||
204 | .tf_load = ata_tf_load, | |
205 | .tf_read = ata_tf_read, | |
206 | .check_status = ata_check_status, | |
207 | .exec_command = ata_exec_command, | |
208 | .dev_select = ata_std_dev_select, | |
209 | ||
210 | .freeze = ata_bmdma_freeze, | |
211 | .thaw = ata_bmdma_thaw, | |
212 | .error_handler = triflex_error_handler, | |
213 | .post_internal_cmd = ata_bmdma_post_internal_cmd, | |
214 | ||
215 | .bmdma_setup = ata_bmdma_setup, | |
216 | .bmdma_start = triflex_bmdma_start, | |
217 | .bmdma_stop = triflex_bmdma_stop, | |
218 | .bmdma_status = ata_bmdma_status, | |
219 | ||
220 | .qc_prep = ata_qc_prep, | |
221 | .qc_issue = ata_qc_issue_prot, | |
bda30288 | 222 | |
669a5db4 JG |
223 | .data_xfer = ata_pio_data_xfer, |
224 | ||
225 | .irq_handler = ata_interrupt, | |
226 | .irq_clear = ata_bmdma_irq_clear, | |
227 | ||
228 | .port_start = ata_port_start, | |
229 | .port_stop = ata_port_stop, | |
230 | .host_stop = ata_host_stop | |
231 | }; | |
232 | ||
233 | static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id) | |
234 | { | |
235 | static struct ata_port_info info = { | |
236 | .sht = &triflex_sht, | |
237 | .flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST, | |
238 | .pio_mask = 0x1f, | |
239 | .mwdma_mask = 0x07, | |
240 | .port_ops = &triflex_port_ops | |
241 | }; | |
242 | static struct ata_port_info *port_info[2] = { &info, &info }; | |
243 | static int printed_version; | |
244 | ||
245 | if (!printed_version++) | |
246 | dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n"); | |
247 | ||
248 | return ata_pci_init_one(dev, port_info, 2); | |
249 | } | |
250 | ||
251 | static const struct pci_device_id triflex[] = { | |
2d2744fc JG |
252 | { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE), }, |
253 | ||
254 | { }, | |
669a5db4 JG |
255 | }; |
256 | ||
257 | static struct pci_driver triflex_pci_driver = { | |
2d2744fc | 258 | .name = DRV_NAME, |
669a5db4 JG |
259 | .id_table = triflex, |
260 | .probe = triflex_init_one, | |
261 | .remove = ata_pci_remove_one | |
262 | }; | |
263 | ||
264 | static int __init triflex_init(void) | |
265 | { | |
266 | return pci_register_driver(&triflex_pci_driver); | |
267 | } | |
268 | ||
669a5db4 JG |
269 | static void __exit triflex_exit(void) |
270 | { | |
271 | pci_unregister_driver(&triflex_pci_driver); | |
272 | } | |
273 | ||
669a5db4 JG |
274 | MODULE_AUTHOR("Alan Cox"); |
275 | MODULE_DESCRIPTION("low-level driver for Compaq Triflex"); | |
276 | MODULE_LICENSE("GPL"); | |
277 | MODULE_DEVICE_TABLE(pci, triflex); | |
278 | MODULE_VERSION(DRV_VERSION); | |
279 | ||
280 | module_init(triflex_init); | |
281 | module_exit(triflex_exit); |