Loading...
1/*
2 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
3 * Copyright (C) 2003 Red Hat
4 *
5 */
6
7#include <linux/module.h>
8#include <linux/types.h>
9#include <linux/string.h>
10#include <linux/kernel.h>
11#include <linux/timer.h>
12#include <linux/mm.h>
13#include <linux/interrupt.h>
14#include <linux/major.h>
15#include <linux/errno.h>
16#include <linux/genhd.h>
17#include <linux/blkpg.h>
18#include <linux/slab.h>
19#include <linux/pci.h>
20#include <linux/delay.h>
21#include <linux/ide.h>
22#include <linux/bitops.h>
23#include <linux/nmi.h>
24
25#include <asm/byteorder.h>
26#include <asm/irq.h>
27#include <asm/uaccess.h>
28#include <asm/io.h>
29
30void SELECT_MASK(ide_drive_t *drive, int mask)
31{
32 const struct ide_port_ops *port_ops = drive->hwif->port_ops;
33
34 if (port_ops && port_ops->maskproc)
35 port_ops->maskproc(drive, mask);
36}
37
38u8 ide_read_error(ide_drive_t *drive)
39{
40 struct ide_taskfile tf;
41
42 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
43
44 return tf.error;
45}
46EXPORT_SYMBOL_GPL(ide_read_error);
47
48void ide_fix_driveid(u16 *id)
49{
50#ifndef __LITTLE_ENDIAN
51# ifdef __BIG_ENDIAN
52 int i;
53
54 for (i = 0; i < 256; i++)
55 id[i] = __le16_to_cpu(id[i]);
56# else
57# error "Please fix <asm/byteorder.h>"
58# endif
59#endif
60}
61
62/*
63 * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
64 * removing leading/trailing blanks and compressing internal blanks.
65 * It is primarily used to tidy up the model name/number fields as
66 * returned by the ATA_CMD_ID_ATA[PI] commands.
67 */
68
69void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
70{
71 u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
72
73 if (byteswap) {
74 /* convert from big-endian to host byte order */
75 for (p = s ; p != end ; p += 2)
76 be16_to_cpus((u16 *) p);
77 }
78
79 /* strip leading blanks */
80 p = s;
81 while (s != end && *s == ' ')
82 ++s;
83 /* compress internal blanks and strip trailing blanks */
84 while (s != end && *s) {
85 if (*s++ != ' ' || (s != end && *s && *s != ' '))
86 *p++ = *(s-1);
87 }
88 /* wipe out trailing garbage */
89 while (p != end)
90 *p++ = '\0';
91}
92EXPORT_SYMBOL(ide_fixstring);
93
94/*
95 * This routine busy-waits for the drive status to be not "busy".
96 * It then checks the status for all of the "good" bits and none
97 * of the "bad" bits, and if all is okay it returns 0. All other
98 * cases return error -- caller may then invoke ide_error().
99 *
100 * This routine should get fixed to not hog the cpu during extra long waits..
101 * That could be done by busy-waiting for the first jiffy or two, and then
102 * setting a timer to wake up at half second intervals thereafter,
103 * until timeout is achieved, before timing out.
104 */
105int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
106 unsigned long timeout, u8 *rstat)
107{
108 ide_hwif_t *hwif = drive->hwif;
109 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
110 unsigned long flags;
111 int i;
112 u8 stat;
113
114 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
115 stat = tp_ops->read_status(hwif);
116
117 if (stat & ATA_BUSY) {
118 local_save_flags(flags);
119 local_irq_enable_in_hardirq();
120 timeout += jiffies;
121 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
122 if (time_after(jiffies, timeout)) {
123 /*
124 * One last read after the timeout in case
125 * heavy interrupt load made us not make any
126 * progress during the timeout..
127 */
128 stat = tp_ops->read_status(hwif);
129 if ((stat & ATA_BUSY) == 0)
130 break;
131
132 local_irq_restore(flags);
133 *rstat = stat;
134 return -EBUSY;
135 }
136 }
137 local_irq_restore(flags);
138 }
139 /*
140 * Allow status to settle, then read it again.
141 * A few rare drives vastly violate the 400ns spec here,
142 * so we'll wait up to 10usec for a "good" status
143 * rather than expensively fail things immediately.
144 * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
145 */
146 for (i = 0; i < 10; i++) {
147 udelay(1);
148 stat = tp_ops->read_status(hwif);
149
150 if (OK_STAT(stat, good, bad)) {
151 *rstat = stat;
152 return 0;
153 }
154 }
155 *rstat = stat;
156 return -EFAULT;
157}
158
159/*
160 * In case of error returns error value after doing "*startstop = ide_error()".
161 * The caller should return the updated value of "startstop" in this case,
162 * "startstop" is unchanged when the function returns 0.
163 */
164int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
165 u8 bad, unsigned long timeout)
166{
167 int err;
168 u8 stat;
169
170 /* bail early if we've exceeded max_failures */
171 if (drive->max_failures && (drive->failures > drive->max_failures)) {
172 *startstop = ide_stopped;
173 return 1;
174 }
175
176 err = __ide_wait_stat(drive, good, bad, timeout, &stat);
177
178 if (err) {
179 char *s = (err == -EBUSY) ? "status timeout" : "status error";
180 *startstop = ide_error(drive, s, stat);
181 }
182
183 return err;
184}
185EXPORT_SYMBOL(ide_wait_stat);
186
187/**
188 * ide_in_drive_list - look for drive in black/white list
189 * @id: drive identifier
190 * @table: list to inspect
191 *
192 * Look for a drive in the blacklist and the whitelist tables
193 * Returns 1 if the drive is found in the table.
194 */
195
196int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
197{
198 for ( ; table->id_model; table++)
199 if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
200 (!table->id_firmware ||
201 strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
202 return 1;
203 return 0;
204}
205EXPORT_SYMBOL_GPL(ide_in_drive_list);
206
207/*
208 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
209 * Some optical devices with the buggy firmwares have the same problem.
210 */
211static const struct drive_list_entry ivb_list[] = {
212 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
213 { "QUANTUM FIREBALLlct20 30" , "APL.0900" },
214 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
215 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
216 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
217 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
218 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
219 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
220 { "SAMSUNG SP0822N" , "WA100-10" },
221 { NULL , NULL }
222};
223
224/*
225 * All hosts that use the 80c ribbon must use!
226 * The name is derived from upper byte of word 93 and the 80c ribbon.
227 */
228u8 eighty_ninty_three(ide_drive_t *drive)
229{
230 ide_hwif_t *hwif = drive->hwif;
231 u16 *id = drive->id;
232 int ivb = ide_in_drive_list(id, ivb_list);
233
234 if (hwif->cbl == ATA_CBL_SATA || hwif->cbl == ATA_CBL_PATA40_SHORT)
235 return 1;
236
237 if (ivb)
238 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
239 drive->name);
240
241 if (ata_id_is_sata(id) && !ivb)
242 return 1;
243
244 if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
245 goto no_80w;
246
247 /*
248 * FIXME:
249 * - change master/slave IDENTIFY order
250 * - force bit13 (80c cable present) check also for !ivb devices
251 * (unless the slave device is pre-ATA3)
252 */
253 if (id[ATA_ID_HW_CONFIG] & 0x4000)
254 return 1;
255
256 if (ivb) {
257 const char *model = (char *)&id[ATA_ID_PROD];
258
259 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
260 /*
261 * These ATAPI devices always report 80c cable
262 * so we have to depend on the host in this case.
263 */
264 if (hwif->cbl == ATA_CBL_PATA80)
265 return 1;
266 } else {
267 /* Depend on the device side cable detection. */
268 if (id[ATA_ID_HW_CONFIG] & 0x2000)
269 return 1;
270 }
271 }
272no_80w:
273 if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
274 return 0;
275
276 printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
277 "limiting max speed to UDMA33\n",
278 drive->name,
279 hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
280
281 drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
282
283 return 0;
284}
285
286static const char *nien_quirk_list[] = {
287 "QUANTUM FIREBALLlct08 08",
288 "QUANTUM FIREBALLP KA6.4",
289 "QUANTUM FIREBALLP KA9.1",
290 "QUANTUM FIREBALLP KX13.6",
291 "QUANTUM FIREBALLP KX20.5",
292 "QUANTUM FIREBALLP KX27.3",
293 "QUANTUM FIREBALLP LM20.4",
294 "QUANTUM FIREBALLP LM20.5",
295 "FUJITSU MHZ2160BH G2",
296 NULL
297};
298
299void ide_check_nien_quirk_list(ide_drive_t *drive)
300{
301 const char **list, *m = (char *)&drive->id[ATA_ID_PROD];
302
303 for (list = nien_quirk_list; *list != NULL; list++)
304 if (strstr(m, *list) != NULL) {
305 drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
306 return;
307 }
308}
309
310int ide_driveid_update(ide_drive_t *drive)
311{
312 u16 *id;
313 int rc;
314
315 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
316 if (id == NULL)
317 return 0;
318
319 SELECT_MASK(drive, 1);
320 rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
321 SELECT_MASK(drive, 0);
322
323 if (rc)
324 goto out_err;
325
326 drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES];
327 drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
328 drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
329 drive->id[ATA_ID_CFA_MODES] = id[ATA_ID_CFA_MODES];
330 /* anything more ? */
331
332 kfree(id);
333
334 return 1;
335out_err:
336 if (rc == 2)
337 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
338 kfree(id);
339 return 0;
340}
341
342int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
343{
344 ide_hwif_t *hwif = drive->hwif;
345 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
346 struct ide_taskfile tf;
347 u16 *id = drive->id, i;
348 int error = 0;
349 u8 stat;
350
351#ifdef CONFIG_BLK_DEV_IDEDMA
352 if (hwif->dma_ops) /* check if host supports DMA */
353 hwif->dma_ops->dma_host_set(drive, 0);
354#endif
355
356 /* Skip setting PIO flow-control modes on pre-EIDE drives */
357 if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
358 goto skip;
359
360 /*
361 * Don't use ide_wait_cmd here - it will
362 * attempt to set_geometry and recalibrate,
363 * but for some reason these don't work at
364 * this point (lost interrupt).
365 */
366
367 udelay(1);
368 tp_ops->dev_select(drive);
369 SELECT_MASK(drive, 1);
370 udelay(1);
371 tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
372
373 memset(&tf, 0, sizeof(tf));
374 tf.feature = SETFEATURES_XFER;
375 tf.nsect = speed;
376
377 tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
378
379 tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
380
381 if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
382 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
383
384 error = __ide_wait_stat(drive, drive->ready_stat,
385 ATA_BUSY | ATA_DRQ | ATA_ERR,
386 WAIT_CMD, &stat);
387
388 SELECT_MASK(drive, 0);
389
390 if (error) {
391 (void) ide_dump_status(drive, "set_drive_speed_status", stat);
392 return error;
393 }
394
395 if (speed >= XFER_SW_DMA_0) {
396 id[ATA_ID_UDMA_MODES] &= ~0xFF00;
397 id[ATA_ID_MWDMA_MODES] &= ~0x0700;
398 id[ATA_ID_SWDMA_MODES] &= ~0x0700;
399 if (ata_id_is_cfa(id))
400 id[ATA_ID_CFA_MODES] &= ~0x0E00;
401 } else if (ata_id_is_cfa(id))
402 id[ATA_ID_CFA_MODES] &= ~0x01C0;
403
404 skip:
405#ifdef CONFIG_BLK_DEV_IDEDMA
406 if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
407 hwif->dma_ops->dma_host_set(drive, 1);
408 else if (hwif->dma_ops) /* check if host supports DMA */
409 ide_dma_off_quietly(drive);
410#endif
411
412 if (speed >= XFER_UDMA_0) {
413 i = 1 << (speed - XFER_UDMA_0);
414 id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
415 } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
416 i = speed - XFER_MW_DMA_2;
417 id[ATA_ID_CFA_MODES] |= i << 9;
418 } else if (speed >= XFER_MW_DMA_0) {
419 i = 1 << (speed - XFER_MW_DMA_0);
420 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
421 } else if (speed >= XFER_SW_DMA_0) {
422 i = 1 << (speed - XFER_SW_DMA_0);
423 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
424 } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
425 i = speed - XFER_PIO_4;
426 id[ATA_ID_CFA_MODES] |= i << 6;
427 }
428
429 if (!drive->init_speed)
430 drive->init_speed = speed;
431 drive->current_speed = speed;
432 return error;
433}
434
435/*
436 * This should get invoked any time we exit the driver to
437 * wait for an interrupt response from a drive. handler() points
438 * at the appropriate code to handle the next interrupt, and a
439 * timer is started to prevent us from waiting forever in case
440 * something goes wrong (see the ide_timer_expiry() handler later on).
441 *
442 * See also ide_execute_command
443 */
444void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
445 unsigned int timeout)
446{
447 ide_hwif_t *hwif = drive->hwif;
448
449 BUG_ON(hwif->handler);
450 hwif->handler = handler;
451 hwif->timer.expires = jiffies + timeout;
452 hwif->req_gen_timer = hwif->req_gen;
453 add_timer(&hwif->timer);
454}
455
456void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
457 unsigned int timeout)
458{
459 ide_hwif_t *hwif = drive->hwif;
460 unsigned long flags;
461
462 spin_lock_irqsave(&hwif->lock, flags);
463 __ide_set_handler(drive, handler, timeout);
464 spin_unlock_irqrestore(&hwif->lock, flags);
465}
466EXPORT_SYMBOL(ide_set_handler);
467
468/**
469 * ide_execute_command - execute an IDE command
470 * @drive: IDE drive to issue the command against
471 * @cmd: command
472 * @handler: handler for next phase
473 * @timeout: timeout for command
474 *
475 * Helper function to issue an IDE command. This handles the
476 * atomicity requirements, command timing and ensures that the
477 * handler and IRQ setup do not race. All IDE command kick off
478 * should go via this function or do equivalent locking.
479 */
480
481void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
482 ide_handler_t *handler, unsigned timeout)
483{
484 ide_hwif_t *hwif = drive->hwif;
485 unsigned long flags;
486
487 spin_lock_irqsave(&hwif->lock, flags);
488 if ((cmd->protocol != ATAPI_PROT_DMA &&
489 cmd->protocol != ATAPI_PROT_PIO) ||
490 (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
491 __ide_set_handler(drive, handler, timeout);
492 hwif->tp_ops->exec_command(hwif, cmd->tf.command);
493 /*
494 * Drive takes 400nS to respond, we must avoid the IRQ being
495 * serviced before that.
496 *
497 * FIXME: we could skip this delay with care on non shared devices
498 */
499 ndelay(400);
500 spin_unlock_irqrestore(&hwif->lock, flags);
501}
502
503/*
504 * ide_wait_not_busy() waits for the currently selected device on the hwif
505 * to report a non-busy status, see comments in ide_probe_port().
506 */
507int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
508{
509 u8 stat = 0;
510
511 while (timeout--) {
512 /*
513 * Turn this into a schedule() sleep once I'm sure
514 * about locking issues (2.5 work ?).
515 */
516 mdelay(1);
517 stat = hwif->tp_ops->read_status(hwif);
518 if ((stat & ATA_BUSY) == 0)
519 return 0;
520 /*
521 * Assume a value of 0xff means nothing is connected to
522 * the interface and it doesn't implement the pull-down
523 * resistor on D7.
524 */
525 if (stat == 0xff)
526 return -ENODEV;
527 touch_softlockup_watchdog();
528 touch_nmi_watchdog();
529 }
530 return -EBUSY;
531}
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
4 * Copyright (C) 2003 Red Hat
5 *
6 */
7
8#include <linux/module.h>
9#include <linux/types.h>
10#include <linux/string.h>
11#include <linux/kernel.h>
12#include <linux/timer.h>
13#include <linux/mm.h>
14#include <linux/interrupt.h>
15#include <linux/major.h>
16#include <linux/errno.h>
17#include <linux/genhd.h>
18#include <linux/blkpg.h>
19#include <linux/slab.h>
20#include <linux/pci.h>
21#include <linux/delay.h>
22#include <linux/ide.h>
23#include <linux/bitops.h>
24#include <linux/nmi.h>
25
26#include <asm/byteorder.h>
27#include <asm/irq.h>
28#include <linux/uaccess.h>
29#include <asm/io.h>
30
31void SELECT_MASK(ide_drive_t *drive, int mask)
32{
33 const struct ide_port_ops *port_ops = drive->hwif->port_ops;
34
35 if (port_ops && port_ops->maskproc)
36 port_ops->maskproc(drive, mask);
37}
38
39u8 ide_read_error(ide_drive_t *drive)
40{
41 struct ide_taskfile tf;
42
43 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
44
45 return tf.error;
46}
47EXPORT_SYMBOL_GPL(ide_read_error);
48
49void ide_fix_driveid(u16 *id)
50{
51#ifndef __LITTLE_ENDIAN
52# ifdef __BIG_ENDIAN
53 int i;
54
55 for (i = 0; i < 256; i++)
56 id[i] = __le16_to_cpu(id[i]);
57# else
58# error "Please fix <asm/byteorder.h>"
59# endif
60#endif
61}
62
63/*
64 * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
65 * removing leading/trailing blanks and compressing internal blanks.
66 * It is primarily used to tidy up the model name/number fields as
67 * returned by the ATA_CMD_ID_ATA[PI] commands.
68 */
69
70void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
71{
72 u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
73
74 if (byteswap) {
75 /* convert from big-endian to host byte order */
76 for (p = s ; p != end ; p += 2)
77 be16_to_cpus((u16 *) p);
78 }
79
80 /* strip leading blanks */
81 p = s;
82 while (s != end && *s == ' ')
83 ++s;
84 /* compress internal blanks and strip trailing blanks */
85 while (s != end && *s) {
86 if (*s++ != ' ' || (s != end && *s && *s != ' '))
87 *p++ = *(s-1);
88 }
89 /* wipe out trailing garbage */
90 while (p != end)
91 *p++ = '\0';
92}
93EXPORT_SYMBOL(ide_fixstring);
94
95/*
96 * This routine busy-waits for the drive status to be not "busy".
97 * It then checks the status for all of the "good" bits and none
98 * of the "bad" bits, and if all is okay it returns 0. All other
99 * cases return error -- caller may then invoke ide_error().
100 *
101 * This routine should get fixed to not hog the cpu during extra long waits..
102 * That could be done by busy-waiting for the first jiffy or two, and then
103 * setting a timer to wake up at half second intervals thereafter,
104 * until timeout is achieved, before timing out.
105 */
106int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
107 unsigned long timeout, u8 *rstat)
108{
109 ide_hwif_t *hwif = drive->hwif;
110 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
111 unsigned long flags;
112 bool irqs_threaded = force_irqthreads;
113 int i;
114 u8 stat;
115
116 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
117 stat = tp_ops->read_status(hwif);
118
119 if (stat & ATA_BUSY) {
120 if (!irqs_threaded) {
121 local_save_flags(flags);
122 local_irq_enable_in_hardirq();
123 }
124 timeout += jiffies;
125 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
126 if (time_after(jiffies, timeout)) {
127 /*
128 * One last read after the timeout in case
129 * heavy interrupt load made us not make any
130 * progress during the timeout..
131 */
132 stat = tp_ops->read_status(hwif);
133 if ((stat & ATA_BUSY) == 0)
134 break;
135
136 if (!irqs_threaded)
137 local_irq_restore(flags);
138 *rstat = stat;
139 return -EBUSY;
140 }
141 }
142 if (!irqs_threaded)
143 local_irq_restore(flags);
144 }
145 /*
146 * Allow status to settle, then read it again.
147 * A few rare drives vastly violate the 400ns spec here,
148 * so we'll wait up to 10usec for a "good" status
149 * rather than expensively fail things immediately.
150 * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
151 */
152 for (i = 0; i < 10; i++) {
153 udelay(1);
154 stat = tp_ops->read_status(hwif);
155
156 if (OK_STAT(stat, good, bad)) {
157 *rstat = stat;
158 return 0;
159 }
160 }
161 *rstat = stat;
162 return -EFAULT;
163}
164
165/*
166 * In case of error returns error value after doing "*startstop = ide_error()".
167 * The caller should return the updated value of "startstop" in this case,
168 * "startstop" is unchanged when the function returns 0.
169 */
170int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
171 u8 bad, unsigned long timeout)
172{
173 int err;
174 u8 stat;
175
176 /* bail early if we've exceeded max_failures */
177 if (drive->max_failures && (drive->failures > drive->max_failures)) {
178 *startstop = ide_stopped;
179 return 1;
180 }
181
182 err = __ide_wait_stat(drive, good, bad, timeout, &stat);
183
184 if (err) {
185 char *s = (err == -EBUSY) ? "status timeout" : "status error";
186 *startstop = ide_error(drive, s, stat);
187 }
188
189 return err;
190}
191EXPORT_SYMBOL(ide_wait_stat);
192
193/**
194 * ide_in_drive_list - look for drive in black/white list
195 * @id: drive identifier
196 * @table: list to inspect
197 *
198 * Look for a drive in the blacklist and the whitelist tables
199 * Returns 1 if the drive is found in the table.
200 */
201
202int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
203{
204 for ( ; table->id_model; table++)
205 if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
206 (!table->id_firmware ||
207 strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
208 return 1;
209 return 0;
210}
211EXPORT_SYMBOL_GPL(ide_in_drive_list);
212
213/*
214 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
215 * Some optical devices with the buggy firmwares have the same problem.
216 */
217static const struct drive_list_entry ivb_list[] = {
218 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
219 { "QUANTUM FIREBALLlct20 30" , "APL.0900" },
220 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
221 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
222 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
223 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
224 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
225 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
226 { "SAMSUNG SP0822N" , "WA100-10" },
227 { NULL , NULL }
228};
229
230/*
231 * All hosts that use the 80c ribbon must use!
232 * The name is derived from upper byte of word 93 and the 80c ribbon.
233 */
234u8 eighty_ninty_three(ide_drive_t *drive)
235{
236 ide_hwif_t *hwif = drive->hwif;
237 u16 *id = drive->id;
238 int ivb = ide_in_drive_list(id, ivb_list);
239
240 if (hwif->cbl == ATA_CBL_SATA || hwif->cbl == ATA_CBL_PATA40_SHORT)
241 return 1;
242
243 if (ivb)
244 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
245 drive->name);
246
247 if (ata_id_is_sata(id) && !ivb)
248 return 1;
249
250 if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
251 goto no_80w;
252
253 /*
254 * FIXME:
255 * - change master/slave IDENTIFY order
256 * - force bit13 (80c cable present) check also for !ivb devices
257 * (unless the slave device is pre-ATA3)
258 */
259 if (id[ATA_ID_HW_CONFIG] & 0x4000)
260 return 1;
261
262 if (ivb) {
263 const char *model = (char *)&id[ATA_ID_PROD];
264
265 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
266 /*
267 * These ATAPI devices always report 80c cable
268 * so we have to depend on the host in this case.
269 */
270 if (hwif->cbl == ATA_CBL_PATA80)
271 return 1;
272 } else {
273 /* Depend on the device side cable detection. */
274 if (id[ATA_ID_HW_CONFIG] & 0x2000)
275 return 1;
276 }
277 }
278no_80w:
279 if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
280 return 0;
281
282 printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
283 "limiting max speed to UDMA33\n",
284 drive->name,
285 hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
286
287 drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
288
289 return 0;
290}
291
292static const char *nien_quirk_list[] = {
293 "QUANTUM FIREBALLlct08 08",
294 "QUANTUM FIREBALLP KA6.4",
295 "QUANTUM FIREBALLP KA9.1",
296 "QUANTUM FIREBALLP KX13.6",
297 "QUANTUM FIREBALLP KX20.5",
298 "QUANTUM FIREBALLP KX27.3",
299 "QUANTUM FIREBALLP LM20.4",
300 "QUANTUM FIREBALLP LM20.5",
301 "FUJITSU MHZ2160BH G2",
302 NULL
303};
304
305void ide_check_nien_quirk_list(ide_drive_t *drive)
306{
307 const char **list, *m = (char *)&drive->id[ATA_ID_PROD];
308
309 for (list = nien_quirk_list; *list != NULL; list++)
310 if (strstr(m, *list) != NULL) {
311 drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
312 return;
313 }
314}
315
316int ide_driveid_update(ide_drive_t *drive)
317{
318 u16 *id;
319 int rc;
320
321 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
322 if (id == NULL)
323 return 0;
324
325 SELECT_MASK(drive, 1);
326 rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
327 SELECT_MASK(drive, 0);
328
329 if (rc)
330 goto out_err;
331
332 drive->id[ATA_ID_UDMA_MODES] = id[ATA_ID_UDMA_MODES];
333 drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
334 drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
335 drive->id[ATA_ID_CFA_MODES] = id[ATA_ID_CFA_MODES];
336 /* anything more ? */
337
338 kfree(id);
339
340 return 1;
341out_err:
342 if (rc == 2)
343 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
344 kfree(id);
345 return 0;
346}
347
348int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
349{
350 ide_hwif_t *hwif = drive->hwif;
351 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
352 struct ide_taskfile tf;
353 u16 *id = drive->id, i;
354 int error = 0;
355 u8 stat;
356
357#ifdef CONFIG_BLK_DEV_IDEDMA
358 if (hwif->dma_ops) /* check if host supports DMA */
359 hwif->dma_ops->dma_host_set(drive, 0);
360#endif
361
362 /* Skip setting PIO flow-control modes on pre-EIDE drives */
363 if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
364 goto skip;
365
366 /*
367 * Don't use ide_wait_cmd here - it will
368 * attempt to set_geometry and recalibrate,
369 * but for some reason these don't work at
370 * this point (lost interrupt).
371 */
372
373 udelay(1);
374 tp_ops->dev_select(drive);
375 SELECT_MASK(drive, 1);
376 udelay(1);
377 tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
378
379 memset(&tf, 0, sizeof(tf));
380 tf.feature = SETFEATURES_XFER;
381 tf.nsect = speed;
382
383 tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
384
385 tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
386
387 if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
388 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
389
390 error = __ide_wait_stat(drive, drive->ready_stat,
391 ATA_BUSY | ATA_DRQ | ATA_ERR,
392 WAIT_CMD, &stat);
393
394 SELECT_MASK(drive, 0);
395
396 if (error) {
397 (void) ide_dump_status(drive, "set_drive_speed_status", stat);
398 return error;
399 }
400
401 if (speed >= XFER_SW_DMA_0) {
402 id[ATA_ID_UDMA_MODES] &= ~0xFF00;
403 id[ATA_ID_MWDMA_MODES] &= ~0x0700;
404 id[ATA_ID_SWDMA_MODES] &= ~0x0700;
405 if (ata_id_is_cfa(id))
406 id[ATA_ID_CFA_MODES] &= ~0x0E00;
407 } else if (ata_id_is_cfa(id))
408 id[ATA_ID_CFA_MODES] &= ~0x01C0;
409
410 skip:
411#ifdef CONFIG_BLK_DEV_IDEDMA
412 if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
413 hwif->dma_ops->dma_host_set(drive, 1);
414 else if (hwif->dma_ops) /* check if host supports DMA */
415 ide_dma_off_quietly(drive);
416#endif
417
418 if (speed >= XFER_UDMA_0) {
419 i = 1 << (speed - XFER_UDMA_0);
420 id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
421 } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
422 i = speed - XFER_MW_DMA_2;
423 id[ATA_ID_CFA_MODES] |= i << 9;
424 } else if (speed >= XFER_MW_DMA_0) {
425 i = 1 << (speed - XFER_MW_DMA_0);
426 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
427 } else if (speed >= XFER_SW_DMA_0) {
428 i = 1 << (speed - XFER_SW_DMA_0);
429 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
430 } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
431 i = speed - XFER_PIO_4;
432 id[ATA_ID_CFA_MODES] |= i << 6;
433 }
434
435 if (!drive->init_speed)
436 drive->init_speed = speed;
437 drive->current_speed = speed;
438 return error;
439}
440
441/*
442 * This should get invoked any time we exit the driver to
443 * wait for an interrupt response from a drive. handler() points
444 * at the appropriate code to handle the next interrupt, and a
445 * timer is started to prevent us from waiting forever in case
446 * something goes wrong (see the ide_timer_expiry() handler later on).
447 *
448 * See also ide_execute_command
449 */
450void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
451 unsigned int timeout)
452{
453 ide_hwif_t *hwif = drive->hwif;
454
455 BUG_ON(hwif->handler);
456 hwif->handler = handler;
457 hwif->timer.expires = jiffies + timeout;
458 hwif->req_gen_timer = hwif->req_gen;
459 add_timer(&hwif->timer);
460}
461
462void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
463 unsigned int timeout)
464{
465 ide_hwif_t *hwif = drive->hwif;
466 unsigned long flags;
467
468 spin_lock_irqsave(&hwif->lock, flags);
469 __ide_set_handler(drive, handler, timeout);
470 spin_unlock_irqrestore(&hwif->lock, flags);
471}
472EXPORT_SYMBOL(ide_set_handler);
473
474/**
475 * ide_execute_command - execute an IDE command
476 * @drive: IDE drive to issue the command against
477 * @cmd: command
478 * @handler: handler for next phase
479 * @timeout: timeout for command
480 *
481 * Helper function to issue an IDE command. This handles the
482 * atomicity requirements, command timing and ensures that the
483 * handler and IRQ setup do not race. All IDE command kick off
484 * should go via this function or do equivalent locking.
485 */
486
487void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
488 ide_handler_t *handler, unsigned timeout)
489{
490 ide_hwif_t *hwif = drive->hwif;
491 unsigned long flags;
492
493 spin_lock_irqsave(&hwif->lock, flags);
494 if ((cmd->protocol != ATAPI_PROT_DMA &&
495 cmd->protocol != ATAPI_PROT_PIO) ||
496 (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
497 __ide_set_handler(drive, handler, timeout);
498 hwif->tp_ops->exec_command(hwif, cmd->tf.command);
499 /*
500 * Drive takes 400nS to respond, we must avoid the IRQ being
501 * serviced before that.
502 *
503 * FIXME: we could skip this delay with care on non shared devices
504 */
505 ndelay(400);
506 spin_unlock_irqrestore(&hwif->lock, flags);
507}
508
509/*
510 * ide_wait_not_busy() waits for the currently selected device on the hwif
511 * to report a non-busy status, see comments in ide_probe_port().
512 */
513int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
514{
515 u8 stat = 0;
516
517 while (timeout--) {
518 /*
519 * Turn this into a schedule() sleep once I'm sure
520 * about locking issues (2.5 work ?).
521 */
522 mdelay(1);
523 stat = hwif->tp_ops->read_status(hwif);
524 if ((stat & ATA_BUSY) == 0)
525 return 0;
526 /*
527 * Assume a value of 0xff means nothing is connected to
528 * the interface and it doesn't implement the pull-down
529 * resistor on D7.
530 */
531 if (stat == 0xff)
532 return -ENODEV;
533 touch_softlockup_watchdog();
534 touch_nmi_watchdog();
535 }
536 return -EBUSY;
537}