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