Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ide-iops.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2000-2002 Andre Hedrick <[email protected]>
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 
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 
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 }
47 
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 
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 }
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  */
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  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);
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  */
164 int 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 }
186 
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 }
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  */
211 static 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  */
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  }
272 no_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 
282 
283  return 0;
284 }
285 
286 static 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 
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) {
306  return;
307  }
308 }
309 
311 {
312  u16 *id;
313  int rc;
314 
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];
329  drive->id[ATA_ID_CFA_MODES] = id[ATA_ID_CFA_MODES];
330  /* anything more ? */
331 
332  kfree(id);
333 
334  return 1;
335 out_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 
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));
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,
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  */
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 
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 }
467 
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) ||
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  */
507 int 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;
529  }
530  return -EBUSY;
531 }