SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/ide/ide-iops.c

   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
  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
  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
  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
  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  */
 105 static 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);
 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  */
 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 }
 185 EXPORT_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
 196 int 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 }
 205 EXPORT_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  */
 211 static const struct drive_list_entry ivb_list[] = {
 212         { "QUANTUM FIREBALLlct10 05"    , "A03.0900"    },
 213         { "TSSTcorp CDDVDW SH-S202J"    , "SB00"        },
 214         { "TSSTcorp CDDVDW SH-S202J"    , "SB01"        },
 215         { "TSSTcorp CDDVDW SH-S202N"    , "SB00"        },
 216         { "TSSTcorp CDDVDW SH-S202N"    , "SB01"        },
 217         { "TSSTcorp CDDVDW SH-S202H"    , "SB00"        },
 218         { "TSSTcorp CDDVDW SH-S202H"    , "SB01"        },
 219         { "SAMSUNG SP0822N"             , "WA100-10"    },
 220         { NULL                          , NULL          }
 221 };
 222
 223 /*
 224  *  All hosts that use the 80c ribbon must use!
 225  *  The name is derived from upper byte of word 93 and the 80c ribbon.
 226  */
 227 u8 eighty_ninty_three(ide_drive_t *drive)
 228 {
 229         ide_hwif_t *hwif = drive->hwif;
 230         u16 *id = drive->id;
 231         int ivb = ide_in_drive_list(id, ivb_list);
 232
 233         if (hwif->cbl == ATA_CBL_PATA40_SHORT)
 234                 return 1;
 235
 236         if (ivb)
 237                 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
 238                                   drive->name);
 239
 240         if (ata_id_is_sata(id) && !ivb)
 241                 return 1;
 242
 243         if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
 244                 goto no_80w;
 245
 246         /*
 247          * FIXME:
 248          * - change master/slave IDENTIFY order
 249          * - force bit13 (80c cable present) check also for !ivb devices
 250          *   (unless the slave device is pre-ATA3)
 251          */
 252         if (id[ATA_ID_HW_CONFIG] & 0x4000)
 253                 return 1;
 254
 255         if (ivb) {
 256                 const char *model = (char *)&id[ATA_ID_PROD];
 257
 258                 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
 259                         /*
 260                          * These ATAPI devices always report 80c cable
 261                          * so we have to depend on the host in this case.
 262                          */
 263                         if (hwif->cbl == ATA_CBL_PATA80)
 264                                 return 1;
 265                 } else {
 266                         /* Depend on the device side cable detection. */
 267                         if (id[ATA_ID_HW_CONFIG] & 0x2000)
 268                                 return 1;
 269                 }
 270         }
 271 no_80w:
 272         if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
 273                 return 0;
 274
 275         printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
 276                             "limiting max speed to UDMA33\n",
 277                             drive->name,
 278                             hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
 279
 280         drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
 281
 282         return 0;
 283 }
 284
 285 static const char *nien_quirk_list[] = {
 286         "QUANTUM FIREBALLlct08 08",
 287         "QUANTUM FIREBALLP KA6.4",
 288         "QUANTUM FIREBALLP KA9.1",
 289         "QUANTUM FIREBALLP KX13.6",
 290         "QUANTUM FIREBALLP KX20.5",
 291         "QUANTUM FIREBALLP KX27.3",
 292         "QUANTUM FIREBALLP LM20.4",
 293         "QUANTUM FIREBALLP LM20.5",
 294         NULL
 295 };
 296
 297 void ide_check_nien_quirk_list(ide_drive_t *drive)
 298 {
 299         const char **list, *m = (char *)&drive->id[ATA_ID_PROD];
 300
 301         for (list = nien_quirk_list; *list != NULL; list++)
 302                 if (strstr(m, *list) != NULL) {
 303                         drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
 304                         return;
 305                 }
 306 }
 307
 308 int ide_driveid_update(ide_drive_t *drive)
 309 {
 310         u16 *id;
 311         int rc;
 312
 313         id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
 314         if (id == NULL)
 315                 return 0;
 316
 317         SELECT_MASK(drive, 1);
 318         rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id);
 319         SELECT_MASK(drive, 0);
 320
 321         if (rc)
 322                 goto out_err;
 323
 324         drive->id[ATA_ID_UDMA_MODES]  = id[ATA_ID_UDMA_MODES];
 325         drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
 326         drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
 327         drive->id[ATA_ID_CFA_MODES]   = id[ATA_ID_CFA_MODES];
 328         /* anything more ? */
 329
 330         kfree(id);
 331
 332         if ((drive->dev_flags & IDE_DFLAG_USING_DMA) && ide_id_dma_bug(drive))
 333                 ide_dma_off(drive);
 334
 335         return 1;
 336 out_err:
 337         if (rc == 2)
 338                 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
 339         kfree(id);
 340         return 0;
 341 }
 342
 343 int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 344 {
 345         ide_hwif_t *hwif = drive->hwif;
 346         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
 347         struct ide_taskfile tf;
 348         u16 *id = drive->id, i;
 349         int error = 0;
 350         u8 stat;
 351
 352 #ifdef CONFIG_BLK_DEV_IDEDMA
 353         if (hwif->dma_ops)      /* check if host supports DMA */
 354                 hwif->dma_ops->dma_host_set(drive, 0);
 355 #endif
 356
 357         /* Skip setting PIO flow-control modes on pre-EIDE drives */
 358         if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
 359                 goto skip;
 360
 361         /*
 362          * Don't use ide_wait_cmd here - it will
 363          * attempt to set_geometry and recalibrate,
 364          * but for some reason these don't work at
 365          * this point (lost interrupt).
 366          */
 367
 368         /*
 369          *      FIXME: we race against the running IRQ here if
 370          *      this is called from non IRQ context. If we use
 371          *      disable_irq() we hang on the error path. Work
 372          *      is needed.
 373          */
 374         disable_irq_nosync(hwif->irq);
 375
 376         udelay(1);
 377         tp_ops->dev_select(drive);
 378         SELECT_MASK(drive, 1);
 379         udelay(1);
 380         tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
 381
 382         memset(&tf, 0, sizeof(tf));
 383         tf.feature = SETFEATURES_XFER;
 384         tf.nsect   = speed;
 385
 386         tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
 387
 388         tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
 389
 390         if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
 391                 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
 392
 393         error = __ide_wait_stat(drive, drive->ready_stat,
 394                                 ATA_BUSY | ATA_DRQ | ATA_ERR,
 395                                 WAIT_CMD, &stat);
 396
 397         SELECT_MASK(drive, 0);
 398
 399         enable_irq(hwif->irq);
 400
 401         if (error) {
 402                 (void) ide_dump_status(drive, "set_drive_speed_status", stat);
 403                 return error;
 404         }
 405
 406         if (speed >= XFER_SW_DMA_0) {
 407                 id[ATA_ID_UDMA_MODES]  &= ~0xFF00;
 408                 id[ATA_ID_MWDMA_MODES] &= ~0x0700;
 409                 id[ATA_ID_SWDMA_MODES] &= ~0x0700;
 410                 if (ata_id_is_cfa(id))
 411                         id[ATA_ID_CFA_MODES] &= ~0x0E00;
 412         } else  if (ata_id_is_cfa(id))
 413                 id[ATA_ID_CFA_MODES] &= ~0x01C0;
 414
 415  skip:
 416 #ifdef CONFIG_BLK_DEV_IDEDMA
 417         if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
 418                 hwif->dma_ops->dma_host_set(drive, 1);
 419         else if (hwif->dma_ops) /* check if host supports DMA */
 420                 ide_dma_off_quietly(drive);
 421 #endif
 422
 423         if (speed >= XFER_UDMA_0) {
 424                 i = 1 << (speed - XFER_UDMA_0);
 425                 id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
 426         } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
 427                 i = speed - XFER_MW_DMA_2;
 428                 id[ATA_ID_CFA_MODES] |= i << 9;
 429         } else if (speed >= XFER_MW_DMA_0) {
 430                 i = 1 << (speed - XFER_MW_DMA_0);
 431                 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
 432         } else if (speed >= XFER_SW_DMA_0) {
 433                 i = 1 << (speed - XFER_SW_DMA_0);
 434                 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
 435         } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
 436                 i = speed - XFER_PIO_4;
 437                 id[ATA_ID_CFA_MODES] |= i << 6;
 438         }
 439
 440         if (!drive->init_speed)
 441                 drive->init_speed = speed;
 442         drive->current_speed = speed;
 443         return error;
 444 }
 445
 446 /*
 447  * This should get invoked any time we exit the driver to
 448  * wait for an interrupt response from a drive.  handler() points
 449  * at the appropriate code to handle the next interrupt, and a
 450  * timer is started to prevent us from waiting forever in case
 451  * something goes wrong (see the ide_timer_expiry() handler later on).
 452  *
 453  * See also ide_execute_command
 454  */
 455 void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
 456                        unsigned int timeout)
 457 {
 458         ide_hwif_t *hwif = drive->hwif;
 459
 460         BUG_ON(hwif->handler);
 461         hwif->handler           = handler;
 462         hwif->timer.expires     = jiffies + timeout;
 463         hwif->req_gen_timer     = hwif->req_gen;
 464         add_timer(&hwif->timer);
 465 }
 466
 467 void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
 468                      unsigned int timeout)
 469 {
 470         ide_hwif_t *hwif = drive->hwif;
 471         unsigned long flags;
 472
 473         spin_lock_irqsave(&hwif->lock, flags);
 474         __ide_set_handler(drive, handler, timeout);
 475         spin_unlock_irqrestore(&hwif->lock, flags);
 476 }
 477 EXPORT_SYMBOL(ide_set_handler);
 478
 479 /**
 480  *      ide_execute_command     -       execute an IDE command
 481  *      @drive: IDE drive to issue the command against
 482  *      @cmd: command
 483  *      @handler: handler for next phase
 484  *      @timeout: timeout for command
 485  *
 486  *      Helper function to issue an IDE command. This handles the
 487  *      atomicity requirements, command timing and ensures that the
 488  *      handler and IRQ setup do not race. All IDE command kick off
 489  *      should go via this function or do equivalent locking.
 490  */
 491
 492 void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
 493                          ide_handler_t *handler, unsigned timeout)
 494 {
 495         ide_hwif_t *hwif = drive->hwif;
 496         unsigned long flags;
 497
 498         spin_lock_irqsave(&hwif->lock, flags);
 499         if ((cmd->protocol != ATAPI_PROT_DMA &&
 500              cmd->protocol != ATAPI_PROT_PIO) ||
 501             (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
 502                 __ide_set_handler(drive, handler, timeout);
 503         hwif->tp_ops->exec_command(hwif, cmd->tf.command);
 504         /*
 505          * Drive takes 400nS to respond, we must avoid the IRQ being
 506          * serviced before that.
 507          *
 508          * FIXME: we could skip this delay with care on non shared devices
 509          */
 510         ndelay(400);
 511         spin_unlock_irqrestore(&hwif->lock, flags);
 512 }
 513
 514 /*
 515  * ide_wait_not_busy() waits for the currently selected device on the hwif
 516  * to report a non-busy status, see comments in ide_probe_port().
 517  */
 518 int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
 519 {
 520         u8 stat = 0;
 521
 522         while (timeout--) {
 523                 /*
 524                  * Turn this into a schedule() sleep once I'm sure
 525                  * about locking issues (2.5 work ?).
 526                  */
 527                 mdelay(1);
 528                 stat = hwif->tp_ops->read_status(hwif);
 529                 if ((stat & ATA_BUSY) == 0)
 530                         return 0;
 531                 /*
 532                  * Assume a value of 0xff means nothing is connected to
 533                  * the interface and it doesn't implement the pull-down
 534                  * resistor on D7.
 535                  */
 536                 if (stat == 0xff)
 537                         return -ENODEV;
 538                 touch_softlockup_watchdog();
 539                 touch_nmi_watchdog();
 540         }
 541         return -EBUSY;
 542 }