drivers/ide/ide-iops.c

   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
  31 void 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
  39 u8 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 }
  47 EXPORT_SYMBOL_GPL(ide_read_error);
  48
  49 void 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
  70 void 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 }
  93 EXPORT_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  */
 106 int __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  */
 170 int 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 }
 191 EXPORT_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
 202 int 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 }
 211 EXPORT_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  */
 217 static 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  */
 234 u8 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         }
 278 no_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
 292 static 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
 305 void 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
 316 int 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;
 341 out_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
 348 int 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  */
 450 void __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
 462 void 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 }
 472 EXPORT_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
 487 void 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  */
 513 int 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_nmi_watchdog();
 534         }
 535         return -EBUSY;
 536 }