Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/drivers/ide/legacy/ht6560b.c Version 0.07 Feb 1, 2000 | |
3 | * | |
4 | * Copyright (C) 1995-2000 Linus Torvalds & author (see below) | |
5 | */ | |
6 | ||
7 | /* | |
8 | * | |
9 | * Version 0.01 Initial version hacked out of ide.c | |
10 | * | |
11 | * Version 0.02 Added support for PIO modes, auto-tune | |
12 | * | |
13 | * Version 0.03 Some cleanups | |
14 | * | |
15 | * Version 0.05 PIO mode cycle timings auto-tune using bus-speed | |
16 | * | |
17 | * Version 0.06 Prefetch mode now defaults no OFF. To set | |
18 | * prefetch mode OFF/ON use "hdparm -p8/-p9". | |
19 | * Unmask irq is disabled when prefetch mode | |
20 | * is enabled. | |
21 | * | |
22 | * Version 0.07 Trying to fix CD-ROM detection problem. | |
23 | * "Prefetch" mode bit OFF for ide disks and | |
24 | * ON for anything else. | |
25 | * | |
26 | * | |
27 | * HT-6560B EIDE-controller support | |
28 | * To activate controller support use kernel parameter "ide0=ht6560b". | |
29 | * Use hdparm utility to enable PIO mode support. | |
30 | * | |
31 | * Author: Mikko Ala-Fossi <maf@iki.fi> | |
32 | * Jan Evert van Grootheest <janevert@iae.nl> | |
33 | * | |
34 | * Try: http://www.maf.iki.fi/~maf/ht6560b/ | |
35 | */ | |
36 | ||
37 | #define HT6560B_VERSION "v0.07" | |
38 | ||
1da177e4 | 39 | #include <linux/module.h> |
1da177e4 LT |
40 | #include <linux/types.h> |
41 | #include <linux/kernel.h> | |
42 | #include <linux/delay.h> | |
43 | #include <linux/timer.h> | |
44 | #include <linux/mm.h> | |
45 | #include <linux/ioport.h> | |
46 | #include <linux/blkdev.h> | |
47 | #include <linux/hdreg.h> | |
48 | #include <linux/ide.h> | |
49 | #include <linux/init.h> | |
50 | ||
51 | #include <asm/io.h> | |
52 | ||
53 | /* #define DEBUG */ /* remove comments for DEBUG messages */ | |
54 | ||
55 | /* | |
56 | * The special i/o-port that HT-6560B uses to configuration: | |
57 | * bit0 (0x01): "1" selects secondary interface | |
58 | * bit2 (0x04): "1" enables FIFO function | |
59 | * bit5 (0x20): "1" enables prefetched data read function (???) | |
60 | * | |
61 | * The special i/o-port that HT-6560A uses to configuration: | |
62 | * bit0 (0x01): "1" selects secondary interface | |
63 | * bit1 (0x02): "1" enables prefetched data read function | |
64 | * bit2 (0x04): "0" enables multi-master system (?) | |
65 | * bit3 (0x08): "1" 3 cycle time, "0" 2 cycle time (?) | |
66 | */ | |
67 | #define HT_CONFIG_PORT 0x3e6 | |
68 | #define HT_CONFIG(drivea) (u8)(((drivea)->drive_data & 0xff00) >> 8) | |
69 | /* | |
70 | * FIFO + PREFETCH (both a/b-model) | |
71 | */ | |
72 | #define HT_CONFIG_DEFAULT 0x1c /* no prefetch */ | |
73 | /* #define HT_CONFIG_DEFAULT 0x3c */ /* with prefetch */ | |
74 | #define HT_SECONDARY_IF 0x01 | |
75 | #define HT_PREFETCH_MODE 0x20 | |
76 | ||
77 | /* | |
78 | * ht6560b Timing values: | |
79 | * | |
80 | * I reviewed some assembler source listings of htide drivers and found | |
81 | * out how they setup those cycle time interfacing values, as they at Holtek | |
82 | * call them. IDESETUP.COM that is supplied with the drivers figures out | |
83 | * optimal values and fetches those values to drivers. I found out that | |
84 | * they use IDE_SELECT_REG to fetch timings to the ide board right after | |
85 | * interface switching. After that it was quite easy to add code to | |
86 | * ht6560b.c. | |
87 | * | |
88 | * IDESETUP.COM gave me values 0x24, 0x45, 0xaa, 0xff that worked fine | |
89 | * for hda and hdc. But hdb needed higher values to work, so I guess | |
90 | * that sometimes it is necessary to give higher value than IDESETUP | |
91 | * gives. [see cmd640.c for an extreme example of this. -ml] | |
92 | * | |
93 | * Perhaps I should explain something about these timing values: | |
94 | * The higher nibble of value is the Recovery Time (rt) and the lower nibble | |
95 | * of the value is the Active Time (at). Minimum value 2 is the fastest and | |
96 | * the maximum value 15 is the slowest. Default values should be 15 for both. | |
97 | * So 0x24 means 2 for rt and 4 for at. Each of the drives should have | |
98 | * both values, and IDESETUP gives automatically rt=15 st=15 for CDROMs or | |
99 | * similar. If value is too small there will be all sorts of failures. | |
100 | * | |
101 | * Timing byte consists of | |
102 | * High nibble: Recovery Cycle Time (rt) | |
103 | * The valid values range from 2 to 15. The default is 15. | |
104 | * | |
105 | * Low nibble: Active Cycle Time (at) | |
106 | * The valid values range from 2 to 15. The default is 15. | |
107 | * | |
108 | * You can obtain optimized timing values by running Holtek IDESETUP.COM | |
109 | * for DOS. DOS drivers get their timing values from command line, where | |
110 | * the first value is the Recovery Time and the second value is the | |
111 | * Active Time for each drive. Smaller value gives higher speed. | |
112 | * In case of failures you should probably fall back to a higher value. | |
113 | */ | |
114 | #define HT_TIMING(drivea) (u8)((drivea)->drive_data & 0x00ff) | |
115 | #define HT_TIMING_DEFAULT 0xff | |
116 | ||
117 | /* | |
118 | * This routine handles interface switching for the peculiar hardware design | |
119 | * on the F.G.I./Holtek HT-6560B VLB IDE interface. | |
120 | * The HT-6560B can only enable one IDE port at a time, and requires a | |
121 | * silly sequence (below) whenever we switch between primary and secondary. | |
122 | */ | |
123 | ||
124 | /* | |
125 | * This routine is invoked from ide.c to prepare for access to a given drive. | |
126 | */ | |
127 | static void ht6560b_selectproc (ide_drive_t *drive) | |
128 | { | |
129 | unsigned long flags; | |
130 | static u8 current_select = 0; | |
131 | static u8 current_timing = 0; | |
132 | u8 select, timing; | |
133 | ||
134 | local_irq_save(flags); | |
135 | ||
136 | select = HT_CONFIG(drive); | |
137 | timing = HT_TIMING(drive); | |
138 | ||
139 | if (select != current_select || timing != current_timing) { | |
140 | current_select = select; | |
141 | current_timing = timing; | |
142 | if (drive->media != ide_disk || !drive->present) | |
143 | select |= HT_PREFETCH_MODE; | |
0ecdca26 BZ |
144 | (void)inb(HT_CONFIG_PORT); |
145 | (void)inb(HT_CONFIG_PORT); | |
146 | (void)inb(HT_CONFIG_PORT); | |
147 | (void)inb(HT_CONFIG_PORT); | |
148 | outb(select, HT_CONFIG_PORT); | |
1da177e4 LT |
149 | /* |
150 | * Set timing for this drive: | |
151 | */ | |
0ecdca26 BZ |
152 | outb(timing, IDE_SELECT_REG); |
153 | (void)inb(IDE_STATUS_REG); | |
1da177e4 LT |
154 | #ifdef DEBUG |
155 | printk("ht6560b: %s: select=%#x timing=%#x\n", | |
156 | drive->name, select, timing); | |
157 | #endif | |
158 | } | |
159 | local_irq_restore(flags); | |
160 | } | |
161 | ||
162 | /* | |
163 | * Autodetection and initialization of ht6560b | |
164 | */ | |
165 | static int __init try_to_init_ht6560b(void) | |
166 | { | |
167 | u8 orig_value; | |
168 | int i; | |
169 | ||
170 | /* Autodetect ht6560b */ | |
171 | if ((orig_value = inb(HT_CONFIG_PORT)) == 0xff) | |
172 | return 0; | |
173 | ||
174 | for (i=3;i>0;i--) { | |
175 | outb(0x00, HT_CONFIG_PORT); | |
176 | if (!( (~inb(HT_CONFIG_PORT)) & 0x3f )) { | |
177 | outb(orig_value, HT_CONFIG_PORT); | |
178 | return 0; | |
179 | } | |
180 | } | |
181 | outb(0x00, HT_CONFIG_PORT); | |
182 | if ((~inb(HT_CONFIG_PORT))& 0x3f) { | |
183 | outb(orig_value, HT_CONFIG_PORT); | |
184 | return 0; | |
185 | } | |
186 | /* | |
187 | * Ht6560b autodetected | |
188 | */ | |
189 | outb(HT_CONFIG_DEFAULT, HT_CONFIG_PORT); | |
190 | outb(HT_TIMING_DEFAULT, 0x1f6); /* IDE_SELECT_REG */ | |
191 | (void) inb(0x1f7); /* IDE_STATUS_REG */ | |
192 | ||
193 | printk("\nht6560b " HT6560B_VERSION | |
194 | ": chipset detected and initialized" | |
195 | #ifdef DEBUG | |
196 | " with debug enabled" | |
197 | #endif | |
198 | ); | |
199 | return 1; | |
200 | } | |
201 | ||
202 | static u8 ht_pio2timings(ide_drive_t *drive, u8 pio) | |
203 | { | |
204 | int active_time, recovery_time; | |
205 | int active_cycles, recovery_cycles; | |
206 | ide_pio_data_t d; | |
207 | int bus_speed = system_bus_clock(); | |
208 | ||
209 | if (pio) { | |
210 | pio = ide_get_best_pio_mode(drive, pio, 5, &d); | |
211 | ||
212 | /* | |
213 | * Just like opti621.c we try to calculate the | |
214 | * actual cycle time for recovery and activity | |
215 | * according system bus speed. | |
216 | */ | |
217 | active_time = ide_pio_timings[pio].active_time; | |
218 | recovery_time = d.cycle_time | |
219 | - active_time | |
220 | - ide_pio_timings[pio].setup_time; | |
221 | /* | |
222 | * Cycle times should be Vesa bus cycles | |
223 | */ | |
224 | active_cycles = (active_time * bus_speed + 999) / 1000; | |
225 | recovery_cycles = (recovery_time * bus_speed + 999) / 1000; | |
226 | /* | |
227 | * Upper and lower limits | |
228 | */ | |
229 | if (active_cycles < 2) active_cycles = 2; | |
230 | if (recovery_cycles < 2) recovery_cycles = 2; | |
231 | if (active_cycles > 15) active_cycles = 15; | |
232 | if (recovery_cycles > 15) recovery_cycles = 0; /* 0==16 */ | |
233 | ||
234 | #ifdef DEBUG | |
235 | printk("ht6560b: drive %s setting pio=%d recovery=%d (%dns) active=%d (%dns)\n", drive->name, pio, recovery_cycles, recovery_time, active_cycles, active_time); | |
236 | #endif | |
237 | ||
238 | return (u8)((recovery_cycles << 4) | active_cycles); | |
239 | } else { | |
240 | ||
241 | #ifdef DEBUG | |
242 | printk("ht6560b: drive %s setting pio=0\n", drive->name); | |
243 | #endif | |
244 | ||
245 | return HT_TIMING_DEFAULT; /* default setting */ | |
246 | } | |
247 | } | |
248 | ||
249 | /* | |
250 | * Enable/Disable so called prefetch mode | |
251 | */ | |
252 | static void ht_set_prefetch(ide_drive_t *drive, u8 state) | |
253 | { | |
254 | unsigned long flags; | |
255 | int t = HT_PREFETCH_MODE << 8; | |
256 | ||
257 | spin_lock_irqsave(&ide_lock, flags); | |
258 | ||
259 | /* | |
260 | * Prefetch mode and unmask irq seems to conflict | |
261 | */ | |
262 | if (state) { | |
263 | drive->drive_data |= t; /* enable prefetch mode */ | |
264 | drive->no_unmask = 1; | |
265 | drive->unmask = 0; | |
266 | } else { | |
267 | drive->drive_data &= ~t; /* disable prefetch mode */ | |
268 | drive->no_unmask = 0; | |
269 | } | |
270 | ||
271 | spin_unlock_irqrestore(&ide_lock, flags); | |
272 | ||
273 | #ifdef DEBUG | |
274 | printk("ht6560b: drive %s prefetch mode %sabled\n", drive->name, (state ? "en" : "dis")); | |
275 | #endif | |
276 | } | |
277 | ||
278 | static void tune_ht6560b (ide_drive_t *drive, u8 pio) | |
279 | { | |
280 | unsigned long flags; | |
281 | u8 timing; | |
282 | ||
283 | switch (pio) { | |
284 | case 8: /* set prefetch off */ | |
285 | case 9: /* set prefetch on */ | |
286 | ht_set_prefetch(drive, pio & 1); | |
287 | return; | |
288 | } | |
289 | ||
290 | timing = ht_pio2timings(drive, pio); | |
291 | ||
292 | spin_lock_irqsave(&ide_lock, flags); | |
293 | ||
294 | drive->drive_data &= 0xff00; | |
295 | drive->drive_data |= timing; | |
296 | ||
297 | spin_unlock_irqrestore(&ide_lock, flags); | |
298 | ||
299 | #ifdef DEBUG | |
300 | printk("ht6560b: drive %s tuned to pio mode %#x timing=%#x\n", drive->name, pio, timing); | |
301 | #endif | |
302 | } | |
303 | ||
84913882 BZ |
304 | int probe_ht6560b = 0; |
305 | ||
306 | module_param_named(probe, probe_ht6560b, bool, 0); | |
307 | MODULE_PARM_DESC(probe, "probe for HT6560B chipset"); | |
308 | ||
1da177e4 LT |
309 | /* Can be called directly from ide.c. */ |
310 | int __init ht6560b_init(void) | |
311 | { | |
312 | ide_hwif_t *hwif, *mate; | |
313 | int t; | |
314 | ||
84913882 BZ |
315 | if (probe_ht6560b == 0) |
316 | return -ENODEV; | |
317 | ||
1da177e4 LT |
318 | hwif = &ide_hwifs[0]; |
319 | mate = &ide_hwifs[1]; | |
320 | ||
321 | if (!request_region(HT_CONFIG_PORT, 1, hwif->name)) { | |
322 | printk(KERN_NOTICE "%s: HT_CONFIG_PORT not found\n", | |
323 | __FUNCTION__); | |
324 | return -ENODEV; | |
325 | } | |
326 | ||
327 | if (!try_to_init_ht6560b()) { | |
328 | printk(KERN_NOTICE "%s: HBA not found\n", __FUNCTION__); | |
329 | goto release_region; | |
330 | } | |
331 | ||
332 | hwif->chipset = ide_ht6560b; | |
333 | hwif->selectproc = &ht6560b_selectproc; | |
334 | hwif->tuneproc = &tune_ht6560b; | |
335 | hwif->serialized = 1; /* is this needed? */ | |
336 | hwif->mate = mate; | |
337 | ||
338 | mate->chipset = ide_ht6560b; | |
339 | mate->selectproc = &ht6560b_selectproc; | |
340 | mate->tuneproc = &tune_ht6560b; | |
341 | mate->serialized = 1; /* is this needed? */ | |
342 | mate->mate = hwif; | |
343 | mate->channel = 1; | |
344 | ||
345 | /* | |
346 | * Setting default configurations for drives | |
347 | */ | |
348 | t = (HT_CONFIG_DEFAULT << 8); | |
349 | t |= HT_TIMING_DEFAULT; | |
350 | hwif->drives[0].drive_data = t; | |
351 | hwif->drives[1].drive_data = t; | |
352 | ||
353 | t |= (HT_SECONDARY_IF << 8); | |
354 | mate->drives[0].drive_data = t; | |
355 | mate->drives[1].drive_data = t; | |
356 | ||
357 | probe_hwif_init(hwif); | |
358 | probe_hwif_init(mate); | |
359 | ||
360 | create_proc_ide_interfaces(); | |
361 | ||
362 | return 0; | |
363 | ||
364 | release_region: | |
365 | release_region(HT_CONFIG_PORT, 1); | |
366 | return -ENODEV; | |
367 | } | |
368 | ||
369 | #ifdef MODULE | |
370 | module_init(ht6560b_init); | |
371 | #endif | |
372 | ||
373 | MODULE_AUTHOR("See Local File"); | |
374 | MODULE_DESCRIPTION("HT-6560B EIDE-controller support"); | |
375 | MODULE_LICENSE("GPL"); |