linux/drivers/scsi/sd.c
<<
>>
Prefs
   1/*
   2 *      sd.c Copyright (C) 1992 Drew Eckhardt
   3 *           Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
   4 *
   5 *      Linux scsi disk driver
   6 *              Initial versions: Drew Eckhardt
   7 *              Subsequent revisions: Eric Youngdale
   8 *      Modification history:
   9 *       - Drew Eckhardt <drew@colorado.edu> original
  10 *       - Eric Youngdale <eric@andante.org> add scatter-gather, multiple 
  11 *         outstanding request, and other enhancements.
  12 *         Support loadable low-level scsi drivers.
  13 *       - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using 
  14 *         eight major numbers.
  15 *       - Richard Gooch <rgooch@atnf.csiro.au> support devfs.
  16 *       - Torben Mathiasen <tmm@image.dk> Resource allocation fixes in 
  17 *         sd_init and cleanups.
  18 *       - Alex Davis <letmein@erols.com> Fix problem where partition info
  19 *         not being read in sd_open. Fix problem where removable media 
  20 *         could be ejected after sd_open.
  21 *       - Douglas Gilbert <dgilbert@interlog.com> cleanup for lk 2.5.x
  22 *       - Badari Pulavarty <pbadari@us.ibm.com>, Matthew Wilcox 
  23 *         <willy@debian.org>, Kurt Garloff <garloff@suse.de>: 
  24 *         Support 32k/1M disks.
  25 *
  26 *      Logging policy (needs CONFIG_SCSI_LOGGING defined):
  27 *       - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2
  28 *       - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1
  29 *       - entering sd_ioctl: SCSI_LOG_IOCTL level 1
  30 *       - entering other commands: SCSI_LOG_HLQUEUE level 3
  31 *      Note: when the logging level is set by the user, it must be greater
  32 *      than the level indicated above to trigger output.       
  33 */
  34
  35#include <linux/module.h>
  36#include <linux/fs.h>
  37#include <linux/kernel.h>
  38#include <linux/mm.h>
  39#include <linux/bio.h>
  40#include <linux/genhd.h>
  41#include <linux/hdreg.h>
  42#include <linux/errno.h>
  43#include <linux/idr.h>
  44#include <linux/interrupt.h>
  45#include <linux/init.h>
  46#include <linux/blkdev.h>
  47#include <linux/blkpg.h>
  48#include <linux/delay.h>
  49#include <linux/mutex.h>
  50#include <linux/string_helpers.h>
  51#include <linux/async.h>
  52#include <linux/slab.h>
  53#include <linux/pm_runtime.h>
  54#include <asm/uaccess.h>
  55#include <asm/unaligned.h>
  56
  57#include <scsi/scsi.h>
  58#include <scsi/scsi_cmnd.h>
  59#include <scsi/scsi_dbg.h>
  60#include <scsi/scsi_device.h>
  61#include <scsi/scsi_driver.h>
  62#include <scsi/scsi_eh.h>
  63#include <scsi/scsi_host.h>
  64#include <scsi/scsi_ioctl.h>
  65#include <scsi/scsicam.h>
  66
  67#include "sd.h"
  68#include "scsi_priv.h"
  69#include "scsi_logging.h"
  70
  71MODULE_AUTHOR("Eric Youngdale");
  72MODULE_DESCRIPTION("SCSI disk (sd) driver");
  73MODULE_LICENSE("GPL");
  74
  75MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
  76MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
  77MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
  78MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
  79MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
  80MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
  81MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
  82MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
  83MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
  84MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
  85MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
  86MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
  87MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
  88MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
  89MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
  90MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
  91MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
  92MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
  93MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
  94
  95#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
  96#define SD_MINORS       16
  97#else
  98#define SD_MINORS       0
  99#endif
 100
 101static void sd_config_discard(struct scsi_disk *, unsigned int);
 102static void sd_config_write_same(struct scsi_disk *);
 103static int  sd_revalidate_disk(struct gendisk *);
 104static void sd_unlock_native_capacity(struct gendisk *disk);
 105static int  sd_probe(struct device *);
 106static int  sd_remove(struct device *);
 107static void sd_shutdown(struct device *);
 108static int sd_suspend(struct device *);
 109static int sd_resume(struct device *);
 110static void sd_rescan(struct device *);
 111static int sd_done(struct scsi_cmnd *);
 112static int sd_eh_action(struct scsi_cmnd *, unsigned char *, int, int);
 113static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
 114static void scsi_disk_release(struct device *cdev);
 115static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
 116static void sd_print_result(struct scsi_disk *, int);
 117
 118static DEFINE_SPINLOCK(sd_index_lock);
 119static DEFINE_IDA(sd_index_ida);
 120
 121/* This semaphore is used to mediate the 0->1 reference get in the
 122 * face of object destruction (i.e. we can't allow a get on an
 123 * object after last put) */
 124static DEFINE_MUTEX(sd_ref_mutex);
 125
 126static struct kmem_cache *sd_cdb_cache;
 127static mempool_t *sd_cdb_pool;
 128
 129static const char *sd_cache_types[] = {
 130        "write through", "none", "write back",
 131        "write back, no read (daft)"
 132};
 133
 134static ssize_t
 135sd_store_cache_type(struct device *dev, struct device_attribute *attr,
 136                    const char *buf, size_t count)
 137{
 138        int i, ct = -1, rcd, wce, sp;
 139        struct scsi_disk *sdkp = to_scsi_disk(dev);
 140        struct scsi_device *sdp = sdkp->device;
 141        char buffer[64];
 142        char *buffer_data;
 143        struct scsi_mode_data data;
 144        struct scsi_sense_hdr sshdr;
 145        int len;
 146
 147        if (sdp->type != TYPE_DISK)
 148                /* no cache control on RBC devices; theoretically they
 149                 * can do it, but there's probably so many exceptions
 150                 * it's not worth the risk */
 151                return -EINVAL;
 152
 153        for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
 154                len = strlen(sd_cache_types[i]);
 155                if (strncmp(sd_cache_types[i], buf, len) == 0 &&
 156                    buf[len] == '\n') {
 157                        ct = i;
 158                        break;
 159                }
 160        }
 161        if (ct < 0)
 162                return -EINVAL;
 163        rcd = ct & 0x01 ? 1 : 0;
 164        wce = ct & 0x02 ? 1 : 0;
 165        if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
 166                            SD_MAX_RETRIES, &data, NULL))
 167                return -EINVAL;
 168        len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
 169                  data.block_descriptor_length);
 170        buffer_data = buffer + data.header_length +
 171                data.block_descriptor_length;
 172        buffer_data[2] &= ~0x05;
 173        buffer_data[2] |= wce << 2 | rcd;
 174        sp = buffer_data[0] & 0x80 ? 1 : 0;
 175
 176        if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
 177                             SD_MAX_RETRIES, &data, &sshdr)) {
 178                if (scsi_sense_valid(&sshdr))
 179                        sd_print_sense_hdr(sdkp, &sshdr);
 180                return -EINVAL;
 181        }
 182        revalidate_disk(sdkp->disk);
 183        return count;
 184}
 185
 186static ssize_t
 187sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
 188                           const char *buf, size_t count)
 189{
 190        struct scsi_disk *sdkp = to_scsi_disk(dev);
 191        struct scsi_device *sdp = sdkp->device;
 192
 193        if (!capable(CAP_SYS_ADMIN))
 194                return -EACCES;
 195
 196        sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
 197
 198        return count;
 199}
 200
 201static ssize_t
 202sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
 203                       const char *buf, size_t count)
 204{
 205        struct scsi_disk *sdkp = to_scsi_disk(dev);
 206        struct scsi_device *sdp = sdkp->device;
 207
 208        if (!capable(CAP_SYS_ADMIN))
 209                return -EACCES;
 210
 211        if (sdp->type != TYPE_DISK)
 212                return -EINVAL;
 213
 214        sdp->allow_restart = simple_strtoul(buf, NULL, 10);
 215
 216        return count;
 217}
 218
 219static ssize_t
 220sd_show_cache_type(struct device *dev, struct device_attribute *attr,
 221                   char *buf)
 222{
 223        struct scsi_disk *sdkp = to_scsi_disk(dev);
 224        int ct = sdkp->RCD + 2*sdkp->WCE;
 225
 226        return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
 227}
 228
 229static ssize_t
 230sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
 231{
 232        struct scsi_disk *sdkp = to_scsi_disk(dev);
 233
 234        return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
 235}
 236
 237static ssize_t
 238sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
 239                          char *buf)
 240{
 241        struct scsi_disk *sdkp = to_scsi_disk(dev);
 242        struct scsi_device *sdp = sdkp->device;
 243
 244        return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
 245}
 246
 247static ssize_t
 248sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
 249                      char *buf)
 250{
 251        struct scsi_disk *sdkp = to_scsi_disk(dev);
 252
 253        return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
 254}
 255
 256static ssize_t
 257sd_show_protection_type(struct device *dev, struct device_attribute *attr,
 258                        char *buf)
 259{
 260        struct scsi_disk *sdkp = to_scsi_disk(dev);
 261
 262        return snprintf(buf, 20, "%u\n", sdkp->protection_type);
 263}
 264
 265static ssize_t
 266sd_store_protection_type(struct device *dev, struct device_attribute *attr,
 267                         const char *buf, size_t count)
 268{
 269        struct scsi_disk *sdkp = to_scsi_disk(dev);
 270        unsigned int val;
 271        int err;
 272
 273        if (!capable(CAP_SYS_ADMIN))
 274                return -EACCES;
 275
 276        err = kstrtouint(buf, 10, &val);
 277
 278        if (err)
 279                return err;
 280
 281        if (val >= 0 && val <= SD_DIF_TYPE3_PROTECTION)
 282                sdkp->protection_type = val;
 283
 284        return count;
 285}
 286
 287static ssize_t
 288sd_show_protection_mode(struct device *dev, struct device_attribute *attr,
 289                        char *buf)
 290{
 291        struct scsi_disk *sdkp = to_scsi_disk(dev);
 292        struct scsi_device *sdp = sdkp->device;
 293        unsigned int dif, dix;
 294
 295        dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
 296        dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type);
 297
 298        if (!dix && scsi_host_dix_capable(sdp->host, SD_DIF_TYPE0_PROTECTION)) {
 299                dif = 0;
 300                dix = 1;
 301        }
 302
 303        if (!dif && !dix)
 304                return snprintf(buf, 20, "none\n");
 305
 306        return snprintf(buf, 20, "%s%u\n", dix ? "dix" : "dif", dif);
 307}
 308
 309static ssize_t
 310sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
 311                    char *buf)
 312{
 313        struct scsi_disk *sdkp = to_scsi_disk(dev);
 314
 315        return snprintf(buf, 20, "%u\n", sdkp->ATO);
 316}
 317
 318static ssize_t
 319sd_show_thin_provisioning(struct device *dev, struct device_attribute *attr,
 320                          char *buf)
 321{
 322        struct scsi_disk *sdkp = to_scsi_disk(dev);
 323
 324        return snprintf(buf, 20, "%u\n", sdkp->lbpme);
 325}
 326
 327static const char *lbp_mode[] = {
 328        [SD_LBP_FULL]           = "full",
 329        [SD_LBP_UNMAP]          = "unmap",
 330        [SD_LBP_WS16]           = "writesame_16",
 331        [SD_LBP_WS10]           = "writesame_10",
 332        [SD_LBP_ZERO]           = "writesame_zero",
 333        [SD_LBP_DISABLE]        = "disabled",
 334};
 335
 336static ssize_t
 337sd_show_provisioning_mode(struct device *dev, struct device_attribute *attr,
 338                          char *buf)
 339{
 340        struct scsi_disk *sdkp = to_scsi_disk(dev);
 341
 342        return snprintf(buf, 20, "%s\n", lbp_mode[sdkp->provisioning_mode]);
 343}
 344
 345static ssize_t
 346sd_store_provisioning_mode(struct device *dev, struct device_attribute *attr,
 347                           const char *buf, size_t count)
 348{
 349        struct scsi_disk *sdkp = to_scsi_disk(dev);
 350        struct scsi_device *sdp = sdkp->device;
 351
 352        if (!capable(CAP_SYS_ADMIN))
 353                return -EACCES;
 354
 355        if (sdp->type != TYPE_DISK)
 356                return -EINVAL;
 357
 358        if (!strncmp(buf, lbp_mode[SD_LBP_UNMAP], 20))
 359                sd_config_discard(sdkp, SD_LBP_UNMAP);
 360        else if (!strncmp(buf, lbp_mode[SD_LBP_WS16], 20))
 361                sd_config_discard(sdkp, SD_LBP_WS16);
 362        else if (!strncmp(buf, lbp_mode[SD_LBP_WS10], 20))
 363                sd_config_discard(sdkp, SD_LBP_WS10);
 364        else if (!strncmp(buf, lbp_mode[SD_LBP_ZERO], 20))
 365                sd_config_discard(sdkp, SD_LBP_ZERO);
 366        else if (!strncmp(buf, lbp_mode[SD_LBP_DISABLE], 20))
 367                sd_config_discard(sdkp, SD_LBP_DISABLE);
 368        else
 369                return -EINVAL;
 370
 371        return count;
 372}
 373
 374static ssize_t
 375sd_show_max_medium_access_timeouts(struct device *dev,
 376                                   struct device_attribute *attr, char *buf)
 377{
 378        struct scsi_disk *sdkp = to_scsi_disk(dev);
 379
 380        return snprintf(buf, 20, "%u\n", sdkp->max_medium_access_timeouts);
 381}
 382
 383static ssize_t
 384sd_store_max_medium_access_timeouts(struct device *dev,
 385                                    struct device_attribute *attr,
 386                                    const char *buf, size_t count)
 387{
 388        struct scsi_disk *sdkp = to_scsi_disk(dev);
 389        int err;
 390
 391        if (!capable(CAP_SYS_ADMIN))
 392                return -EACCES;
 393
 394        err = kstrtouint(buf, 10, &sdkp->max_medium_access_timeouts);
 395
 396        return err ? err : count;
 397}
 398
 399static ssize_t
 400sd_show_write_same_blocks(struct device *dev, struct device_attribute *attr,
 401                          char *buf)
 402{
 403        struct scsi_disk *sdkp = to_scsi_disk(dev);
 404
 405        return snprintf(buf, 20, "%u\n", sdkp->max_ws_blocks);
 406}
 407
 408static ssize_t
 409sd_store_write_same_blocks(struct device *dev, struct device_attribute *attr,
 410                           const char *buf, size_t count)
 411{
 412        struct scsi_disk *sdkp = to_scsi_disk(dev);
 413        struct scsi_device *sdp = sdkp->device;
 414        unsigned long max;
 415        int err;
 416
 417        if (!capable(CAP_SYS_ADMIN))
 418                return -EACCES;
 419
 420        if (sdp->type != TYPE_DISK)
 421                return -EINVAL;
 422
 423        err = kstrtoul(buf, 10, &max);
 424
 425        if (err)
 426                return err;
 427
 428        if (max == 0)
 429                sdp->no_write_same = 1;
 430        else if (max <= SD_MAX_WS16_BLOCKS)
 431                sdkp->max_ws_blocks = max;
 432
 433        sd_config_write_same(sdkp);
 434
 435        return count;
 436}
 437
 438static struct device_attribute sd_disk_attrs[] = {
 439        __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
 440               sd_store_cache_type),
 441        __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
 442        __ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
 443               sd_store_allow_restart),
 444        __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
 445               sd_store_manage_start_stop),
 446        __ATTR(protection_type, S_IRUGO|S_IWUSR, sd_show_protection_type,
 447               sd_store_protection_type),
 448        __ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL),
 449        __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
 450        __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
 451        __ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
 452               sd_store_provisioning_mode),
 453        __ATTR(max_write_same_blocks, S_IRUGO|S_IWUSR,
 454               sd_show_write_same_blocks, sd_store_write_same_blocks),
 455        __ATTR(max_medium_access_timeouts, S_IRUGO|S_IWUSR,
 456               sd_show_max_medium_access_timeouts,
 457               sd_store_max_medium_access_timeouts),
 458        __ATTR_NULL,
 459};
 460
 461static struct class sd_disk_class = {
 462        .name           = "scsi_disk",
 463        .owner          = THIS_MODULE,
 464        .dev_release    = scsi_disk_release,
 465        .dev_attrs      = sd_disk_attrs,
 466};
 467
 468static const struct dev_pm_ops sd_pm_ops = {
 469        .suspend                = sd_suspend,
 470        .resume                 = sd_resume,
 471        .poweroff               = sd_suspend,
 472        .restore                = sd_resume,
 473        .runtime_suspend        = sd_suspend,
 474        .runtime_resume         = sd_resume,
 475};
 476
 477static struct scsi_driver sd_template = {
 478        .owner                  = THIS_MODULE,
 479        .gendrv = {
 480                .name           = "sd",
 481                .probe          = sd_probe,
 482                .remove         = sd_remove,
 483                .shutdown       = sd_shutdown,
 484                .pm             = &sd_pm_ops,
 485        },
 486        .rescan                 = sd_rescan,
 487        .done                   = sd_done,
 488        .eh_action              = sd_eh_action,
 489};
 490
 491/*
 492 * Device no to disk mapping:
 493 * 
 494 *       major         disc2     disc  p1
 495 *   |............|.............|....|....| <- dev_t
 496 *    31        20 19          8 7  4 3  0
 497 * 
 498 * Inside a major, we have 16k disks, however mapped non-
 499 * contiguously. The first 16 disks are for major0, the next
 500 * ones with major1, ... Disk 256 is for major0 again, disk 272 
 501 * for major1, ... 
 502 * As we stay compatible with our numbering scheme, we can reuse 
 503 * the well-know SCSI majors 8, 65--71, 136--143.
 504 */
 505static int sd_major(int major_idx)
 506{
 507        switch (major_idx) {
 508        case 0:
 509                return SCSI_DISK0_MAJOR;
 510        case 1 ... 7:
 511                return SCSI_DISK1_MAJOR + major_idx - 1;
 512        case 8 ... 15:
 513                return SCSI_DISK8_MAJOR + major_idx - 8;
 514        default:
 515                BUG();
 516                return 0;       /* shut up gcc */
 517        }
 518}
 519
 520static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
 521{
 522        struct scsi_disk *sdkp = NULL;
 523
 524        if (disk->private_data) {
 525                sdkp = scsi_disk(disk);
 526                if (scsi_device_get(sdkp->device) == 0)
 527                        get_device(&sdkp->dev);
 528                else
 529                        sdkp = NULL;
 530        }
 531        return sdkp;
 532}
 533
 534static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
 535{
 536        struct scsi_disk *sdkp;
 537
 538        mutex_lock(&sd_ref_mutex);
 539        sdkp = __scsi_disk_get(disk);
 540        mutex_unlock(&sd_ref_mutex);
 541        return sdkp;
 542}
 543
 544static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
 545{
 546        struct scsi_disk *sdkp;
 547
 548        mutex_lock(&sd_ref_mutex);
 549        sdkp = dev_get_drvdata(dev);
 550        if (sdkp)
 551                sdkp = __scsi_disk_get(sdkp->disk);
 552        mutex_unlock(&sd_ref_mutex);
 553        return sdkp;
 554}
 555
 556static void scsi_disk_put(struct scsi_disk *sdkp)
 557{
 558        struct scsi_device *sdev = sdkp->device;
 559
 560        mutex_lock(&sd_ref_mutex);
 561        put_device(&sdkp->dev);
 562        scsi_device_put(sdev);
 563        mutex_unlock(&sd_ref_mutex);
 564}
 565
 566static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
 567{
 568        unsigned int prot_op = SCSI_PROT_NORMAL;
 569        unsigned int dix = scsi_prot_sg_count(scmd);
 570
 571        if (scmd->sc_data_direction == DMA_FROM_DEVICE) {
 572                if (dif && dix)
 573                        prot_op = SCSI_PROT_READ_PASS;
 574                else if (dif && !dix)
 575                        prot_op = SCSI_PROT_READ_STRIP;
 576                else if (!dif && dix)
 577                        prot_op = SCSI_PROT_READ_INSERT;
 578        } else {
 579                if (dif && dix)
 580                        prot_op = SCSI_PROT_WRITE_PASS;
 581                else if (dif && !dix)
 582                        prot_op = SCSI_PROT_WRITE_INSERT;
 583                else if (!dif && dix)
 584                        prot_op = SCSI_PROT_WRITE_STRIP;
 585        }
 586
 587        scsi_set_prot_op(scmd, prot_op);
 588        scsi_set_prot_type(scmd, dif);
 589}
 590
 591static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
 592{
 593        struct request_queue *q = sdkp->disk->queue;
 594        unsigned int logical_block_size = sdkp->device->sector_size;
 595        unsigned int max_blocks = 0;
 596
 597        q->limits.discard_zeroes_data = sdkp->lbprz;
 598        q->limits.discard_alignment = sdkp->unmap_alignment *
 599                logical_block_size;
 600        q->limits.discard_granularity =
 601                max(sdkp->physical_block_size,
 602                    sdkp->unmap_granularity * logical_block_size);
 603
 604        sdkp->provisioning_mode = mode;
 605
 606        switch (mode) {
 607
 608        case SD_LBP_DISABLE:
 609                q->limits.max_discard_sectors = 0;
 610                queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
 611                return;
 612
 613        case SD_LBP_UNMAP:
 614                max_blocks = min_not_zero(sdkp->max_unmap_blocks,
 615                                          (u32)SD_MAX_WS16_BLOCKS);
 616                break;
 617
 618        case SD_LBP_WS16:
 619                max_blocks = min_not_zero(sdkp->max_ws_blocks,
 620                                          (u32)SD_MAX_WS16_BLOCKS);
 621                break;
 622
 623        case SD_LBP_WS10:
 624                max_blocks = min_not_zero(sdkp->max_ws_blocks,
 625                                          (u32)SD_MAX_WS10_BLOCKS);
 626                break;
 627
 628        case SD_LBP_ZERO:
 629                max_blocks = min_not_zero(sdkp->max_ws_blocks,
 630                                          (u32)SD_MAX_WS10_BLOCKS);
 631                q->limits.discard_zeroes_data = 1;
 632                break;
 633        }
 634
 635        q->limits.max_discard_sectors = max_blocks * (logical_block_size >> 9);
 636        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
 637}
 638
 639/**
 640 * sd_setup_discard_cmnd - unmap blocks on thinly provisioned device
 641 * @sdp: scsi device to operate one
 642 * @rq: Request to prepare
 643 *
 644 * Will issue either UNMAP or WRITE SAME(16) depending on preference
 645 * indicated by target device.
 646 **/
 647static int sd_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
 648{
 649        struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 650        sector_t sector = blk_rq_pos(rq);
 651        unsigned int nr_sectors = blk_rq_sectors(rq);
 652        unsigned int nr_bytes = blk_rq_bytes(rq);
 653        unsigned int len;
 654        int ret;
 655        char *buf;
 656        struct page *page;
 657
 658        sector >>= ilog2(sdp->sector_size) - 9;
 659        nr_sectors >>= ilog2(sdp->sector_size) - 9;
 660        rq->timeout = SD_TIMEOUT;
 661
 662        memset(rq->cmd, 0, rq->cmd_len);
 663
 664        page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
 665        if (!page)
 666                return BLKPREP_DEFER;
 667
 668        switch (sdkp->provisioning_mode) {
 669        case SD_LBP_UNMAP:
 670                buf = page_address(page);
 671
 672                rq->cmd_len = 10;
 673                rq->cmd[0] = UNMAP;
 674                rq->cmd[8] = 24;
 675
 676                put_unaligned_be16(6 + 16, &buf[0]);
 677                put_unaligned_be16(16, &buf[2]);
 678                put_unaligned_be64(sector, &buf[8]);
 679                put_unaligned_be32(nr_sectors, &buf[16]);
 680
 681                len = 24;
 682                break;
 683
 684        case SD_LBP_WS16:
 685                rq->cmd_len = 16;
 686                rq->cmd[0] = WRITE_SAME_16;
 687                rq->cmd[1] = 0x8; /* UNMAP */
 688                put_unaligned_be64(sector, &rq->cmd[2]);
 689                put_unaligned_be32(nr_sectors, &rq->cmd[10]);
 690
 691                len = sdkp->device->sector_size;
 692                break;
 693
 694        case SD_LBP_WS10:
 695        case SD_LBP_ZERO:
 696                rq->cmd_len = 10;
 697                rq->cmd[0] = WRITE_SAME;
 698                if (sdkp->provisioning_mode == SD_LBP_WS10)
 699                        rq->cmd[1] = 0x8; /* UNMAP */
 700                put_unaligned_be32(sector, &rq->cmd[2]);
 701                put_unaligned_be16(nr_sectors, &rq->cmd[7]);
 702
 703                len = sdkp->device->sector_size;
 704                break;
 705
 706        default:
 707                ret = BLKPREP_KILL;
 708                goto out;
 709        }
 710
 711        blk_add_request_payload(rq, page, len);
 712        ret = scsi_setup_blk_pc_cmnd(sdp, rq);
 713        rq->buffer = page_address(page);
 714        rq->__data_len = nr_bytes;
 715
 716out:
 717        if (ret != BLKPREP_OK) {
 718                __free_page(page);
 719                rq->buffer = NULL;
 720        }
 721        return ret;
 722}
 723
 724static void sd_config_write_same(struct scsi_disk *sdkp)
 725{
 726        struct request_queue *q = sdkp->disk->queue;
 727        unsigned int logical_block_size = sdkp->device->sector_size;
 728        unsigned int blocks = 0;
 729
 730        if (sdkp->device->no_write_same) {
 731                sdkp->max_ws_blocks = 0;
 732                goto out;
 733        }
 734
 735        /* Some devices can not handle block counts above 0xffff despite
 736         * supporting WRITE SAME(16). Consequently we default to 64k
 737         * blocks per I/O unless the device explicitly advertises a
 738         * bigger limit.
 739         */
 740        if (sdkp->max_ws_blocks == 0)
 741                sdkp->max_ws_blocks = SD_MAX_WS10_BLOCKS;
 742
 743        if (sdkp->ws16 || sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
 744                blocks = min_not_zero(sdkp->max_ws_blocks,
 745                                      (u32)SD_MAX_WS16_BLOCKS);
 746        else
 747                blocks = min_not_zero(sdkp->max_ws_blocks,
 748                                      (u32)SD_MAX_WS10_BLOCKS);
 749
 750out:
 751        blk_queue_max_write_same_sectors(q, blocks * (logical_block_size >> 9));
 752}
 753
 754/**
 755 * sd_setup_write_same_cmnd - write the same data to multiple blocks
 756 * @sdp: scsi device to operate one
 757 * @rq: Request to prepare
 758 *
 759 * Will issue either WRITE SAME(10) or WRITE SAME(16) depending on
 760 * preference indicated by target device.
 761 **/
 762static int sd_setup_write_same_cmnd(struct scsi_device *sdp, struct request *rq)
 763{
 764        struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 765        struct bio *bio = rq->bio;
 766        sector_t sector = blk_rq_pos(rq);
 767        unsigned int nr_sectors = blk_rq_sectors(rq);
 768        unsigned int nr_bytes = blk_rq_bytes(rq);
 769        int ret;
 770
 771        if (sdkp->device->no_write_same)
 772                return BLKPREP_KILL;
 773
 774        BUG_ON(bio_offset(bio) || bio_iovec(bio)->bv_len != sdp->sector_size);
 775
 776        sector >>= ilog2(sdp->sector_size) - 9;
 777        nr_sectors >>= ilog2(sdp->sector_size) - 9;
 778
 779        rq->__data_len = sdp->sector_size;
 780        rq->timeout = SD_WRITE_SAME_TIMEOUT;
 781        memset(rq->cmd, 0, rq->cmd_len);
 782
 783        if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff) {
 784                rq->cmd_len = 16;
 785                rq->cmd[0] = WRITE_SAME_16;
 786                put_unaligned_be64(sector, &rq->cmd[2]);
 787                put_unaligned_be32(nr_sectors, &rq->cmd[10]);
 788        } else {
 789                rq->cmd_len = 10;
 790                rq->cmd[0] = WRITE_SAME;
 791                put_unaligned_be32(sector, &rq->cmd[2]);
 792                put_unaligned_be16(nr_sectors, &rq->cmd[7]);
 793        }
 794
 795        ret = scsi_setup_blk_pc_cmnd(sdp, rq);
 796        rq->__data_len = nr_bytes;
 797
 798        return ret;
 799}
 800
 801static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
 802{
 803        rq->timeout = SD_FLUSH_TIMEOUT;
 804        rq->retries = SD_MAX_RETRIES;
 805        rq->cmd[0] = SYNCHRONIZE_CACHE;
 806        rq->cmd_len = 10;
 807
 808        return scsi_setup_blk_pc_cmnd(sdp, rq);
 809}
 810
 811static void sd_unprep_fn(struct request_queue *q, struct request *rq)
 812{
 813        if (rq->cmd_flags & REQ_DISCARD) {
 814                free_page((unsigned long)rq->buffer);
 815                rq->buffer = NULL;
 816        }
 817}
 818
 819/**
 820 *      sd_prep_fn - build a scsi (read or write) command from
 821 *      information in the request structure.
 822 *      @SCpnt: pointer to mid-level's per scsi command structure that
 823 *      contains request and into which the scsi command is written
 824 *
 825 *      Returns 1 if successful and 0 if error (or cannot be done now).
 826 **/
 827static int sd_prep_fn(struct request_queue *q, struct request *rq)
 828{
 829        struct scsi_cmnd *SCpnt;
 830        struct scsi_device *sdp = q->queuedata;
 831        struct gendisk *disk = rq->rq_disk;
 832        struct scsi_disk *sdkp;
 833        sector_t block = blk_rq_pos(rq);
 834        sector_t threshold;
 835        unsigned int this_count = blk_rq_sectors(rq);
 836        int ret, host_dif;
 837        unsigned char protect;
 838
 839        /*
 840         * Discard request come in as REQ_TYPE_FS but we turn them into
 841         * block PC requests to make life easier.
 842         */
 843        if (rq->cmd_flags & REQ_DISCARD) {
 844                ret = sd_setup_discard_cmnd(sdp, rq);
 845                goto out;
 846        } else if (rq->cmd_flags & REQ_WRITE_SAME) {
 847                ret = sd_setup_write_same_cmnd(sdp, rq);
 848                goto out;
 849        } else if (rq->cmd_flags & REQ_FLUSH) {
 850                ret = scsi_setup_flush_cmnd(sdp, rq);
 851                goto out;
 852        } else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
 853                ret = scsi_setup_blk_pc_cmnd(sdp, rq);
 854                goto out;
 855        } else if (rq->cmd_type != REQ_TYPE_FS) {
 856                ret = BLKPREP_KILL;
 857                goto out;
 858        }
 859        ret = scsi_setup_fs_cmnd(sdp, rq);
 860        if (ret != BLKPREP_OK)
 861                goto out;
 862        SCpnt = rq->special;
 863        sdkp = scsi_disk(disk);
 864
 865        /* from here on until we're complete, any goto out
 866         * is used for a killable error condition */
 867        ret = BLKPREP_KILL;
 868
 869        SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
 870                                        "sd_prep_fn: block=%llu, "
 871                                        "count=%d\n",
 872                                        (unsigned long long)block,
 873                                        this_count));
 874
 875        if (!sdp || !scsi_device_online(sdp) ||
 876            block + blk_rq_sectors(rq) > get_capacity(disk)) {
 877                SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 878                                                "Finishing %u sectors\n",
 879                                                blk_rq_sectors(rq)));
 880                SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 881                                                "Retry with 0x%p\n", SCpnt));
 882                goto out;
 883        }
 884
 885        if (sdp->changed) {
 886                /*
 887                 * quietly refuse to do anything to a changed disc until 
 888                 * the changed bit has been reset
 889                 */
 890                /* printk("SCSI disk has been changed or is not present. Prohibiting further I/O.\n"); */
 891                goto out;
 892        }
 893
 894        /*
 895         * Some SD card readers can't handle multi-sector accesses which touch
 896         * the last one or two hardware sectors.  Split accesses as needed.
 897         */
 898        threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
 899                (sdp->sector_size / 512);
 900
 901        if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
 902                if (block < threshold) {
 903                        /* Access up to the threshold but not beyond */
 904                        this_count = threshold - block;
 905                } else {
 906                        /* Access only a single hardware sector */
 907                        this_count = sdp->sector_size / 512;
 908                }
 909        }
 910
 911        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
 912                                        (unsigned long long)block));
 913
 914        /*
 915         * If we have a 1K hardware sectorsize, prevent access to single
 916         * 512 byte sectors.  In theory we could handle this - in fact
 917         * the scsi cdrom driver must be able to handle this because
 918         * we typically use 1K blocksizes, and cdroms typically have
 919         * 2K hardware sectorsizes.  Of course, things are simpler
 920         * with the cdrom, since it is read-only.  For performance
 921         * reasons, the filesystems should be able to handle this
 922         * and not force the scsi disk driver to use bounce buffers
 923         * for this.
 924         */
 925        if (sdp->sector_size == 1024) {
 926                if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
 927                        scmd_printk(KERN_ERR, SCpnt,
 928                                    "Bad block number requested\n");
 929                        goto out;
 930                } else {
 931                        block = block >> 1;
 932                        this_count = this_count >> 1;
 933                }
 934        }
 935        if (sdp->sector_size == 2048) {
 936                if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
 937                        scmd_printk(KERN_ERR, SCpnt,
 938                                    "Bad block number requested\n");
 939                        goto out;
 940                } else {
 941                        block = block >> 2;
 942                        this_count = this_count >> 2;
 943                }
 944        }
 945        if (sdp->sector_size == 4096) {
 946                if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
 947                        scmd_printk(KERN_ERR, SCpnt,
 948                                    "Bad block number requested\n");
 949                        goto out;
 950                } else {
 951                        block = block >> 3;
 952                        this_count = this_count >> 3;
 953                }
 954        }
 955        if (rq_data_dir(rq) == WRITE) {
 956                if (!sdp->writeable) {
 957                        goto out;
 958                }
 959                SCpnt->cmnd[0] = WRITE_6;
 960                SCpnt->sc_data_direction = DMA_TO_DEVICE;
 961
 962                if (blk_integrity_rq(rq))
 963                        sd_dif_prepare(rq, block, sdp->sector_size);
 964
 965        } else if (rq_data_dir(rq) == READ) {
 966                SCpnt->cmnd[0] = READ_6;
 967                SCpnt->sc_data_direction = DMA_FROM_DEVICE;
 968        } else {
 969                scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
 970                goto out;
 971        }
 972
 973        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 974                                        "%s %d/%u 512 byte blocks.\n",
 975                                        (rq_data_dir(rq) == WRITE) ?
 976                                        "writing" : "reading", this_count,
 977                                        blk_rq_sectors(rq)));
 978
 979        /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
 980        host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
 981        if (host_dif)
 982                protect = 1 << 5;
 983        else
 984                protect = 0;
 985
 986        if (host_dif == SD_DIF_TYPE2_PROTECTION) {
 987                SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC);
 988
 989                if (unlikely(SCpnt->cmnd == NULL)) {
 990                        ret = BLKPREP_DEFER;
 991                        goto out;
 992                }
 993
 994                SCpnt->cmd_len = SD_EXT_CDB_SIZE;
 995                memset(SCpnt->cmnd, 0, SCpnt->cmd_len);
 996                SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
 997                SCpnt->cmnd[7] = 0x18;
 998                SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
 999                SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1000
1001                /* LBA */
1002                SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
1003                SCpnt->cmnd[13] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
1004                SCpnt->cmnd[14] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
1005                SCpnt->cmnd[15] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
1006                SCpnt->cmnd[16] = (unsigned char) (block >> 24) & 0xff;
1007                SCpnt->cmnd[17] = (unsigned char) (block >> 16) & 0xff;
1008                SCpnt->cmnd[18] = (unsigned char) (block >> 8) & 0xff;
1009                SCpnt->cmnd[19] = (unsigned char) block & 0xff;
1010
1011                /* Expected Indirect LBA */
1012                SCpnt->cmnd[20] = (unsigned char) (block >> 24) & 0xff;
1013                SCpnt->cmnd[21] = (unsigned char) (block >> 16) & 0xff;
1014                SCpnt->cmnd[22] = (unsigned char) (block >> 8) & 0xff;
1015                SCpnt->cmnd[23] = (unsigned char) block & 0xff;
1016
1017                /* Transfer length */
1018                SCpnt->cmnd[28] = (unsigned char) (this_count >> 24) & 0xff;
1019                SCpnt->cmnd[29] = (unsigned char) (this_count >> 16) & 0xff;
1020                SCpnt->cmnd[30] = (unsigned char) (this_count >> 8) & 0xff;
1021                SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
1022        } else if (sdp->use_16_for_rw) {
1023                SCpnt->cmnd[0] += READ_16 - READ_6;
1024                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1025                SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
1026                SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
1027                SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
1028                SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
1029                SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
1030                SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
1031                SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
1032                SCpnt->cmnd[9] = (unsigned char) block & 0xff;
1033                SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
1034                SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
1035                SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
1036                SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
1037                SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
1038        } else if ((this_count > 0xff) || (block > 0x1fffff) ||
1039                   scsi_device_protection(SCpnt->device) ||
1040                   SCpnt->device->use_10_for_rw) {
1041                if (this_count > 0xffff)
1042                        this_count = 0xffff;
1043
1044                SCpnt->cmnd[0] += READ_10 - READ_6;
1045                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1046                SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
1047                SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
1048                SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
1049                SCpnt->cmnd[5] = (unsigned char) block & 0xff;
1050                SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
1051                SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
1052                SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
1053        } else {
1054                if (unlikely(rq->cmd_flags & REQ_FUA)) {
1055                        /*
1056                         * This happens only if this drive failed
1057                         * 10byte rw command with ILLEGAL_REQUEST
1058                         * during operation and thus turned off
1059                         * use_10_for_rw.
1060                         */
1061                        scmd_printk(KERN_ERR, SCpnt,
1062                                    "FUA write on READ/WRITE(6) drive\n");
1063                        goto out;
1064                }
1065
1066                SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
1067                SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
1068                SCpnt->cmnd[3] = (unsigned char) block & 0xff;
1069                SCpnt->cmnd[4] = (unsigned char) this_count;
1070                SCpnt->cmnd[5] = 0;
1071        }
1072        SCpnt->sdb.length = this_count * sdp->sector_size;
1073
1074        /* If DIF or DIX is enabled, tell HBA how to handle request */
1075        if (host_dif || scsi_prot_sg_count(SCpnt))
1076                sd_prot_op(SCpnt, host_dif);
1077
1078        /*
1079         * We shouldn't disconnect in the middle of a sector, so with a dumb
1080         * host adapter, it's safe to assume that we can at least transfer
1081         * this many bytes between each connect / disconnect.
1082         */
1083        SCpnt->transfersize = sdp->sector_size;
1084        SCpnt->underflow = this_count << 9;
1085        SCpnt->allowed = SD_MAX_RETRIES;
1086
1087        /*
1088         * This indicates that the command is ready from our end to be
1089         * queued.
1090         */
1091        ret = BLKPREP_OK;
1092 out:
1093        return scsi_prep_return(q, rq, ret);
1094}
1095
1096/**
1097 *      sd_open - open a scsi disk device
1098 *      @inode: only i_rdev member may be used
1099 *      @filp: only f_mode and f_flags may be used
1100 *
1101 *      Returns 0 if successful. Returns a negated errno value in case 
1102 *      of error.
1103 *
1104 *      Note: This can be called from a user context (e.g. fsck(1) )
1105 *      or from within the kernel (e.g. as a result of a mount(1) ).
1106 *      In the latter case @inode and @filp carry an abridged amount
1107 *      of information as noted above.
1108 *
1109 *      Locking: called with bdev->bd_mutex held.
1110 **/
1111static int sd_open(struct block_device *bdev, fmode_t mode)
1112{
1113        struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
1114        struct scsi_device *sdev;
1115        int retval;
1116
1117        if (!sdkp)
1118                return -ENXIO;
1119
1120        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
1121
1122        sdev = sdkp->device;
1123
1124        retval = scsi_autopm_get_device(sdev);
1125        if (retval)
1126                goto error_autopm;
1127
1128        /*
1129         * If the device is in error recovery, wait until it is done.
1130         * If the device is offline, then disallow any access to it.
1131         */
1132        retval = -ENXIO;
1133        if (!scsi_block_when_processing_errors(sdev))
1134                goto error_out;
1135
1136        if (sdev->removable || sdkp->write_prot)
1137                check_disk_change(bdev);
1138
1139        /*
1140         * If the drive is empty, just let the open fail.
1141         */
1142        retval = -ENOMEDIUM;
1143        if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
1144                goto error_out;
1145
1146        /*
1147         * If the device has the write protect tab set, have the open fail
1148         * if the user expects to be able to write to the thing.
1149         */
1150        retval = -EROFS;
1151        if (sdkp->write_prot && (mode & FMODE_WRITE))
1152                goto error_out;
1153
1154        /*
1155         * It is possible that the disk changing stuff resulted in
1156         * the device being taken offline.  If this is the case,
1157         * report this to the user, and don't pretend that the
1158         * open actually succeeded.
1159         */
1160        retval = -ENXIO;
1161        if (!scsi_device_online(sdev))
1162                goto error_out;
1163
1164        if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
1165                if (scsi_block_when_processing_errors(sdev))
1166                        scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
1167        }
1168
1169        return 0;
1170
1171error_out:
1172        scsi_autopm_put_device(sdev);
1173error_autopm:
1174        scsi_disk_put(sdkp);
1175        return retval;  
1176}
1177
1178/**
1179 *      sd_release - invoked when the (last) close(2) is called on this
1180 *      scsi disk.
1181 *      @inode: only i_rdev member may be used
1182 *      @filp: only f_mode and f_flags may be used
1183 *
1184 *      Returns 0. 
1185 *
1186 *      Note: may block (uninterruptible) if error recovery is underway
1187 *      on this disk.
1188 *
1189 *      Locking: called with bdev->bd_mutex held.
1190 **/
1191static int sd_release(struct gendisk *disk, fmode_t mode)
1192{
1193        struct scsi_disk *sdkp = scsi_disk(disk);
1194        struct scsi_device *sdev = sdkp->device;
1195
1196        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
1197
1198        if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
1199                if (scsi_block_when_processing_errors(sdev))
1200                        scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
1201        }
1202
1203        /*
1204         * XXX and what if there are packets in flight and this close()
1205         * XXX is followed by a "rmmod sd_mod"?
1206         */
1207
1208        scsi_autopm_put_device(sdev);
1209        scsi_disk_put(sdkp);
1210        return 0;
1211}
1212
1213static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1214{
1215        struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
1216        struct scsi_device *sdp = sdkp->device;
1217        struct Scsi_Host *host = sdp->host;
1218        int diskinfo[4];
1219
1220        /* default to most commonly used values */
1221        diskinfo[0] = 0x40;     /* 1 << 6 */
1222        diskinfo[1] = 0x20;     /* 1 << 5 */
1223        diskinfo[2] = sdkp->capacity >> 11;
1224        
1225        /* override with calculated, extended default, or driver values */
1226        if (host->hostt->bios_param)
1227                host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
1228        else
1229                scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
1230
1231        geo->heads = diskinfo[0];
1232        geo->sectors = diskinfo[1];
1233        geo->cylinders = diskinfo[2];
1234        return 0;
1235}
1236
1237/**
1238 *      sd_ioctl - process an ioctl
1239 *      @inode: only i_rdev/i_bdev members may be used
1240 *      @filp: only f_mode and f_flags may be used
1241 *      @cmd: ioctl command number
1242 *      @arg: this is third argument given to ioctl(2) system call.
1243 *      Often contains a pointer.
1244 *
1245 *      Returns 0 if successful (some ioctls return positive numbers on
1246 *      success as well). Returns a negated errno value in case of error.
1247 *
1248 *      Note: most ioctls are forward onto the block subsystem or further
1249 *      down in the scsi subsystem.
1250 **/
1251static int sd_ioctl(struct block_device *bdev, fmode_t mode,
1252                    unsigned int cmd, unsigned long arg)
1253{
1254        struct gendisk *disk = bdev->bd_disk;
1255        struct scsi_disk *sdkp = scsi_disk(disk);
1256        struct scsi_device *sdp = sdkp->device;
1257        void __user *p = (void __user *)arg;
1258        int error;
1259    
1260        SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
1261                                    "cmd=0x%x\n", disk->disk_name, cmd));
1262
1263        error = scsi_verify_blk_ioctl(bdev, cmd);
1264        if (error < 0)
1265                return error;
1266
1267        /*
1268         * If we are in the middle of error recovery, don't let anyone
1269         * else try and use this device.  Also, if error recovery fails, it
1270         * may try and take the device offline, in which case all further
1271         * access to the device is prohibited.
1272         */
1273        error = scsi_nonblockable_ioctl(sdp, cmd, p,
1274                                        (mode & FMODE_NDELAY) != 0);
1275        if (!scsi_block_when_processing_errors(sdp) || !error)
1276                goto out;
1277
1278        /*
1279         * Send SCSI addressing ioctls directly to mid level, send other
1280         * ioctls to block level and then onto mid level if they can't be
1281         * resolved.
1282         */
1283        switch (cmd) {
1284                case SCSI_IOCTL_GET_IDLUN:
1285                case SCSI_IOCTL_GET_BUS_NUMBER:
1286                        error = scsi_ioctl(sdp, cmd, p);
1287                        break;
1288                default:
1289                        error = scsi_cmd_blk_ioctl(bdev, mode, cmd, p);
1290                        if (error != -ENOTTY)
1291                                break;
1292                        error = scsi_ioctl(sdp, cmd, p);
1293                        break;
1294        }
1295out:
1296        return error;
1297}
1298
1299static void set_media_not_present(struct scsi_disk *sdkp)
1300{
1301        if (sdkp->media_present)
1302                sdkp->device->changed = 1;
1303
1304        if (sdkp->device->removable) {
1305                sdkp->media_present = 0;
1306                sdkp->capacity = 0;
1307        }
1308}
1309
1310static int media_not_present(struct scsi_disk *sdkp,
1311                             struct scsi_sense_hdr *sshdr)
1312{
1313        if (!scsi_sense_valid(sshdr))
1314                return 0;
1315
1316        /* not invoked for commands that could return deferred errors */
1317        switch (sshdr->sense_key) {
1318        case UNIT_ATTENTION:
1319        case NOT_READY:
1320                /* medium not present */
1321                if (sshdr->asc == 0x3A) {
1322                        set_media_not_present(sdkp);
1323                        return 1;
1324                }
1325        }
1326        return 0;
1327}
1328
1329/**
1330 *      sd_check_events - check media events
1331 *      @disk: kernel device descriptor
1332 *      @clearing: disk events currently being cleared
1333 *
1334 *      Returns mask of DISK_EVENT_*.
1335 *
1336 *      Note: this function is invoked from the block subsystem.
1337 **/
1338static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
1339{
1340        struct scsi_disk *sdkp = scsi_disk(disk);
1341        struct scsi_device *sdp = sdkp->device;
1342        struct scsi_sense_hdr *sshdr = NULL;
1343        int retval;
1344
1345        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n"));
1346
1347        /*
1348         * If the device is offline, don't send any commands - just pretend as
1349         * if the command failed.  If the device ever comes back online, we
1350         * can deal with it then.  It is only because of unrecoverable errors
1351         * that we would ever take a device offline in the first place.
1352         */
1353        if (!scsi_device_online(sdp)) {
1354                set_media_not_present(sdkp);
1355                goto out;
1356        }
1357
1358        /*
1359         * Using TEST_UNIT_READY enables differentiation between drive with
1360         * no cartridge loaded - NOT READY, drive with changed cartridge -
1361         * UNIT ATTENTION, or with same cartridge - GOOD STATUS.
1362         *
1363         * Drives that auto spin down. eg iomega jaz 1G, will be started
1364         * by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever
1365         * sd_revalidate() is called.
1366         */
1367        retval = -ENODEV;
1368
1369        if (scsi_block_when_processing_errors(sdp)) {
1370                retval = scsi_autopm_get_device(sdp);
1371                if (retval)
1372                        goto out;
1373
1374                sshdr  = kzalloc(sizeof(*sshdr), GFP_KERNEL);
1375                retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
1376                                              sshdr);
1377                scsi_autopm_put_device(sdp);
1378        }
1379
1380        /* failed to execute TUR, assume media not present */
1381        if (host_byte(retval)) {
1382                set_media_not_present(sdkp);
1383                goto out;
1384        }
1385
1386        if (media_not_present(sdkp, sshdr))
1387                goto out;
1388
1389        /*
1390         * For removable scsi disk we have to recognise the presence
1391         * of a disk in the drive.
1392         */
1393        if (!sdkp->media_present)
1394                sdp->changed = 1;
1395        sdkp->media_present = 1;
1396out:
1397        /*
1398         * sdp->changed is set under the following conditions:
1399         *
1400         *      Medium present state has changed in either direction.
1401         *      Device has indicated UNIT_ATTENTION.
1402         */
1403        kfree(sshdr);
1404        retval = sdp->changed ? DISK_EVENT_MEDIA_CHANGE : 0;
1405        sdp->changed = 0;
1406        return retval;
1407}
1408
1409static int sd_sync_cache(struct scsi_disk *sdkp)
1410{
1411        int retries, res;
1412        struct scsi_device *sdp = sdkp->device;
1413        struct scsi_sense_hdr sshdr;
1414
1415        if (!scsi_device_online(sdp))
1416                return -ENODEV;
1417
1418
1419        for (retries = 3; retries > 0; --retries) {
1420                unsigned char cmd[10] = { 0 };
1421
1422                cmd[0] = SYNCHRONIZE_CACHE;
1423                /*
1424                 * Leave the rest of the command zero to indicate
1425                 * flush everything.
1426                 */
1427                res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
1428                                       SD_FLUSH_TIMEOUT, SD_MAX_RETRIES, NULL);
1429                if (res == 0)
1430                        break;
1431        }
1432
1433        if (res) {
1434                sd_print_result(sdkp, res);
1435                if (driver_byte(res) & DRIVER_SENSE)
1436                        sd_print_sense_hdr(sdkp, &sshdr);
1437        }
1438
1439        if (res)
1440                return -EIO;
1441        return 0;
1442}
1443
1444static void sd_rescan(struct device *dev)
1445{
1446        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
1447
1448        if (sdkp) {
1449                revalidate_disk(sdkp->disk);
1450                scsi_disk_put(sdkp);
1451        }
1452}
1453
1454
1455#ifdef CONFIG_COMPAT
1456/* 
1457 * This gets directly called from VFS. When the ioctl 
1458 * is not recognized we go back to the other translation paths. 
1459 */
1460static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
1461                           unsigned int cmd, unsigned long arg)
1462{
1463        struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
1464        int ret;
1465
1466        ret = scsi_verify_blk_ioctl(bdev, cmd);
1467        if (ret < 0)
1468                return ret;
1469
1470        /*
1471         * If we are in the middle of error recovery, don't let anyone
1472         * else try and use this device.  Also, if error recovery fails, it
1473         * may try and take the device offline, in which case all further
1474         * access to the device is prohibited.
1475         */
1476        if (!scsi_block_when_processing_errors(sdev))
1477                return -ENODEV;
1478               
1479        if (sdev->host->hostt->compat_ioctl) {
1480                ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
1481
1482                return ret;
1483        }
1484
1485        /* 
1486         * Let the static ioctl translation table take care of it.
1487         */
1488        return -ENOIOCTLCMD; 
1489}
1490#endif
1491
1492static const struct block_device_operations sd_fops = {
1493        .owner                  = THIS_MODULE,
1494        .open                   = sd_open,
1495        .release                = sd_release,
1496        .ioctl                  = sd_ioctl,
1497        .getgeo                 = sd_getgeo,
1498#ifdef CONFIG_COMPAT
1499        .compat_ioctl           = sd_compat_ioctl,
1500#endif
1501        .check_events           = sd_check_events,
1502        .revalidate_disk        = sd_revalidate_disk,
1503        .unlock_native_capacity = sd_unlock_native_capacity,
1504};
1505
1506/**
1507 *      sd_eh_action - error handling callback
1508 *      @scmd:          sd-issued command that has failed
1509 *      @eh_cmnd:       The command that was sent during error handling
1510 *      @eh_cmnd_len:   Length of eh_cmnd in bytes
1511 *      @eh_disp:       The recovery disposition suggested by the midlayer
1512 *
1513 *      This function is called by the SCSI midlayer upon completion of
1514 *      an error handling command (TEST UNIT READY, START STOP UNIT,
1515 *      etc.) The command sent to the device by the error handler is
1516 *      stored in eh_cmnd. The result of sending the eh command is
1517 *      passed in eh_disp.
1518 **/
1519static int sd_eh_action(struct scsi_cmnd *scmd, unsigned char *eh_cmnd,
1520                        int eh_cmnd_len, int eh_disp)
1521{
1522        struct scsi_disk *sdkp = scsi_disk(scmd->request->rq_disk);
1523
1524        if (!scsi_device_online(scmd->device) ||
1525            !scsi_medium_access_command(scmd))
1526                return eh_disp;
1527
1528        /*
1529         * The device has timed out executing a medium access command.
1530         * However, the TEST UNIT READY command sent during error
1531         * handling completed successfully. Either the device is in the
1532         * process of recovering or has it suffered an internal failure
1533         * that prevents access to the storage medium.
1534         */
1535        if (host_byte(scmd->result) == DID_TIME_OUT && eh_disp == SUCCESS &&
1536            eh_cmnd_len && eh_cmnd[0] == TEST_UNIT_READY)
1537                sdkp->medium_access_timed_out++;
1538
1539        /*
1540         * If the device keeps failing read/write commands but TEST UNIT
1541         * READY always completes successfully we assume that medium
1542         * access is no longer possible and take the device offline.
1543         */
1544        if (sdkp->medium_access_timed_out >= sdkp->max_medium_access_timeouts) {
1545                scmd_printk(KERN_ERR, scmd,
1546                            "Medium access timeout failure. Offlining disk!\n");
1547                scsi_device_set_state(scmd->device, SDEV_OFFLINE);
1548
1549                return FAILED;
1550        }
1551
1552        return eh_disp;
1553}
1554
1555static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
1556{
1557        u64 start_lba = blk_rq_pos(scmd->request);
1558        u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
1559        u64 bad_lba;
1560        int info_valid;
1561        /*
1562         * resid is optional but mostly filled in.  When it's unused,
1563         * its value is zero, so we assume the whole buffer transferred
1564         */
1565        unsigned int transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd);
1566        unsigned int good_bytes;
1567
1568        if (scmd->request->cmd_type != REQ_TYPE_FS)
1569                return 0;
1570
1571        info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
1572                                             SCSI_SENSE_BUFFERSIZE,
1573                                             &bad_lba);
1574        if (!info_valid)
1575                return 0;
1576
1577        if (scsi_bufflen(scmd) <= scmd->device->sector_size)
1578                return 0;
1579
1580        if (scmd->device->sector_size < 512) {
1581                /* only legitimate sector_size here is 256 */
1582                start_lba <<= 1;
1583                end_lba <<= 1;
1584        } else {
1585                /* be careful ... don't want any overflows */
1586                u64 factor = scmd->device->sector_size / 512;
1587                do_div(start_lba, factor);
1588                do_div(end_lba, factor);
1589        }
1590
1591        /* The bad lba was reported incorrectly, we have no idea where
1592         * the error is.
1593         */
1594        if (bad_lba < start_lba  || bad_lba >= end_lba)
1595                return 0;
1596
1597        /* This computation should always be done in terms of
1598         * the resolution of the device's medium.
1599         */
1600        good_bytes = (bad_lba - start_lba) * scmd->device->sector_size;
1601        return min(good_bytes, transferred);
1602}
1603
1604/**
1605 *      sd_done - bottom half handler: called when the lower level
1606 *      driver has completed (successfully or otherwise) a scsi command.
1607 *      @SCpnt: mid-level's per command structure.
1608 *
1609 *      Note: potentially run from within an ISR. Must not block.
1610 **/
1611static int sd_done(struct scsi_cmnd *SCpnt)
1612{
1613        int result = SCpnt->result;
1614        unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
1615        struct scsi_sense_hdr sshdr;
1616        struct scsi_disk *sdkp = scsi_disk(SCpnt->request->rq_disk);
1617        struct request *req = SCpnt->request;
1618        int sense_valid = 0;
1619        int sense_deferred = 0;
1620        unsigned char op = SCpnt->cmnd[0];
1621        unsigned char unmap = SCpnt->cmnd[1] & 8;
1622
1623        if (req->cmd_flags & REQ_DISCARD || req->cmd_flags & REQ_WRITE_SAME) {
1624                if (!result) {
1625                        good_bytes = blk_rq_bytes(req);
1626                        scsi_set_resid(SCpnt, 0);
1627                } else {
1628                        good_bytes = 0;
1629                        scsi_set_resid(SCpnt, blk_rq_bytes(req));
1630                }
1631        }
1632
1633        if (result) {
1634                sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
1635                if (sense_valid)
1636                        sense_deferred = scsi_sense_is_deferred(&sshdr);
1637        }
1638#ifdef CONFIG_SCSI_LOGGING
1639        SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
1640        if (sense_valid) {
1641                SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
1642                                                   "sd_done: sb[respc,sk,asc,"
1643                                                   "ascq]=%x,%x,%x,%x\n",
1644                                                   sshdr.response_code,
1645                                                   sshdr.sense_key, sshdr.asc,
1646                                                   sshdr.ascq));
1647        }
1648#endif
1649        if (driver_byte(result) != DRIVER_SENSE &&
1650            (!sense_valid || sense_deferred))
1651                goto out;
1652
1653        sdkp->medium_access_timed_out = 0;
1654
1655        switch (sshdr.sense_key) {
1656        case HARDWARE_ERROR:
1657        case MEDIUM_ERROR:
1658                good_bytes = sd_completed_bytes(SCpnt);
1659                break;
1660        case RECOVERED_ERROR:
1661                good_bytes = scsi_bufflen(SCpnt);
1662                break;
1663        case NO_SENSE:
1664                /* This indicates a false check condition, so ignore it.  An
1665                 * unknown amount of data was transferred so treat it as an
1666                 * error.
1667                 */
1668                scsi_print_sense("sd", SCpnt);
1669                SCpnt->result = 0;
1670                memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1671                break;
1672        case ABORTED_COMMAND:
1673                if (sshdr.asc == 0x10)  /* DIF: Target detected corruption */
1674                        good_bytes = sd_completed_bytes(SCpnt);
1675                break;
1676        case ILLEGAL_REQUEST:
1677                if (sshdr.asc == 0x10)  /* DIX: Host detected corruption */
1678                        good_bytes = sd_completed_bytes(SCpnt);
1679                /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
1680                if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
1681                        switch (op) {
1682                        case UNMAP:
1683                                sd_config_discard(sdkp, SD_LBP_DISABLE);
1684                                break;
1685                        case WRITE_SAME_16:
1686                        case WRITE_SAME:
1687                                if (unmap)
1688                                        sd_config_discard(sdkp, SD_LBP_DISABLE);
1689                                else {
1690                                        sdkp->device->no_write_same = 1;
1691                                        sd_config_write_same(sdkp);
1692
1693                                        good_bytes = 0;
1694                                        req->__data_len = blk_rq_bytes(req);
1695                                        req->cmd_flags |= REQ_QUIET;
1696                                }
1697                        }
1698                }
1699                break;
1700        default:
1701                break;
1702        }
1703 out:
1704        if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
1705                sd_dif_complete(SCpnt, good_bytes);
1706
1707        if (scsi_host_dif_capable(sdkp->device->host, sdkp->protection_type)
1708            == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd) {
1709
1710                /* We have to print a failed command here as the
1711                 * extended CDB gets freed before scsi_io_completion()
1712                 * is called.
1713                 */
1714                if (result)
1715                        scsi_print_command(SCpnt);
1716
1717                mempool_free(SCpnt->cmnd, sd_cdb_pool);
1718                SCpnt->cmnd = NULL;
1719                SCpnt->cmd_len = 0;
1720        }
1721
1722        return good_bytes;
1723}
1724
1725/*
1726 * spinup disk - called only in sd_revalidate_disk()
1727 */
1728static void
1729sd_spinup_disk(struct scsi_disk *sdkp)
1730{
1731        unsigned char cmd[10];
1732        unsigned long spintime_expire = 0;
1733        int retries, spintime;
1734        unsigned int the_result;
1735        struct scsi_sense_hdr sshdr;
1736        int sense_valid = 0;
1737
1738        spintime = 0;
1739
1740        /* Spin up drives, as required.  Only do this at boot time */
1741        /* Spinup needs to be done for module loads too. */
1742        do {
1743                retries = 0;
1744
1745                do {
1746                        cmd[0] = TEST_UNIT_READY;
1747                        memset((void *) &cmd[1], 0, 9);
1748
1749                        the_result = scsi_execute_req(sdkp->device, cmd,
1750                                                      DMA_NONE, NULL, 0,
1751                                                      &sshdr, SD_TIMEOUT,
1752                                                      SD_MAX_RETRIES, NULL);
1753
1754                        /*
1755                         * If the drive has indicated to us that it
1756                         * doesn't have any media in it, don't bother
1757                         * with any more polling.
1758                         */
1759                        if (media_not_present(sdkp, &sshdr))
1760                                return;
1761
1762                        if (the_result)
1763                                sense_valid = scsi_sense_valid(&sshdr);
1764                        retries++;
1765                } while (retries < 3 && 
1766                         (!scsi_status_is_good(the_result) ||
1767                          ((driver_byte(the_result) & DRIVER_SENSE) &&
1768                          sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
1769
1770                if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
1771                        /* no sense, TUR either succeeded or failed
1772                         * with a status error */
1773                        if(!spintime && !scsi_status_is_good(the_result)) {
1774                                sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1775                                sd_print_result(sdkp, the_result);
1776                        }
1777                        break;
1778                }
1779                                        
1780                /*
1781                 * The device does not want the automatic start to be issued.
1782                 */
1783                if (sdkp->device->no_start_on_add)
1784                        break;
1785
1786                if (sense_valid && sshdr.sense_key == NOT_READY) {
1787                        if (sshdr.asc == 4 && sshdr.ascq == 3)
1788                                break;  /* manual intervention required */
1789                        if (sshdr.asc == 4 && sshdr.ascq == 0xb)
1790                                break;  /* standby */
1791                        if (sshdr.asc == 4 && sshdr.ascq == 0xc)
1792                                break;  /* unavailable */
1793                        /*
1794                         * Issue command to spin up drive when not ready
1795                         */
1796                        if (!spintime) {
1797                                sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
1798                                cmd[0] = START_STOP;
1799                                cmd[1] = 1;     /* Return immediately */
1800                                memset((void *) &cmd[2], 0, 8);
1801                                cmd[4] = 1;     /* Start spin cycle */
1802                                if (sdkp->device->start_stop_pwr_cond)
1803                                        cmd[4] |= 1 << 4;
1804                                scsi_execute_req(sdkp->device, cmd, DMA_NONE,
1805                                                 NULL, 0, &sshdr,
1806                                                 SD_TIMEOUT, SD_MAX_RETRIES,
1807                                                 NULL);
1808                                spintime_expire = jiffies + 100 * HZ;
1809                                spintime = 1;
1810                        }
1811                        /* Wait 1 second for next try */
1812                        msleep(1000);
1813                        printk(".");
1814
1815                /*
1816                 * Wait for USB flash devices with slow firmware.
1817                 * Yes, this sense key/ASC combination shouldn't
1818                 * occur here.  It's characteristic of these devices.
1819                 */
1820                } else if (sense_valid &&
1821                                sshdr.sense_key == UNIT_ATTENTION &&
1822                                sshdr.asc == 0x28) {
1823                        if (!spintime) {
1824                                spintime_expire = jiffies + 5 * HZ;
1825                                spintime = 1;
1826                        }
1827                        /* Wait 1 second for next try */
1828                        msleep(1000);
1829                } else {
1830                        /* we don't understand the sense code, so it's
1831                         * probably pointless to loop */
1832                        if(!spintime) {
1833                                sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1834                                sd_print_sense_hdr(sdkp, &sshdr);
1835                        }
1836                        break;
1837                }
1838                                
1839        } while (spintime && time_before_eq(jiffies, spintime_expire));
1840
1841        if (spintime) {
1842                if (scsi_status_is_good(the_result))
1843                        printk("ready\n");
1844                else
1845                        printk("not responding...\n");
1846        }
1847}
1848
1849
1850/*
1851 * Determine whether disk supports Data Integrity Field.
1852 */
1853static int sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
1854{
1855        struct scsi_device *sdp = sdkp->device;
1856        u8 type;
1857        int ret = 0;
1858
1859        if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0)
1860                return ret;
1861
1862        type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
1863
1864        if (type > SD_DIF_TYPE3_PROTECTION)
1865                ret = -ENODEV;
1866        else if (scsi_host_dif_capable(sdp->host, type))
1867                ret = 1;
1868
1869        if (sdkp->first_scan || type != sdkp->protection_type)
1870                switch (ret) {
1871                case -ENODEV:
1872                        sd_printk(KERN_ERR, sdkp, "formatted with unsupported" \
1873                                  " protection type %u. Disabling disk!\n",
1874                                  type);
1875                        break;
1876                case 1:
1877                        sd_printk(KERN_NOTICE, sdkp,
1878                                  "Enabling DIF Type %u protection\n", type);
1879                        break;
1880                case 0:
1881                        sd_printk(KERN_NOTICE, sdkp,
1882                                  "Disabling DIF Type %u protection\n", type);
1883                        break;
1884                }
1885
1886        sdkp->protection_type = type;
1887
1888        return ret;
1889}
1890
1891static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
1892                        struct scsi_sense_hdr *sshdr, int sense_valid,
1893                        int the_result)
1894{
1895        sd_print_result(sdkp, the_result);
1896        if (driver_byte(the_result) & DRIVER_SENSE)
1897                sd_print_sense_hdr(sdkp, sshdr);
1898        else
1899                sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
1900
1901        /*
1902         * Set dirty bit for removable devices if not ready -
1903         * sometimes drives will not report this properly.
1904         */
1905        if (sdp->removable &&
1906            sense_valid && sshdr->sense_key == NOT_READY)
1907                set_media_not_present(sdkp);
1908
1909        /*
1910         * We used to set media_present to 0 here to indicate no media
1911         * in the drive, but some drives fail read capacity even with
1912         * media present, so we can't do that.
1913         */
1914        sdkp->capacity = 0; /* unknown mapped to zero - as usual */
1915}
1916
1917#define RC16_LEN 32
1918#if RC16_LEN > SD_BUF_SIZE
1919#error RC16_LEN must not be more than SD_BUF_SIZE
1920#endif
1921
1922#define READ_CAPACITY_RETRIES_ON_RESET  10
1923
1924static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
1925                                                unsigned char *buffer)
1926{
1927        unsigned char cmd[16];
1928        struct scsi_sense_hdr sshdr;
1929        int sense_valid = 0;
1930        int the_result;
1931        int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
1932        unsigned int alignment;
1933        unsigned long long lba;
1934        unsigned sector_size;
1935
1936        if (sdp->no_read_capacity_16)
1937                return -EINVAL;
1938
1939        do {
1940                memset(cmd, 0, 16);
1941                cmd[0] = SERVICE_ACTION_IN;
1942                cmd[1] = SAI_READ_CAPACITY_16;
1943                cmd[13] = RC16_LEN;
1944                memset(buffer, 0, RC16_LEN);
1945
1946                the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
1947                                        buffer, RC16_LEN, &sshdr,
1948                                        SD_TIMEOUT, SD_MAX_RETRIES, NULL);
1949
1950                if (media_not_present(sdkp, &sshdr))
1951                        return -ENODEV;
1952
1953                if (the_result) {
1954                        sense_valid = scsi_sense_valid(&sshdr);
1955                        if (sense_valid &&
1956                            sshdr.sense_key == ILLEGAL_REQUEST &&
1957                            (sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
1958                            sshdr.ascq == 0x00)
1959                                /* Invalid Command Operation Code or
1960                                 * Invalid Field in CDB, just retry
1961                                 * silently with RC10 */
1962                                return -EINVAL;
1963                        if (sense_valid &&
1964                            sshdr.sense_key == UNIT_ATTENTION &&
1965                            sshdr.asc == 0x29 && sshdr.ascq == 0x00)
1966                                /* Device reset might occur several times,
1967                                 * give it one more chance */
1968                                if (--reset_retries > 0)
1969                                        continue;
1970                }
1971                retries--;
1972
1973        } while (the_result && retries);
1974
1975        if (the_result) {
1976                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
1977                read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
1978                return -EINVAL;
1979        }
1980
1981        sector_size = get_unaligned_be32(&buffer[8]);
1982        lba = get_unaligned_be64(&buffer[0]);
1983
1984        if (sd_read_protection_type(sdkp, buffer) < 0) {
1985                sdkp->capacity = 0;
1986                return -ENODEV;
1987        }
1988
1989        if ((sizeof(sdkp->capacity) == 4) && (lba >= 0xffffffffULL)) {
1990                sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
1991                        "kernel compiled with support for large block "
1992                        "devices.\n");
1993                sdkp->capacity = 0;
1994                return -EOVERFLOW;
1995        }
1996
1997        /* Logical blocks per physical block exponent */
1998        sdkp->physical_block_size = (1 << (buffer[13] & 0xf)) * sector_size;
1999
2000        /* Lowest aligned logical block */
2001        alignment = ((buffer[14] & 0x3f) << 8 | buffer[15]) * sector_size;
2002        blk_queue_alignment_offset(sdp->request_queue, alignment);
2003        if (alignment && sdkp->first_scan)
2004                sd_printk(KERN_NOTICE, sdkp,
2005                          "physical block alignment offset: %u\n", alignment);
2006
2007        if (buffer[14] & 0x80) { /* LBPME */
2008                sdkp->lbpme = 1;
2009
2010                if (buffer[14] & 0x40) /* LBPRZ */
2011                        sdkp->lbprz = 1;
2012
2013                sd_config_discard(sdkp, SD_LBP_WS16);
2014        }
2015
2016        sdkp->capacity = lba + 1;
2017        return sector_size;
2018}
2019
2020static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
2021                                                unsigned char *buffer)
2022{
2023        unsigned char cmd[16];
2024        struct scsi_sense_hdr sshdr;
2025        int sense_valid = 0;
2026        int the_result;
2027        int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
2028        sector_t lba;
2029        unsigned sector_size;
2030
2031        do {
2032                cmd[0] = READ_CAPACITY;
2033                memset(&cmd[1], 0, 9);
2034                memset(buffer, 0, 8);
2035
2036                the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
2037                                        buffer, 8, &sshdr,
2038                                        SD_TIMEOUT, SD_MAX_RETRIES, NULL);
2039
2040                if (media_not_present(sdkp, &sshdr))
2041                        return -ENODEV;
2042
2043                if (the_result) {
2044                        sense_valid = scsi_sense_valid(&sshdr);
2045                        if (sense_valid &&
2046                            sshdr.sense_key == UNIT_ATTENTION &&
2047                            sshdr.asc == 0x29 && sshdr.ascq == 0x00)
2048                                /* Device reset might occur several times,
2049                                 * give it one more chance */
2050                                if (--reset_retries > 0)
2051                                        continue;
2052                }
2053                retries--;
2054
2055        } while (the_result && retries);
2056
2057        if (the_result) {
2058                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
2059                read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
2060                return -EINVAL;
2061        }
2062
2063        sector_size = get_unaligned_be32(&buffer[4]);
2064        lba = get_unaligned_be32(&buffer[0]);
2065
2066        if (sdp->no_read_capacity_16 && (lba == 0xffffffff)) {
2067                /* Some buggy (usb cardreader) devices return an lba of
2068                   0xffffffff when the want to report a size of 0 (with
2069                   which they really mean no media is present) */
2070                sdkp->capacity = 0;
2071                sdkp->physical_block_size = sector_size;
2072                return sector_size;
2073        }
2074
2075        if ((sizeof(sdkp->capacity) == 4) && (lba == 0xffffffff)) {
2076                sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
2077                        "kernel compiled with support for large block "
2078                        "devices.\n");
2079                sdkp->capacity = 0;
2080                return -EOVERFLOW;
2081        }
2082
2083        sdkp->capacity = lba + 1;
2084        sdkp->physical_block_size = sector_size;
2085        return sector_size;
2086}
2087
2088static int sd_try_rc16_first(struct scsi_device *sdp)
2089{
2090        if (sdp->host->max_cmd_len < 16)
2091                return 0;
2092        if (sdp->try_rc_10_first)
2093                return 0;
2094        if (sdp->scsi_level > SCSI_SPC_2)
2095                return 1;
2096        if (scsi_device_protection(sdp))
2097                return 1;
2098        return 0;
2099}
2100
2101/*
2102 * read disk capacity
2103 */
2104static void
2105sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
2106{
2107        int sector_size;
2108        struct scsi_device *sdp = sdkp->device;
2109        sector_t old_capacity = sdkp->capacity;
2110
2111        if (sd_try_rc16_first(sdp)) {
2112                sector_size = read_capacity_16(sdkp, sdp, buffer);
2113                if (sector_size == -EOVERFLOW)
2114                        goto got_data;
2115                if (sector_size == -ENODEV)
2116                        return;
2117                if (sector_size < 0)
2118                        sector_size = read_capacity_10(sdkp, sdp, buffer);
2119                if (sector_size < 0)
2120                        return;
2121        } else {
2122                sector_size = read_capacity_10(sdkp, sdp, buffer);
2123                if (sector_size == -EOVERFLOW)
2124                        goto got_data;
2125                if (sector_size < 0)
2126                        return;
2127                if ((sizeof(sdkp->capacity) > 4) &&
2128                    (sdkp->capacity > 0xffffffffULL)) {
2129                        int old_sector_size = sector_size;
2130                        sd_printk(KERN_NOTICE, sdkp, "Very big device. "
2131                                        "Trying to use READ CAPACITY(16).\n");
2132                        sector_size = read_capacity_16(sdkp, sdp, buffer);
2133                        if (sector_size < 0) {
2134                                sd_printk(KERN_NOTICE, sdkp,
2135                                        "Using 0xffffffff as device size\n");
2136                                sdkp->capacity = 1 + (sector_t) 0xffffffff;
2137                                sector_size = old_sector_size;
2138                                goto got_data;
2139                        }
2140                }
2141        }
2142
2143        /* Some devices are known to return the total number of blocks,
2144         * not the highest block number.  Some devices have versions
2145         * which do this and others which do not.  Some devices we might
2146         * suspect of doing this but we don't know for certain.
2147         *
2148         * If we know the reported capacity is wrong, decrement it.  If
2149         * we can only guess, then assume the number of blocks is even
2150         * (usually true but not always) and err on the side of lowering
2151         * the capacity.
2152         */
2153        if (sdp->fix_capacity ||
2154            (sdp->guess_capacity && (sdkp->capacity & 0x01))) {
2155                sd_printk(KERN_INFO, sdkp, "Adjusting the sector count "
2156                                "from its reported value: %llu\n",
2157                                (unsigned long long) sdkp->capacity);
2158                --sdkp->capacity;
2159        }
2160
2161got_data:
2162        if (sector_size == 0) {
2163                sector_size = 512;
2164                sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
2165                          "assuming 512.\n");
2166        }
2167
2168        if (sector_size != 512 &&
2169            sector_size != 1024 &&
2170            sector_size != 2048 &&
2171            sector_size != 4096 &&
2172            sector_size != 256) {
2173                sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
2174                          sector_size);
2175                /*
2176                 * The user might want to re-format the drive with
2177                 * a supported sectorsize.  Once this happens, it
2178                 * would be relatively trivial to set the thing up.
2179                 * For this reason, we leave the thing in the table.
2180                 */
2181                sdkp->capacity = 0;
2182                /*
2183                 * set a bogus sector size so the normal read/write
2184                 * logic in the block layer will eventually refuse any
2185                 * request on this device without tripping over power
2186                 * of two sector size assumptions
2187                 */
2188                sector_size = 512;
2189        }
2190        blk_queue_logical_block_size(sdp->request_queue, sector_size);
2191
2192        {
2193                char cap_str_2[10], cap_str_10[10];
2194                u64 sz = (u64)sdkp->capacity << ilog2(sector_size);
2195
2196                string_get_size(sz, STRING_UNITS_2, cap_str_2,
2197                                sizeof(cap_str_2));
2198                string_get_size(sz, STRING_UNITS_10, cap_str_10,
2199                                sizeof(cap_str_10));
2200
2201                if (sdkp->first_scan || old_capacity != sdkp->capacity) {
2202                        sd_printk(KERN_NOTICE, sdkp,
2203                                  "%llu %d-byte logical blocks: (%s/%s)\n",
2204                                  (unsigned long long)sdkp->capacity,
2205                                  sector_size, cap_str_10, cap_str_2);
2206
2207                        if (sdkp->physical_block_size != sector_size)
2208                                sd_printk(KERN_NOTICE, sdkp,
2209                                          "%u-byte physical blocks\n",
2210                                          sdkp->physical_block_size);
2211                }
2212        }
2213
2214        sdp->use_16_for_rw = (sdkp->capacity > 0xffffffff);
2215
2216        /* Rescale capacity to 512-byte units */
2217        if (sector_size == 4096)
2218                sdkp->capacity <<= 3;
2219        else if (sector_size == 2048)
2220                sdkp->capacity <<= 2;
2221        else if (sector_size == 1024)
2222                sdkp->capacity <<= 1;
2223        else if (sector_size == 256)
2224                sdkp->capacity >>= 1;
2225
2226        blk_queue_physical_block_size(sdp->request_queue,
2227                                      sdkp->physical_block_size);
2228        sdkp->device->sector_size = sector_size;
2229}
2230
2231/* called with buffer of length 512 */
2232static inline int
2233sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
2234                 unsigned char *buffer, int len, struct scsi_mode_data *data,
2235                 struct scsi_sense_hdr *sshdr)
2236{
2237        return scsi_mode_sense(sdp, dbd, modepage, buffer, len,
2238                               SD_TIMEOUT, SD_MAX_RETRIES, data,
2239                               sshdr);
2240}
2241
2242/*
2243 * read write protect setting, if possible - called only in sd_revalidate_disk()
2244 * called with buffer of length SD_BUF_SIZE
2245 */
2246static void
2247sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
2248{
2249        int res;
2250        struct scsi_device *sdp = sdkp->device;
2251        struct scsi_mode_data data;
2252        int old_wp = sdkp->write_prot;
2253
2254        set_disk_ro(sdkp->disk, 0);
2255        if (sdp->skip_ms_page_3f) {
2256                sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
2257                return;
2258        }
2259
2260        if (sdp->use_192_bytes_for_3f) {
2261                res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL);
2262        } else {
2263                /*
2264                 * First attempt: ask for all pages (0x3F), but only 4 bytes.
2265                 * We have to start carefully: some devices hang if we ask
2266                 * for more than is available.
2267                 */
2268                res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL);
2269
2270                /*
2271                 * Second attempt: ask for page 0 When only page 0 is
2272                 * implemented, a request for page 3F may return Sense Key
2273                 * 5: Illegal Request, Sense Code 24: Invalid field in
2274                 * CDB.
2275                 */
2276                if (!scsi_status_is_good(res))
2277                        res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL);
2278
2279                /*
2280                 * Third attempt: ask 255 bytes, as we did earlier.
2281                 */
2282                if (!scsi_status_is_good(res))
2283                        res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255,
2284                                               &data, NULL);
2285        }
2286
2287        if (!scsi_status_is_good(res)) {
2288                sd_printk(KERN_WARNING, sdkp,
2289                          "Test WP failed, assume Write Enabled\n");
2290        } else {
2291                sdkp->write_prot = ((data.device_specific & 0x80) != 0);
2292                set_disk_ro(sdkp->disk, sdkp->write_prot);
2293                if (sdkp->first_scan || old_wp != sdkp->write_prot) {
2294                        sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
2295                                  sdkp->write_prot ? "on" : "off");
2296                        sd_printk(KERN_DEBUG, sdkp,
2297                                  "Mode Sense: %02x %02x %02x %02x\n",
2298                                  buffer[0], buffer[1], buffer[2], buffer[3]);
2299                }
2300        }
2301}
2302
2303/*
2304 * sd_read_cache_type - called only from sd_revalidate_disk()
2305 * called with buffer of length SD_BUF_SIZE
2306 */
2307static void
2308sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
2309{
2310        int len = 0, res;
2311        struct scsi_device *sdp = sdkp->device;
2312
2313        int dbd;
2314        int modepage;
2315        int first_len;
2316        struct scsi_mode_data data;
2317        struct scsi_sense_hdr sshdr;
2318        int old_wce = sdkp->WCE;
2319        int old_rcd = sdkp->RCD;
2320        int old_dpofua = sdkp->DPOFUA;
2321
2322        first_len = 4;
2323        if (sdp->skip_ms_page_8) {
2324                if (sdp->type == TYPE_RBC)
2325                        goto defaults;
2326                else {
2327                        if (sdp->skip_ms_page_3f)
2328                                goto defaults;
2329                        modepage = 0x3F;
2330                        if (sdp->use_192_bytes_for_3f)
2331                                first_len = 192;
2332                        dbd = 0;
2333                }
2334        } else if (sdp->type == TYPE_RBC) {
2335                modepage = 6;
2336                dbd = 8;
2337        } else {
2338                modepage = 8;
2339                dbd = 0;
2340        }
2341
2342        /* cautiously ask */
2343        res = sd_do_mode_sense(sdp, dbd, modepage, buffer, first_len,
2344                        &data, &sshdr);
2345
2346        if (!scsi_status_is_good(res))
2347                goto bad_sense;
2348
2349        if (!data.header_length) {
2350                modepage = 6;
2351                first_len = 0;
2352                sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
2353        }
2354
2355        /* that went OK, now ask for the proper length */
2356        len = data.length;
2357
2358        /*
2359         * We're only interested in the first three bytes, actually.
2360         * But the data cache page is defined for the first 20.
2361         */
2362        if (len < 3)
2363                goto bad_sense;
2364        else if (len > SD_BUF_SIZE) {
2365                sd_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
2366                          "data from %d to %d bytes\n", len, SD_BUF_SIZE);
2367                len = SD_BUF_SIZE;
2368        }
2369        if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
2370                len = 192;
2371
2372        /* Get the data */
2373        if (len > first_len)
2374                res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len,
2375                                &data, &sshdr);
2376
2377        if (scsi_status_is_good(res)) {
2378                int offset = data.header_length + data.block_descriptor_length;
2379
2380                while (offset < len) {
2381                        u8 page_code = buffer[offset] & 0x3F;
2382                        u8 spf       = buffer[offset] & 0x40;
2383
2384                        if (page_code == 8 || page_code == 6) {
2385                                /* We're interested only in the first 3 bytes.
2386                                 */
2387                                if (len - offset <= 2) {
2388                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
2389                                                  "mode parameter data\n");
2390                                        goto defaults;
2391                                } else {
2392                                        modepage = page_code;
2393                                        goto Page_found;
2394                                }
2395                        } else {
2396                                /* Go to the next page */
2397                                if (spf && len - offset > 3)
2398                                        offset += 4 + (buffer[offset+2] << 8) +
2399                                                buffer[offset+3];
2400                                else if (!spf && len - offset > 1)
2401                                        offset += 2 + buffer[offset+1];
2402                                else {
2403                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
2404                                                  "mode parameter data\n");
2405                                        goto defaults;
2406                                }
2407                        }
2408                }
2409
2410                if (modepage == 0x3F) {
2411                        sd_printk(KERN_ERR, sdkp, "No Caching mode page "
2412                                  "present\n");
2413                        goto defaults;
2414                } else if ((buffer[offset] & 0x3f) != modepage) {
2415                        sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
2416                        goto defaults;
2417                }
2418        Page_found:
2419                if (modepage == 8) {
2420                        sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
2421                        sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
2422                } else {
2423                        sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
2424                        sdkp->RCD = 0;
2425                }
2426
2427                sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
2428                if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
2429                        sd_printk(KERN_NOTICE, sdkp,
2430                                  "Uses READ/WRITE(6), disabling FUA\n");
2431                        sdkp->DPOFUA = 0;
2432                }
2433
2434                if (sdkp->first_scan || old_wce != sdkp->WCE ||
2435                    old_rcd != sdkp->RCD || old_dpofua != sdkp->DPOFUA)
2436                        sd_printk(KERN_NOTICE, sdkp,
2437                                  "Write cache: %s, read cache: %s, %s\n",
2438                                  sdkp->WCE ? "enabled" : "disabled",
2439                                  sdkp->RCD ? "disabled" : "enabled",
2440                                  sdkp->DPOFUA ? "supports DPO and FUA"
2441                                  : "doesn't support DPO or FUA");
2442
2443                return;
2444        }
2445
2446bad_sense:
2447        if (scsi_sense_valid(&sshdr) &&
2448            sshdr.sense_key == ILLEGAL_REQUEST &&
2449            sshdr.asc == 0x24 && sshdr.ascq == 0x0)
2450                /* Invalid field in CDB */
2451                sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
2452        else
2453                sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
2454
2455defaults:
2456        if (sdp->wce_default_on) {
2457                sd_printk(KERN_NOTICE, sdkp, "Assuming drive cache: write back\n");
2458                sdkp->WCE = 1;
2459        } else {
2460                sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
2461                sdkp->WCE = 0;
2462        }
2463        sdkp->RCD = 0;
2464        sdkp->DPOFUA = 0;
2465}
2466
2467/*
2468 * The ATO bit indicates whether the DIF application tag is available
2469 * for use by the operating system.
2470 */
2471static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
2472{
2473        int res, offset;
2474        struct scsi_device *sdp = sdkp->device;
2475        struct scsi_mode_data data;
2476        struct scsi_sense_hdr sshdr;
2477
2478        if (sdp->type != TYPE_DISK)
2479                return;
2480
2481        if (sdkp->protection_type == 0)
2482                return;
2483
2484        res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT,
2485                              SD_MAX_RETRIES, &data, &sshdr);
2486
2487        if (!scsi_status_is_good(res) || !data.header_length ||
2488            data.length < 6) {
2489                sd_printk(KERN_WARNING, sdkp,
2490                          "getting Control mode page failed, assume no ATO\n");
2491
2492                if (scsi_sense_valid(&sshdr))
2493                        sd_print_sense_hdr(sdkp, &sshdr);
2494
2495                return;
2496        }
2497
2498        offset = data.header_length + data.block_descriptor_length;
2499
2500        if ((buffer[offset] & 0x3f) != 0x0a) {
2501                sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
2502                return;
2503        }
2504
2505        if ((buffer[offset + 5] & 0x80) == 0)
2506                return;
2507
2508        sdkp->ATO = 1;
2509
2510        return;
2511}
2512
2513/**
2514 * sd_read_block_limits - Query disk device for preferred I/O sizes.
2515 * @disk: disk to query
2516 */
2517static void sd_read_block_limits(struct scsi_disk *sdkp)
2518{
2519        unsigned int sector_sz = sdkp->device->sector_size;
2520        const int vpd_len = 64;
2521        unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
2522
2523        if (!buffer ||
2524            /* Block Limits VPD */
2525            scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
2526                goto out;
2527
2528        blk_queue_io_min(sdkp->disk->queue,
2529                         get_unaligned_be16(&buffer[6]) * sector_sz);
2530        blk_queue_io_opt(sdkp->disk->queue,
2531                         get_unaligned_be32(&buffer[12]) * sector_sz);
2532
2533        if (buffer[3] == 0x3c) {
2534                unsigned int lba_count, desc_count;
2535
2536                sdkp->max_ws_blocks = (u32)get_unaligned_be64(&buffer[36]);
2537
2538                if (!sdkp->lbpme)
2539                        goto out;
2540
2541                lba_count = get_unaligned_be32(&buffer[20]);
2542                desc_count = get_unaligned_be32(&buffer[24]);
2543
2544                if (lba_count && desc_count)
2545                        sdkp->max_unmap_blocks = lba_count;
2546
2547                sdkp->unmap_granularity = get_unaligned_be32(&buffer[28]);
2548
2549                if (buffer[32] & 0x80)
2550                        sdkp->unmap_alignment =
2551                                get_unaligned_be32(&buffer[32]) & ~(1 << 31);
2552
2553                if (!sdkp->lbpvpd) { /* LBP VPD page not provided */
2554
2555                        if (sdkp->max_unmap_blocks)
2556                                sd_config_discard(sdkp, SD_LBP_UNMAP);
2557                        else
2558                                sd_config_discard(sdkp, SD_LBP_WS16);
2559
2560                } else {        /* LBP VPD page tells us what to use */
2561
2562                        if (sdkp->lbpu && sdkp->max_unmap_blocks)
2563                                sd_config_discard(sdkp, SD_LBP_UNMAP);
2564                        else if (sdkp->lbpws)
2565                                sd_config_discard(sdkp, SD_LBP_WS16);
2566                        else if (sdkp->lbpws10)
2567                                sd_config_discard(sdkp, SD_LBP_WS10);
2568                        else
2569                                sd_config_discard(sdkp, SD_LBP_DISABLE);
2570                }
2571        }
2572
2573 out:
2574        kfree(buffer);
2575}
2576
2577/**
2578 * sd_read_block_characteristics - Query block dev. characteristics
2579 * @disk: disk to query
2580 */
2581static void sd_read_block_characteristics(struct scsi_disk *sdkp)
2582{
2583        unsigned char *buffer;
2584        u16 rot;
2585        const int vpd_len = 64;
2586
2587        buffer = kmalloc(vpd_len, GFP_KERNEL);
2588
2589        if (!buffer ||
2590            /* Block Device Characteristics VPD */
2591            scsi_get_vpd_page(sdkp->device, 0xb1, buffer, vpd_len))
2592                goto out;
2593
2594        rot = get_unaligned_be16(&buffer[4]);
2595
2596        if (rot == 1)
2597                queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue);
2598
2599 out:
2600        kfree(buffer);
2601}
2602
2603/**
2604 * sd_read_block_provisioning - Query provisioning VPD page
2605 * @disk: disk to query
2606 */
2607static void sd_read_block_provisioning(struct scsi_disk *sdkp)
2608{
2609        unsigned char *buffer;
2610        const int vpd_len = 8;
2611
2612        if (sdkp->lbpme == 0)
2613                return;
2614
2615        buffer = kmalloc(vpd_len, GFP_KERNEL);
2616
2617        if (!buffer || scsi_get_vpd_page(sdkp->device, 0xb2, buffer, vpd_len))
2618                goto out;
2619
2620        sdkp->lbpvpd    = 1;
2621        sdkp->lbpu      = (buffer[5] >> 7) & 1; /* UNMAP */
2622        sdkp->lbpws     = (buffer[5] >> 6) & 1; /* WRITE SAME(16) with UNMAP */
2623        sdkp->lbpws10   = (buffer[5] >> 5) & 1; /* WRITE SAME(10) with UNMAP */
2624
2625 out:
2626        kfree(buffer);
2627}
2628
2629static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
2630{
2631        if (scsi_report_opcode(sdkp->device, buffer, SD_BUF_SIZE,
2632                               WRITE_SAME_16))
2633                sdkp->ws16 = 1;
2634}
2635
2636static int sd_try_extended_inquiry(struct scsi_device *sdp)
2637{
2638        /*
2639         * Although VPD inquiries can go to SCSI-2 type devices,
2640         * some USB ones crash on receiving them, and the pages
2641         * we currently ask for are for SPC-3 and beyond
2642         */
2643        if (sdp->scsi_level > SCSI_SPC_2 && !sdp->skip_vpd_pages)
2644                return 1;
2645        return 0;
2646}
2647
2648/**
2649 *      sd_revalidate_disk - called the first time a new disk is seen,
2650 *      performs disk spin up, read_capacity, etc.
2651 *      @disk: struct gendisk we care about
2652 **/
2653static int sd_revalidate_disk(struct gendisk *disk)
2654{
2655        struct scsi_disk *sdkp = scsi_disk(disk);
2656        struct scsi_device *sdp = sdkp->device;
2657        unsigned char *buffer;
2658        unsigned flush = 0;
2659
2660        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
2661                                      "sd_revalidate_disk\n"));
2662
2663        /*
2664         * If the device is offline, don't try and read capacity or any
2665         * of the other niceties.
2666         */
2667        if (!scsi_device_online(sdp))
2668                goto out;
2669
2670        buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
2671        if (!buffer) {
2672                sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
2673                          "allocation failure.\n");
2674                goto out;
2675        }
2676
2677        sd_spinup_disk(sdkp);
2678
2679        /*
2680         * Without media there is no reason to ask; moreover, some devices
2681         * react badly if we do.
2682         */
2683        if (sdkp->media_present) {
2684                sd_read_capacity(sdkp, buffer);
2685
2686                if (sd_try_extended_inquiry(sdp)) {
2687                        sd_read_block_provisioning(sdkp);
2688                        sd_read_block_limits(sdkp);
2689                        sd_read_block_characteristics(sdkp);
2690                }
2691
2692                sd_read_write_protect_flag(sdkp, buffer);
2693                sd_read_cache_type(sdkp, buffer);
2694                sd_read_app_tag_own(sdkp, buffer);
2695                sd_read_write_same(sdkp, buffer);
2696        }
2697
2698        sdkp->first_scan = 0;
2699
2700        /*
2701         * We now have all cache related info, determine how we deal
2702         * with flush requests.
2703         */
2704        if (sdkp->WCE) {
2705                flush |= REQ_FLUSH;
2706                if (sdkp->DPOFUA)
2707                        flush |= REQ_FUA;
2708        }
2709
2710        blk_queue_flush(sdkp->disk->queue, flush);
2711
2712        set_capacity(disk, sdkp->capacity);
2713        sd_config_write_same(sdkp);
2714        kfree(buffer);
2715
2716 out:
2717        return 0;
2718}
2719
2720/**
2721 *      sd_unlock_native_capacity - unlock native capacity
2722 *      @disk: struct gendisk to set capacity for
2723 *
2724 *      Block layer calls this function if it detects that partitions
2725 *      on @disk reach beyond the end of the device.  If the SCSI host
2726 *      implements ->unlock_native_capacity() method, it's invoked to
2727 *      give it a chance to adjust the device capacity.
2728 *
2729 *      CONTEXT:
2730 *      Defined by block layer.  Might sleep.
2731 */
2732static void sd_unlock_native_capacity(struct gendisk *disk)
2733{
2734        struct scsi_device *sdev = scsi_disk(disk)->device;
2735
2736        if (sdev->host->hostt->unlock_native_capacity)
2737                sdev->host->hostt->unlock_native_capacity(sdev);
2738}
2739
2740/**
2741 *      sd_format_disk_name - format disk name
2742 *      @prefix: name prefix - ie. "sd" for SCSI disks
2743 *      @index: index of the disk to format name for
2744 *      @buf: output buffer
2745 *      @buflen: length of the output buffer
2746 *
2747 *      SCSI disk names starts at sda.  The 26th device is sdz and the
2748 *      27th is sdaa.  The last one for two lettered suffix is sdzz
2749 *      which is followed by sdaaa.
2750 *
2751 *      This is basically 26 base counting with one extra 'nil' entry
2752 *      at the beginning from the second digit on and can be
2753 *      determined using similar method as 26 base conversion with the
2754 *      index shifted -1 after each digit is computed.
2755 *
2756 *      CONTEXT:
2757 *      Don't care.
2758 *
2759 *      RETURNS:
2760 *      0 on success, -errno on failure.
2761 */
2762static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen)
2763{
2764        const int base = 'z' - 'a' + 1;
2765        char *begin = buf + strlen(prefix);
2766        char *end = buf + buflen;
2767        char *p;
2768        int unit;
2769
2770        p = end - 1;
2771        *p = '\0';
2772        unit = base;
2773        do {
2774                if (p == begin)
2775                        return -EINVAL;
2776                *--p = 'a' + (index % unit);
2777                index = (index / unit) - 1;
2778        } while (index >= 0);
2779
2780        memmove(begin, p, end - p);
2781        memcpy(buf, prefix, strlen(prefix));
2782
2783        return 0;
2784}
2785
2786/*
2787 * The asynchronous part of sd_probe
2788 */
2789static void sd_probe_async(void *data, async_cookie_t cookie)
2790{
2791        struct scsi_disk *sdkp = data;
2792        struct scsi_device *sdp;
2793        struct gendisk *gd;
2794        u32 index;
2795        struct device *dev;
2796
2797        sdp = sdkp->device;
2798        gd = sdkp->disk;
2799        index = sdkp->index;
2800        dev = &sdp->sdev_gendev;
2801
2802        gd->major = sd_major((index & 0xf0) >> 4);
2803        gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
2804        gd->minors = SD_MINORS;
2805
2806        gd->fops = &sd_fops;
2807        gd->private_data = &sdkp->driver;
2808        gd->queue = sdkp->device->request_queue;
2809
2810        /* defaults, until the device tells us otherwise */
2811        sdp->sector_size = 512;
2812        sdkp->capacity = 0;
2813        sdkp->media_present = 1;
2814        sdkp->write_prot = 0;
2815        sdkp->WCE = 0;
2816        sdkp->RCD = 0;
2817        sdkp->ATO = 0;
2818        sdkp->first_scan = 1;
2819        sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
2820
2821        sd_revalidate_disk(gd);
2822
2823        blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
2824        blk_queue_unprep_rq(sdp->request_queue, sd_unprep_fn);
2825
2826        gd->driverfs_dev = &sdp->sdev_gendev;
2827        gd->flags = GENHD_FL_EXT_DEVT;
2828        if (sdp->removable) {
2829                gd->flags |= GENHD_FL_REMOVABLE;
2830                gd->events |= DISK_EVENT_MEDIA_CHANGE;
2831        }
2832
2833        add_disk(gd);
2834        if (sdkp->capacity)
2835                sd_dif_config_host(sdkp);
2836
2837        sd_revalidate_disk(gd);
2838
2839        sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
2840                  sdp->removable ? "removable " : "");
2841        scsi_autopm_put_device(sdp);
2842        put_device(&sdkp->dev);
2843}
2844
2845/**
2846 *      sd_probe - called during driver initialization and whenever a
2847 *      new scsi device is attached to the system. It is called once
2848 *      for each scsi device (not just disks) present.
2849 *      @dev: pointer to device object
2850 *
2851 *      Returns 0 if successful (or not interested in this scsi device 
2852 *      (e.g. scanner)); 1 when there is an error.
2853 *
2854 *      Note: this function is invoked from the scsi mid-level.
2855 *      This function sets up the mapping between a given 
2856 *      <host,channel,id,lun> (found in sdp) and new device name 
2857 *      (e.g. /dev/sda). More precisely it is the block device major 
2858 *      and minor number that is chosen here.
2859 *
2860 *      Assume sd_probe is not re-entrant (for time being)
2861 *      Also think about sd_probe() and sd_remove() running coincidentally.
2862 **/
2863static int sd_probe(struct device *dev)
2864{
2865        struct scsi_device *sdp = to_scsi_device(dev);
2866        struct scsi_disk *sdkp;
2867        struct gendisk *gd;
2868        int index;
2869        int error;
2870
2871        error = -ENODEV;
2872        if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)
2873                goto out;
2874
2875        SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
2876                                        "sd_probe\n"));
2877
2878        error = -ENOMEM;
2879        sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
2880        if (!sdkp)
2881                goto out;
2882
2883        gd = alloc_disk(SD_MINORS);
2884        if (!gd)
2885                goto out_free;
2886
2887        do {
2888                if (!ida_pre_get(&sd_index_ida, GFP_KERNEL))
2889                        goto out_put;
2890
2891                spin_lock(&sd_index_lock);
2892                error = ida_get_new(&sd_index_ida, &index);
2893                spin_unlock(&sd_index_lock);
2894        } while (error == -EAGAIN);
2895
2896        if (error) {
2897                sdev_printk(KERN_WARNING, sdp, "sd_probe: memory exhausted.\n");
2898                goto out_put;
2899        }
2900
2901        error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
2902        if (error) {
2903                sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name length exceeded.\n");
2904                goto out_free_index;
2905        }
2906
2907        sdkp->device = sdp;
2908        sdkp->driver = &sd_template;
2909        sdkp->disk = gd;
2910        sdkp->index = index;
2911        atomic_set(&sdkp->openers, 0);
2912        atomic_set(&sdkp->device->ioerr_cnt, 0);
2913
2914        if (!sdp->request_queue->rq_timeout) {
2915                if (sdp->type != TYPE_MOD)
2916                        blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
2917                else
2918                        blk_queue_rq_timeout(sdp->request_queue,
2919                                             SD_MOD_TIMEOUT);
2920        }
2921
2922        device_initialize(&sdkp->dev);
2923        sdkp->dev.parent = dev;
2924        sdkp->dev.class = &sd_disk_class;
2925        dev_set_name(&sdkp->dev, dev_name(dev));
2926
2927        if (device_add(&sdkp->dev))
2928                goto out_free_index;
2929
2930        get_device(dev);
2931        dev_set_drvdata(dev, sdkp);
2932
2933        get_device(&sdkp->dev); /* prevent release before async_schedule */
2934        async_schedule_domain(sd_probe_async, sdkp, &scsi_sd_probe_domain);
2935
2936        return 0;
2937
2938 out_free_index:
2939        spin_lock(&sd_index_lock);
2940        ida_remove(&sd_index_ida, index);
2941        spin_unlock(&sd_index_lock);
2942 out_put:
2943        put_disk(gd);
2944 out_free:
2945        kfree(sdkp);
2946 out:
2947        return error;
2948}
2949
2950/**
2951 *      sd_remove - called whenever a scsi disk (previously recognized by
2952 *      sd_probe) is detached from the system. It is called (potentially
2953 *      multiple times) during sd module unload.
2954 *      @sdp: pointer to mid level scsi device object
2955 *
2956 *      Note: this function is invoked from the scsi mid-level.
2957 *      This function potentially frees up a device name (e.g. /dev/sdc)
2958 *      that could be re-used by a subsequent sd_probe().
2959 *      This function is not called when the built-in sd driver is "exit-ed".
2960 **/
2961static int sd_remove(struct device *dev)
2962{
2963        struct scsi_disk *sdkp;
2964
2965        sdkp = dev_get_drvdata(dev);
2966        scsi_autopm_get_device(sdkp->device);
2967
2968        async_synchronize_full_domain(&scsi_sd_probe_domain);
2969        blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
2970        blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
2971        device_del(&sdkp->dev);
2972        del_gendisk(sdkp->disk);
2973        sd_shutdown(dev);
2974
2975        mutex_lock(&sd_ref_mutex);
2976        dev_set_drvdata(dev, NULL);
2977        put_device(&sdkp->dev);
2978        mutex_unlock(&sd_ref_mutex);
2979
2980        return 0;
2981}
2982
2983/**
2984 *      scsi_disk_release - Called to free the scsi_disk structure
2985 *      @dev: pointer to embedded class device
2986 *
2987 *      sd_ref_mutex must be held entering this routine.  Because it is
2988 *      called on last put, you should always use the scsi_disk_get()
2989 *      scsi_disk_put() helpers which manipulate the semaphore directly
2990 *      and never do a direct put_device.
2991 **/
2992static void scsi_disk_release(struct device *dev)
2993{
2994        struct scsi_disk *sdkp = to_scsi_disk(dev);
2995        struct gendisk *disk = sdkp->disk;
2996        
2997        spin_lock(&sd_index_lock);
2998        ida_remove(&sd_index_ida, sdkp->index);
2999        spin_unlock(&sd_index_lock);
3000
3001        disk->private_data = NULL;
3002        put_disk(disk);
3003        put_device(&sdkp->device->sdev_gendev);
3004
3005        kfree(sdkp);
3006}
3007
3008static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
3009{
3010        unsigned char cmd[6] = { START_STOP };  /* START_VALID */
3011        struct scsi_sense_hdr sshdr;
3012        struct scsi_device *sdp = sdkp->device;
3013        int res;
3014
3015        if (start)
3016                cmd[4] |= 1;    /* START */
3017
3018        if (sdp->start_stop_pwr_cond)
3019                cmd[4] |= start ? 1 << 4 : 3 << 4;      /* Active or Standby */
3020
3021        if (!scsi_device_online(sdp))
3022                return -ENODEV;
3023
3024        res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
3025                               SD_TIMEOUT, SD_MAX_RETRIES, NULL);
3026        if (res) {
3027                sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
3028                sd_print_result(sdkp, res);
3029                if (driver_byte(res) & DRIVER_SENSE)
3030                        sd_print_sense_hdr(sdkp, &sshdr);
3031        }
3032
3033        return res;
3034}
3035
3036/*
3037 * Send a SYNCHRONIZE CACHE instruction down to the device through
3038 * the normal SCSI command structure.  Wait for the command to
3039 * complete.
3040 */
3041static void sd_shutdown(struct device *dev)
3042{
3043        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3044
3045        if (!sdkp)
3046                return;         /* this can happen */
3047
3048        if (pm_runtime_suspended(dev))
3049                goto exit;
3050
3051        if (sdkp->WCE) {
3052                sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
3053                sd_sync_cache(sdkp);
3054        }
3055
3056        if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
3057                sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
3058                sd_start_stop_device(sdkp, 0);
3059        }
3060
3061exit:
3062        scsi_disk_put(sdkp);
3063}
3064
3065static int sd_suspend(struct device *dev)
3066{
3067        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3068        int ret = 0;
3069
3070        if (!sdkp)
3071                return 0;       /* this can happen */
3072
3073        if (sdkp->WCE) {
3074                sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
3075                ret = sd_sync_cache(sdkp);
3076                if (ret)
3077                        goto done;
3078        }
3079
3080        if (sdkp->device->manage_start_stop) {
3081                sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
3082                ret = sd_start_stop_device(sdkp, 0);
3083        }
3084
3085done:
3086        scsi_disk_put(sdkp);
3087        return ret;
3088}
3089
3090static int sd_resume(struct device *dev)
3091{
3092        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3093        int ret = 0;
3094
3095        if (!sdkp->device->manage_start_stop)
3096                goto done;
3097
3098        sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
3099        ret = sd_start_stop_device(sdkp, 1);
3100
3101done:
3102        scsi_disk_put(sdkp);
3103        return ret;
3104}
3105
3106/**
3107 *      init_sd - entry point for this driver (both when built in or when
3108 *      a module).
3109 *
3110 *      Note: this function registers this driver with the scsi mid-level.
3111 **/
3112static int __init init_sd(void)
3113{
3114        int majors = 0, i, err;
3115
3116        SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
3117
3118        for (i = 0; i < SD_MAJORS; i++)
3119                if (register_blkdev(sd_major(i), "sd") == 0)
3120                        majors++;
3121
3122        if (!majors)
3123                return -ENODEV;
3124
3125        err = class_register(&sd_disk_class);
3126        if (err)
3127                goto err_out;
3128
3129        sd_cdb_cache = kmem_cache_create("sd_ext_cdb", SD_EXT_CDB_SIZE,
3130                                         0, 0, NULL);
3131        if (!sd_cdb_cache) {
3132                printk(KERN_ERR "sd: can't init extended cdb cache\n");
3133                goto err_out_class;
3134        }
3135
3136        sd_cdb_pool = mempool_create_slab_pool(SD_MEMPOOL_SIZE, sd_cdb_cache);
3137        if (!sd_cdb_pool) {
3138                printk(KERN_ERR "sd: can't init extended cdb pool\n");
3139                goto err_out_cache;
3140        }
3141
3142        err = scsi_register_driver(&sd_template.gendrv);
3143        if (err)
3144                goto err_out_driver;
3145
3146        return 0;
3147
3148err_out_driver:
3149        mempool_destroy(sd_cdb_pool);
3150
3151err_out_cache:
3152        kmem_cache_destroy(sd_cdb_cache);
3153
3154err_out_class:
3155        class_unregister(&sd_disk_class);
3156err_out:
3157        for (i = 0; i < SD_MAJORS; i++)
3158                unregister_blkdev(sd_major(i), "sd");
3159        return err;
3160}
3161
3162/**
3163 *      exit_sd - exit point for this driver (when it is a module).
3164 *
3165 *      Note: this function unregisters this driver from the scsi mid-level.
3166 **/
3167static void __exit exit_sd(void)
3168{
3169        int i;
3170
3171        SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
3172
3173        scsi_unregister_driver(&sd_template.gendrv);
3174        mempool_destroy(sd_cdb_pool);
3175        kmem_cache_destroy(sd_cdb_cache);
3176
3177        class_unregister(&sd_disk_class);
3178
3179        for (i = 0; i < SD_MAJORS; i++)
3180                unregister_blkdev(sd_major(i), "sd");
3181}
3182
3183module_init(init_sd);
3184module_exit(exit_sd);
3185
3186static void sd_print_sense_hdr(struct scsi_disk *sdkp,
3187                               struct scsi_sense_hdr *sshdr)
3188{
3189        sd_printk(KERN_INFO, sdkp, " ");
3190        scsi_show_sense_hdr(sshdr);
3191        sd_printk(KERN_INFO, sdkp, " ");
3192        scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
3193}
3194
3195static void sd_print_result(struct scsi_disk *sdkp, int result)
3196{
3197        sd_printk(KERN_INFO, sdkp, " ");
3198        scsi_show_result(result);
3199}
3200
3201
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.