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 <linux/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 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  */
 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
 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  */
 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
 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
 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
 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  */
 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
 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
 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  */
 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 }