linux/drivers/ide/ide-iops.c
<<
>>
Prefs
   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
  30void 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
  38u8 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}
  46EXPORT_SYMBOL_GPL(ide_read_error);
  47
  48void 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
  69void 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}
  92EXPORT_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 */
 105int __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 */
 164int 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}
 185EXPORT_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
 196int 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}
 205EXPORT_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 */
 211static 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 */
 228u8 eighty_ninty_three(ide_drive_t *drive)
 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        }
 272no_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
 281        drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
 282
 283        return 0;
 284}
 285
 286static 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
 299void ide_check_nien_quirk_list(ide_drive_t *drive)
 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) {
 305                        drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
 306                        return;
 307                }
 308}
 309
 310int ide_driveid_update(ide_drive_t *drive)
 311{
 312        u16 *id;
 313        int rc;
 314
 315        id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
 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];
 327        drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
 328        drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
 329        drive->id[ATA_ID_CFA_MODES]   = id[ATA_ID_CFA_MODES];
 330        /* anything more ? */
 331
 332        kfree(id);
 333
 334        return 1;
 335out_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
 342int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 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));
 374        tf.feature = SETFEATURES_XFER;
 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,
 385                                ATA_BUSY | ATA_DRQ | ATA_ERR,
 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 */
 444void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
 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
 456void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
 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}
 466EXPORT_SYMBOL(ide_set_handler);
 467
 468/**
 469 *      ide_execute_command     -       execute an IDE command
 470 *      @drive: IDE drive to issue the command against
 471 *      @cmd: command
 472 *      @handler: handler for next phase
 473 *      @timeout: timeout for command
 474 *
 475 *      Helper function to issue an IDE command. This handles the
 476 *      atomicity requirements, command timing and ensures that the
 477 *      handler and IRQ setup do not race. All IDE command kick off
 478 *      should go via this function or do equivalent locking.
 479 */
 480
 481void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
 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) ||
 490            (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
 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 */
 507int 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;
 527                touch_softlockup_watchdog();
 528                touch_nmi_watchdog();
 529        }
 530        return -EBUSY;
 531}
 532
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.