drivers/scsi/sd.c

   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 <asm/uaccess.h>
  51
  52 #include <scsi/scsi.h>
  53 #include <scsi/scsi_cmnd.h>
  54 #include <scsi/scsi_dbg.h>
  55 #include <scsi/scsi_device.h>
  56 #include <scsi/scsi_driver.h>
  57 #include <scsi/scsi_eh.h>
  58 #include <scsi/scsi_host.h>
  59 #include <scsi/scsi_ioctl.h>
  60 #include <scsi/scsicam.h>
  61 #include <scsi/sd.h>
  62
  63 #include "scsi_logging.h"
  64
  65 MODULE_AUTHOR("Eric Youngdale");
  66 MODULE_DESCRIPTION("SCSI disk (sd) driver");
  67 MODULE_LICENSE("GPL");
  68
  69 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
  70 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
  71 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
  72 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
  73 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
  74 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
  75 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
  76 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
  77 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
  78 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
  79 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
  80 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
  81 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
  82 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
  83 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
  84 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
  85 MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
  86 MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
  87 MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
  88
  89 static int  sd_revalidate_disk(struct gendisk *);
  90 static int  sd_probe(struct device *);
  91 static int  sd_remove(struct device *);
  92 static void sd_shutdown(struct device *);
  93 static int sd_suspend(struct device *, pm_message_t state);
  94 static int sd_resume(struct device *);
  95 static void sd_rescan(struct device *);
  96 static int sd_done(struct scsi_cmnd *);
  97 static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
  98 static void scsi_disk_release(struct device *cdev);
  99 static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
 100 static void sd_print_result(struct scsi_disk *, int);
 101
 102 static DEFINE_IDR(sd_index_idr);
 103 static DEFINE_SPINLOCK(sd_index_lock);
 104
 105 /* This semaphore is used to mediate the 0->1 reference get in the
 106  * face of object destruction (i.e. we can't allow a get on an
 107  * object after last put) */
 108 static DEFINE_MUTEX(sd_ref_mutex);
 109
 110 static const char *sd_cache_types[] = {
 111         "write through", "none", "write back",
 112         "write back, no read (daft)"
 113 };
 114
 115 static ssize_t
 116 sd_store_cache_type(struct device *dev, struct device_attribute *attr,
 117                     const char *buf, size_t count)
 118 {
 119         int i, ct = -1, rcd, wce, sp;
 120         struct scsi_disk *sdkp = to_scsi_disk(dev);
 121         struct scsi_device *sdp = sdkp->device;
 122         char buffer[64];
 123         char *buffer_data;
 124         struct scsi_mode_data data;
 125         struct scsi_sense_hdr sshdr;
 126         int len;
 127
 128         if (sdp->type != TYPE_DISK)
 129                 /* no cache control on RBC devices; theoretically they
 130                  * can do it, but there's probably so many exceptions
 131                  * it's not worth the risk */
 132                 return -EINVAL;
 133
 134         for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
 135                 const int len = strlen(sd_cache_types[i]);
 136                 if (strncmp(sd_cache_types[i], buf, len) == 0 &&
 137                     buf[len] == '\n') {
 138                         ct = i;
 139                         break;
 140                 }
 141         }
 142         if (ct < 0)
 143                 return -EINVAL;
 144         rcd = ct & 0x01 ? 1 : 0;
 145         wce = ct & 0x02 ? 1 : 0;
 146         if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
 147                             SD_MAX_RETRIES, &data, NULL))
 148                 return -EINVAL;
 149         len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
 150                   data.block_descriptor_length);
 151         buffer_data = buffer + data.header_length +
 152                 data.block_descriptor_length;
 153         buffer_data[2] &= ~0x05;
 154         buffer_data[2] |= wce << 2 | rcd;
 155         sp = buffer_data[0] & 0x80 ? 1 : 0;
 156
 157         if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
 158                              SD_MAX_RETRIES, &data, &sshdr)) {
 159                 if (scsi_sense_valid(&sshdr))
 160                         sd_print_sense_hdr(sdkp, &sshdr);
 161                 return -EINVAL;
 162         }
 163         sd_revalidate_disk(sdkp->disk);
 164         return count;
 165 }
 166
 167 static ssize_t
 168 sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
 169                            const char *buf, size_t count)
 170 {
 171         struct scsi_disk *sdkp = to_scsi_disk(dev);
 172         struct scsi_device *sdp = sdkp->device;
 173
 174         if (!capable(CAP_SYS_ADMIN))
 175                 return -EACCES;
 176
 177         sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
 178
 179         return count;
 180 }
 181
 182 static ssize_t
 183 sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
 184                        const char *buf, size_t count)
 185 {
 186         struct scsi_disk *sdkp = to_scsi_disk(dev);
 187         struct scsi_device *sdp = sdkp->device;
 188
 189         if (!capable(CAP_SYS_ADMIN))
 190                 return -EACCES;
 191
 192         if (sdp->type != TYPE_DISK)
 193                 return -EINVAL;
 194
 195         sdp->allow_restart = simple_strtoul(buf, NULL, 10);
 196
 197         return count;
 198 }
 199
 200 static ssize_t
 201 sd_show_cache_type(struct device *dev, struct device_attribute *attr,
 202                    char *buf)
 203 {
 204         struct scsi_disk *sdkp = to_scsi_disk(dev);
 205         int ct = sdkp->RCD + 2*sdkp->WCE;
 206
 207         return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
 208 }
 209
 210 static ssize_t
 211 sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
 212 {
 213         struct scsi_disk *sdkp = to_scsi_disk(dev);
 214
 215         return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
 216 }
 217
 218 static ssize_t
 219 sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
 220                           char *buf)
 221 {
 222         struct scsi_disk *sdkp = to_scsi_disk(dev);
 223         struct scsi_device *sdp = sdkp->device;
 224
 225         return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
 226 }
 227
 228 static ssize_t
 229 sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
 230                       char *buf)
 231 {
 232         struct scsi_disk *sdkp = to_scsi_disk(dev);
 233
 234         return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
 235 }
 236
 237 static struct device_attribute sd_disk_attrs[] = {
 238         __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
 239                sd_store_cache_type),
 240         __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
 241         __ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
 242                sd_store_allow_restart),
 243         __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
 244                sd_store_manage_start_stop),
 245         __ATTR_NULL,
 246 };
 247
 248 static struct class sd_disk_class = {
 249         .name           = "scsi_disk",
 250         .owner          = THIS_MODULE,
 251         .dev_release    = scsi_disk_release,
 252         .dev_attrs      = sd_disk_attrs,
 253 };
 254
 255 static struct scsi_driver sd_template = {
 256         .owner                  = THIS_MODULE,
 257         .gendrv = {
 258                 .name           = "sd",
 259                 .probe          = sd_probe,
 260                 .remove         = sd_remove,
 261                 .suspend        = sd_suspend,
 262                 .resume         = sd_resume,
 263                 .shutdown       = sd_shutdown,
 264         },
 265         .rescan                 = sd_rescan,
 266         .done                   = sd_done,
 267 };
 268
 269 /*
 270  * Device no to disk mapping:
 271  *
 272  *       major         disc2     disc  p1
 273  *   |............|.............|....|....| <- dev_t
 274  *    31        20 19          8 7  4 3  0
 275  *
 276  * Inside a major, we have 16k disks, however mapped non-
 277  * contiguously. The first 16 disks are for major0, the next
 278  * ones with major1, ... Disk 256 is for major0 again, disk 272
 279  * for major1, ...
 280  * As we stay compatible with our numbering scheme, we can reuse
 281  * the well-know SCSI majors 8, 65--71, 136--143.
 282  */
 283 static int sd_major(int major_idx)
 284 {
 285         switch (major_idx) {
 286         case 0:
 287                 return SCSI_DISK0_MAJOR;
 288         case 1 ... 7:
 289                 return SCSI_DISK1_MAJOR + major_idx - 1;
 290         case 8 ... 15:
 291                 return SCSI_DISK8_MAJOR + major_idx - 8;
 292         default:
 293                 BUG();
 294                 return 0;       /* shut up gcc */
 295         }
 296 }
 297
 298 static inline struct scsi_disk *scsi_disk(struct gendisk *disk)
 299 {
 300         return container_of(disk->private_data, struct scsi_disk, driver);
 301 }
 302
 303 static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
 304 {
 305         struct scsi_disk *sdkp = NULL;
 306
 307         if (disk->private_data) {
 308                 sdkp = scsi_disk(disk);
 309                 if (scsi_device_get(sdkp->device) == 0)
 310                         get_device(&sdkp->dev);
 311                 else
 312                         sdkp = NULL;
 313         }
 314         return sdkp;
 315 }
 316
 317 static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
 318 {
 319         struct scsi_disk *sdkp;
 320
 321         mutex_lock(&sd_ref_mutex);
 322         sdkp = __scsi_disk_get(disk);
 323         mutex_unlock(&sd_ref_mutex);
 324         return sdkp;
 325 }
 326
 327 static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
 328 {
 329         struct scsi_disk *sdkp;
 330
 331         mutex_lock(&sd_ref_mutex);
 332         sdkp = dev_get_drvdata(dev);
 333         if (sdkp)
 334                 sdkp = __scsi_disk_get(sdkp->disk);
 335         mutex_unlock(&sd_ref_mutex);
 336         return sdkp;
 337 }
 338
 339 static void scsi_disk_put(struct scsi_disk *sdkp)
 340 {
 341         struct scsi_device *sdev = sdkp->device;
 342
 343         mutex_lock(&sd_ref_mutex);
 344         put_device(&sdkp->dev);
 345         scsi_device_put(sdev);
 346         mutex_unlock(&sd_ref_mutex);
 347 }
 348
 349 /**
 350  *      sd_init_command - build a scsi (read or write) command from
 351  *      information in the request structure.
 352  *      @SCpnt: pointer to mid-level's per scsi command structure that
 353  *      contains request and into which the scsi command is written
 354  *
 355  *      Returns 1 if successful and 0 if error (or cannot be done now).
 356  **/
 357 static int sd_prep_fn(struct request_queue *q, struct request *rq)
 358 {
 359         struct scsi_cmnd *SCpnt;
 360         struct scsi_device *sdp = q->queuedata;
 361         struct gendisk *disk = rq->rq_disk;
 362         sector_t block = rq->sector;
 363         unsigned int this_count = rq->nr_sectors;
 364         unsigned int timeout = sdp->timeout;
 365         int ret;
 366
 367         if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
 368                 ret = scsi_setup_blk_pc_cmnd(sdp, rq);
 369                 goto out;
 370         } else if (rq->cmd_type != REQ_TYPE_FS) {
 371                 ret = BLKPREP_KILL;
 372                 goto out;
 373         }
 374         ret = scsi_setup_fs_cmnd(sdp, rq);
 375         if (ret != BLKPREP_OK)
 376                 goto out;
 377         SCpnt = rq->special;
 378
 379         /* from here on until we're complete, any goto out
 380          * is used for a killable error condition */
 381         ret = BLKPREP_KILL;
 382
 383         SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
 384                                         "sd_init_command: block=%llu, "
 385                                         "count=%d\n",
 386                                         (unsigned long long)block,
 387                                         this_count));
 388
 389         if (!sdp || !scsi_device_online(sdp) ||
 390             block + rq->nr_sectors > get_capacity(disk)) {
 391                 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 392                                                 "Finishing %ld sectors\n",
 393                                                 rq->nr_sectors));
 394                 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 395                                                 "Retry with 0x%p\n", SCpnt));
 396                 goto out;
 397         }
 398
 399         if (sdp->changed) {
 400                 /*
 401                  * quietly refuse to do anything to a changed disc until
 402                  * the changed bit has been reset
 403                  */
 404                 /* printk("SCSI disk has been changed. Prohibiting further I/O.\n"); */
 405                 goto out;
 406         }
 407
 408         /*
 409          * Some devices (some sdcards for one) don't like it if the
 410          * last sector gets read in a larger then 1 sector read.
 411          */
 412         if (unlikely(sdp->last_sector_bug &&
 413             rq->nr_sectors > sdp->sector_size / 512 &&
 414             block + this_count == get_capacity(disk)))
 415                 this_count -= sdp->sector_size / 512;
 416
 417         SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
 418                                         (unsigned long long)block));
 419
 420         /*
 421          * If we have a 1K hardware sectorsize, prevent access to single
 422          * 512 byte sectors.  In theory we could handle this - in fact
 423          * the scsi cdrom driver must be able to handle this because
 424          * we typically use 1K blocksizes, and cdroms typically have
 425          * 2K hardware sectorsizes.  Of course, things are simpler
 426          * with the cdrom, since it is read-only.  For performance
 427          * reasons, the filesystems should be able to handle this
 428          * and not force the scsi disk driver to use bounce buffers
 429          * for this.
 430          */
 431         if (sdp->sector_size == 1024) {
 432                 if ((block & 1) || (rq->nr_sectors & 1)) {
 433                         scmd_printk(KERN_ERR, SCpnt,
 434                                     "Bad block number requested\n");
 435                         goto out;
 436                 } else {
 437                         block = block >> 1;
 438                         this_count = this_count >> 1;
 439                 }
 440         }
 441         if (sdp->sector_size == 2048) {
 442                 if ((block & 3) || (rq->nr_sectors & 3)) {
 443                         scmd_printk(KERN_ERR, SCpnt,
 444                                     "Bad block number requested\n");
 445                         goto out;
 446                 } else {
 447                         block = block >> 2;
 448                         this_count = this_count >> 2;
 449                 }
 450         }
 451         if (sdp->sector_size == 4096) {
 452                 if ((block & 7) || (rq->nr_sectors & 7)) {
 453                         scmd_printk(KERN_ERR, SCpnt,
 454                                     "Bad block number requested\n");
 455                         goto out;
 456                 } else {
 457                         block = block >> 3;
 458                         this_count = this_count >> 3;
 459                 }
 460         }
 461         if (rq_data_dir(rq) == WRITE) {
 462                 if (!sdp->writeable) {
 463                         goto out;
 464                 }
 465                 SCpnt->cmnd[0] = WRITE_6;
 466                 SCpnt->sc_data_direction = DMA_TO_DEVICE;
 467         } else if (rq_data_dir(rq) == READ) {
 468                 SCpnt->cmnd[0] = READ_6;
 469                 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
 470         } else {
 471                 scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
 472                 goto out;
 473         }
 474
 475         SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 476                                         "%s %d/%ld 512 byte blocks.\n",
 477                                         (rq_data_dir(rq) == WRITE) ?
 478                                         "writing" : "reading", this_count,
 479                                         rq->nr_sectors));
 480
 481         SCpnt->cmnd[1] = 0;
 482
 483         if (block > 0xffffffff) {
 484                 SCpnt->cmnd[0] += READ_16 - READ_6;
 485                 SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
 486                 SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
 487                 SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
 488                 SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
 489                 SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
 490                 SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
 491                 SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
 492                 SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
 493                 SCpnt->cmnd[9] = (unsigned char) block & 0xff;
 494                 SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
 495                 SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
 496                 SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
 497                 SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
 498                 SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
 499         } else if ((this_count > 0xff) || (block > 0x1fffff) ||
 500                    SCpnt->device->use_10_for_rw) {
 501                 if (this_count > 0xffff)
 502                         this_count = 0xffff;
 503
 504                 SCpnt->cmnd[0] += READ_10 - READ_6;
 505                 SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
 506                 SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
 507                 SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
 508                 SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
 509                 SCpnt->cmnd[5] = (unsigned char) block & 0xff;
 510                 SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
 511                 SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
 512                 SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
 513         } else {
 514                 if (unlikely(blk_fua_rq(rq))) {
 515                         /*
 516                          * This happens only if this drive failed
 517                          * 10byte rw command with ILLEGAL_REQUEST
 518                          * during operation and thus turned off
 519                          * use_10_for_rw.
 520                          */
 521                         scmd_printk(KERN_ERR, SCpnt,
 522                                     "FUA write on READ/WRITE(6) drive\n");
 523                         goto out;
 524                 }
 525
 526                 SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
 527                 SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
 528                 SCpnt->cmnd[3] = (unsigned char) block & 0xff;
 529                 SCpnt->cmnd[4] = (unsigned char) this_count;
 530                 SCpnt->cmnd[5] = 0;
 531         }
 532         SCpnt->sdb.length = this_count * sdp->sector_size;
 533
 534         /*
 535          * We shouldn't disconnect in the middle of a sector, so with a dumb
 536          * host adapter, it's safe to assume that we can at least transfer
 537          * this many bytes between each connect / disconnect.
 538          */
 539         SCpnt->transfersize = sdp->sector_size;
 540         SCpnt->underflow = this_count << 9;
 541         SCpnt->allowed = SD_MAX_RETRIES;
 542         SCpnt->timeout_per_command = timeout;
 543
 544         /*
 545          * This indicates that the command is ready from our end to be
 546          * queued.
 547          */
 548         ret = BLKPREP_OK;
 549  out:
 550         return scsi_prep_return(q, rq, ret);
 551 }
 552
 553 /**
 554  *      sd_open - open a scsi disk device
 555  *      @inode: only i_rdev member may be used
 556  *      @filp: only f_mode and f_flags may be used
 557  *
 558  *      Returns 0 if successful. Returns a negated errno value in case
 559  *      of error.
 560  *
 561  *      Note: This can be called from a user context (e.g. fsck(1) )
 562  *      or from within the kernel (e.g. as a result of a mount(1) ).
 563  *      In the latter case @inode and @filp carry an abridged amount
 564  *      of information as noted above.
 565  **/
 566 static int sd_open(struct inode *inode, struct file *filp)
 567 {
 568         struct gendisk *disk = inode->i_bdev->bd_disk;
 569         struct scsi_disk *sdkp;
 570         struct scsi_device *sdev;
 571         int retval;
 572
 573         if (!(sdkp = scsi_disk_get(disk)))
 574                 return -ENXIO;
 575
 576
 577         SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
 578
 579         sdev = sdkp->device;
 580
 581         /*
 582          * If the device is in error recovery, wait until it is done.
 583          * If the device is offline, then disallow any access to it.
 584          */
 585         retval = -ENXIO;
 586         if (!scsi_block_when_processing_errors(sdev))
 587                 goto error_out;
 588
 589         if (sdev->removable || sdkp->write_prot)
 590                 check_disk_change(inode->i_bdev);
 591
 592         /*
 593          * If the drive is empty, just let the open fail.
 594          */
 595         retval = -ENOMEDIUM;
 596         if (sdev->removable && !sdkp->media_present &&
 597             !(filp->f_flags & O_NDELAY))
 598                 goto error_out;
 599
 600         /*
 601          * If the device has the write protect tab set, have the open fail
 602          * if the user expects to be able to write to the thing.
 603          */
 604         retval = -EROFS;
 605         if (sdkp->write_prot && (filp->f_mode & FMODE_WRITE))
 606                 goto error_out;
 607
 608         /*
 609          * It is possible that the disk changing stuff resulted in
 610          * the device being taken offline.  If this is the case,
 611          * report this to the user, and don't pretend that the
 612          * open actually succeeded.
 613          */
 614         retval = -ENXIO;
 615         if (!scsi_device_online(sdev))
 616                 goto error_out;
 617
 618         if (!sdkp->openers++ && sdev->removable) {
 619                 if (scsi_block_when_processing_errors(sdev))
 620                         scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
 621         }
 622
 623         return 0;
 624
 625 error_out:
 626         scsi_disk_put(sdkp);
 627         return retval;
 628 }
 629
 630 /**
 631  *      sd_release - invoked when the (last) close(2) is called on this
 632  *      scsi disk.
 633  *      @inode: only i_rdev member may be used
 634  *      @filp: only f_mode and f_flags may be used
 635  *
 636  *      Returns 0.
 637  *
 638  *      Note: may block (uninterruptible) if error recovery is underway
 639  *      on this disk.
 640  **/
 641 static int sd_release(struct inode *inode, struct file *filp)
 642 {
 643         struct gendisk *disk = inode->i_bdev->bd_disk;
 644         struct scsi_disk *sdkp = scsi_disk(disk);
 645         struct scsi_device *sdev = sdkp->device;
 646
 647         SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
 648
 649         if (!--sdkp->openers && sdev->removable) {
 650                 if (scsi_block_when_processing_errors(sdev))
 651                         scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
 652         }
 653
 654         /*
 655          * XXX and what if there are packets in flight and this close()
 656          * XXX is followed by a "rmmod sd_mod"?
 657          */
 658         scsi_disk_put(sdkp);
 659         return 0;
 660 }
 661
 662 static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 663 {
 664         struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
 665         struct scsi_device *sdp = sdkp->device;
 666         struct Scsi_Host *host = sdp->host;
 667         int diskinfo[4];
 668
 669         /* default to most commonly used values */
 670         diskinfo[0] = 0x40;     /* 1 << 6 */
 671         diskinfo[1] = 0x20;     /* 1 << 5 */
 672         diskinfo[2] = sdkp->capacity >> 11;
 673
 674         /* override with calculated, extended default, or driver values */
 675         if (host->hostt->bios_param)
 676                 host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
 677         else
 678                 scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
 679
 680         geo->heads = diskinfo[0];
 681         geo->sectors = diskinfo[1];
 682         geo->cylinders = diskinfo[2];
 683         return 0;
 684 }
 685
 686 /**
 687  *      sd_ioctl - process an ioctl
 688  *      @inode: only i_rdev/i_bdev members may be used
 689  *      @filp: only f_mode and f_flags may be used
 690  *      @cmd: ioctl command number
 691  *      @arg: this is third argument given to ioctl(2) system call.
 692  *      Often contains a pointer.
 693  *
 694  *      Returns 0 if successful (some ioctls return postive numbers on
 695  *      success as well). Returns a negated errno value in case of error.
 696  *
 697  *      Note: most ioctls are forward onto the block subsystem or further
 698  *      down in the scsi subsystem.
 699  **/
 700 static int sd_ioctl(struct inode * inode, struct file * filp,
 701                     unsigned int cmd, unsigned long arg)
 702 {
 703         struct block_device *bdev = inode->i_bdev;
 704         struct gendisk *disk = bdev->bd_disk;
 705         struct scsi_device *sdp = scsi_disk(disk)->device;
 706         void __user *p = (void __user *)arg;
 707         int error;
 708
 709         SCSI_LOG_IOCTL(1, printk("sd_ioctl: disk=%s, cmd=0x%x\n",
 710                                                 disk->disk_name, cmd));
 711
 712         /*
 713          * If we are in the middle of error recovery, don't let anyone
 714          * else try and use this device.  Also, if error recovery fails, it
 715          * may try and take the device offline, in which case all further
 716          * access to the device is prohibited.
 717          */
 718         error = scsi_nonblockable_ioctl(sdp, cmd, p, filp);
 719         if (!scsi_block_when_processing_errors(sdp) || !error)
 720                 return error;
 721
 722         /*
 723          * Send SCSI addressing ioctls directly to mid level, send other
 724          * ioctls to block level and then onto mid level if they can't be
 725          * resolved.
 726          */
 727         switch (cmd) {
 728                 case SCSI_IOCTL_GET_IDLUN:
 729                 case SCSI_IOCTL_GET_BUS_NUMBER:
 730                         return scsi_ioctl(sdp, cmd, p);
 731                 default:
 732                         error = scsi_cmd_ioctl(filp, disk->queue, disk, cmd, p);
 733                         if (error != -ENOTTY)
 734                                 return error;
 735         }
 736         return scsi_ioctl(sdp, cmd, p);
 737 }
 738
 739 static void set_media_not_present(struct scsi_disk *sdkp)
 740 {
 741         sdkp->media_present = 0;
 742         sdkp->capacity = 0;
 743         sdkp->device->changed = 1;
 744 }
 745
 746 /**
 747  *      sd_media_changed - check if our medium changed
 748  *      @disk: kernel device descriptor
 749  *
 750  *      Returns 0 if not applicable or no change; 1 if change
 751  *
 752  *      Note: this function is invoked from the block subsystem.
 753  **/
 754 static int sd_media_changed(struct gendisk *disk)
 755 {
 756         struct scsi_disk *sdkp = scsi_disk(disk);
 757         struct scsi_device *sdp = sdkp->device;
 758         struct scsi_sense_hdr *sshdr = NULL;
 759         int retval;
 760
 761         SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_media_changed\n"));
 762
 763         if (!sdp->removable)
 764                 return 0;
 765
 766         /*
 767          * If the device is offline, don't send any commands - just pretend as
 768          * if the command failed.  If the device ever comes back online, we
 769          * can deal with it then.  It is only because of unrecoverable errors
 770          * that we would ever take a device offline in the first place.
 771          */
 772         if (!scsi_device_online(sdp)) {
 773                 set_media_not_present(sdkp);
 774                 retval = 1;
 775                 goto out;
 776         }
 777
 778         /*
 779          * Using TEST_UNIT_READY enables differentiation between drive with
 780          * no cartridge loaded - NOT READY, drive with changed cartridge -
 781          * UNIT ATTENTION, or with same cartridge - GOOD STATUS.
 782          *
 783          * Drives that auto spin down. eg iomega jaz 1G, will be started
 784          * by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever
 785          * sd_revalidate() is called.
 786          */
 787         retval = -ENODEV;
 788
 789         if (scsi_block_when_processing_errors(sdp)) {
 790                 sshdr  = kzalloc(sizeof(*sshdr), GFP_KERNEL);
 791                 retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
 792                                               sshdr);
 793         }
 794
 795         /*
 796          * Unable to test, unit probably not ready.   This usually
 797          * means there is no disc in the drive.  Mark as changed,
 798          * and we will figure it out later once the drive is
 799          * available again.
 800          */
 801         if (retval || (scsi_sense_valid(sshdr) &&
 802                        /* 0x3a is medium not present */
 803                        sshdr->asc == 0x3a)) {
 804                 set_media_not_present(sdkp);
 805                 retval = 1;
 806                 goto out;
 807         }
 808
 809         /*
 810          * For removable scsi disk we have to recognise the presence
 811          * of a disk in the drive. This is kept in the struct scsi_disk
 812          * struct and tested at open !  Daniel Roche (dan@lectra.fr)
 813          */
 814         sdkp->media_present = 1;
 815
 816         retval = sdp->changed;
 817         sdp->changed = 0;
 818 out:
 819         if (retval != sdkp->previous_state)
 820                 sdev_evt_send_simple(sdp, SDEV_EVT_MEDIA_CHANGE, GFP_KERNEL);
 821         sdkp->previous_state = retval;
 822         kfree(sshdr);
 823         return retval;
 824 }
 825
 826 static int sd_sync_cache(struct scsi_disk *sdkp)
 827 {
 828         int retries, res;
 829         struct scsi_device *sdp = sdkp->device;
 830         struct scsi_sense_hdr sshdr;
 831
 832         if (!scsi_device_online(sdp))
 833                 return -ENODEV;
 834
 835
 836         for (retries = 3; retries > 0; --retries) {
 837                 unsigned char cmd[10] = { 0 };
 838
 839                 cmd[0] = SYNCHRONIZE_CACHE;
 840                 /*
 841                  * Leave the rest of the command zero to indicate
 842                  * flush everything.
 843                  */
 844                 res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
 845                                        SD_TIMEOUT, SD_MAX_RETRIES);
 846                 if (res == 0)
 847                         break;
 848         }
 849
 850         if (res) {
 851                 sd_print_result(sdkp, res);
 852                 if (driver_byte(res) & DRIVER_SENSE)
 853                         sd_print_sense_hdr(sdkp, &sshdr);
 854         }
 855
 856         if (res)
 857                 return -EIO;
 858         return 0;
 859 }
 860
 861 static void sd_prepare_flush(struct request_queue *q, struct request *rq)
 862 {
 863         rq->cmd_type = REQ_TYPE_BLOCK_PC;
 864         rq->timeout = SD_TIMEOUT;
 865         rq->cmd[0] = SYNCHRONIZE_CACHE;
 866         rq->cmd_len = 10;
 867 }
 868
 869 static void sd_rescan(struct device *dev)
 870 {
 871         struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
 872
 873         if (sdkp) {
 874                 sd_revalidate_disk(sdkp->disk);
 875                 scsi_disk_put(sdkp);
 876         }
 877 }
 878
 879
 880 #ifdef CONFIG_COMPAT
 881 /*
 882  * This gets directly called from VFS. When the ioctl
 883  * is not recognized we go back to the other translation paths.
 884  */
 885 static long sd_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 886 {
 887         struct block_device *bdev = file->f_path.dentry->d_inode->i_bdev;
 888         struct gendisk *disk = bdev->bd_disk;
 889         struct scsi_device *sdev = scsi_disk(disk)->device;
 890
 891         /*
 892          * If we are in the middle of error recovery, don't let anyone
 893          * else try and use this device.  Also, if error recovery fails, it
 894          * may try and take the device offline, in which case all further
 895          * access to the device is prohibited.
 896          */
 897         if (!scsi_block_when_processing_errors(sdev))
 898                 return -ENODEV;
 899
 900         if (sdev->host->hostt->compat_ioctl) {
 901                 int ret;
 902
 903                 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
 904
 905                 return ret;
 906         }
 907
 908         /*
 909          * Let the static ioctl translation table take care of it.
 910          */
 911         return -ENOIOCTLCMD;
 912 }
 913 #endif
 914
 915 static struct block_device_operations sd_fops = {
 916         .owner                  = THIS_MODULE,
 917         .open                   = sd_open,
 918         .release                = sd_release,
 919         .ioctl                  = sd_ioctl,
 920         .getgeo                 = sd_getgeo,
 921 #ifdef CONFIG_COMPAT
 922         .compat_ioctl           = sd_compat_ioctl,
 923 #endif
 924         .media_changed          = sd_media_changed,
 925         .revalidate_disk        = sd_revalidate_disk,
 926 };
 927
 928 /**
 929  *      sd_done - bottom half handler: called when the lower level
 930  *      driver has completed (successfully or otherwise) a scsi command.
 931  *      @SCpnt: mid-level's per command structure.
 932  *
 933  *      Note: potentially run from within an ISR. Must not block.
 934  **/
 935 static int sd_done(struct scsi_cmnd *SCpnt)
 936 {
 937         int result = SCpnt->result;
 938         unsigned int xfer_size = scsi_bufflen(SCpnt);
 939         unsigned int good_bytes = result ? 0 : xfer_size;
 940         u64 start_lba = SCpnt->request->sector;
 941         u64 end_lba = SCpnt->request->sector + (xfer_size / 512);
 942         u64 bad_lba;
 943         struct scsi_sense_hdr sshdr;
 944         int sense_valid = 0;
 945         int sense_deferred = 0;
 946         int info_valid;
 947
 948         if (result) {
 949                 sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
 950                 if (sense_valid)
 951                         sense_deferred = scsi_sense_is_deferred(&sshdr);
 952         }
 953 #ifdef CONFIG_SCSI_LOGGING
 954         SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
 955         if (sense_valid) {
 956                 SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
 957                                                    "sd_done: sb[respc,sk,asc,"
 958                                                    "ascq]=%x,%x,%x,%x\n",
 959                                                    sshdr.response_code,
 960                                                    sshdr.sense_key, sshdr.asc,
 961                                                    sshdr.ascq));
 962         }
 963 #endif
 964         if (driver_byte(result) != DRIVER_SENSE &&
 965             (!sense_valid || sense_deferred))
 966                 goto out;
 967
 968         switch (sshdr.sense_key) {
 969         case HARDWARE_ERROR:
 970         case MEDIUM_ERROR:
 971                 if (!blk_fs_request(SCpnt->request))
 972                         goto out;
 973                 info_valid = scsi_get_sense_info_fld(SCpnt->sense_buffer,
 974                                                      SCSI_SENSE_BUFFERSIZE,
 975                                                      &bad_lba);
 976                 if (!info_valid)
 977                         goto out;
 978                 if (xfer_size <= SCpnt->device->sector_size)
 979                         goto out;
 980                 if (SCpnt->device->sector_size < 512) {
 981                         /* only legitimate sector_size here is 256 */
 982                         start_lba <<= 1;
 983                         end_lba <<= 1;
 984                 } else {
 985                         /* be careful ... don't want any overflows */
 986                         u64 factor = SCpnt->device->sector_size / 512;
 987                         do_div(start_lba, factor);
 988                         do_div(end_lba, factor);
 989                 }
 990
 991                 if (bad_lba < start_lba  || bad_lba >= end_lba)
 992                         /* the bad lba was reported incorrectly, we have
 993                          * no idea where the error is
 994                          */
 995                         goto out;
 996
 997                 /* This computation should always be done in terms of
 998                  * the resolution of the device's medium.
 999                  */
1000                 good_bytes = (bad_lba - start_lba)*SCpnt->device->sector_size;
1001                 break;
1002         case RECOVERED_ERROR:
1003         case NO_SENSE:
1004                 /* Inform the user, but make sure that it's not treated
1005                  * as a hard error.
1006                  */
1007                 scsi_print_sense("sd", SCpnt);
1008                 SCpnt->result = 0;
1009                 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1010                 good_bytes = xfer_size;
1011                 break;
1012         case ILLEGAL_REQUEST:
1013                 if (SCpnt->device->use_10_for_rw &&
1014                     (SCpnt->cmnd[0] == READ_10 ||
1015                      SCpnt->cmnd[0] == WRITE_10))
1016                         SCpnt->device->use_10_for_rw = 0;
1017                 if (SCpnt->device->use_10_for_ms &&
1018                     (SCpnt->cmnd[0] == MODE_SENSE_10 ||
1019                      SCpnt->cmnd[0] == MODE_SELECT_10))
1020                         SCpnt->device->use_10_for_ms = 0;
1021                 break;
1022         default:
1023                 break;
1024         }
1025  out:
1026         return good_bytes;
1027 }
1028
1029 static int media_not_present(struct scsi_disk *sdkp,
1030                              struct scsi_sense_hdr *sshdr)
1031 {
1032
1033         if (!scsi_sense_valid(sshdr))
1034                 return 0;
1035         /* not invoked for commands that could return deferred errors */
1036         if (sshdr->sense_key != NOT_READY &&
1037             sshdr->sense_key != UNIT_ATTENTION)
1038                 return 0;
1039         if (sshdr->asc != 0x3A) /* medium not present */
1040                 return 0;
1041
1042         set_media_not_present(sdkp);
1043         return 1;
1044 }
1045
1046 /*
1047  * spinup disk - called only in sd_revalidate_disk()
1048  */
1049 static void
1050 sd_spinup_disk(struct scsi_disk *sdkp)
1051 {
1052         unsigned char cmd[10];
1053         unsigned long spintime_expire = 0;
1054         int retries, spintime;
1055         unsigned int the_result;
1056         struct scsi_sense_hdr sshdr;
1057         int sense_valid = 0;
1058
1059         spintime = 0;
1060
1061         /* Spin up drives, as required.  Only do this at boot time */
1062         /* Spinup needs to be done for module loads too. */
1063         do {
1064                 retries = 0;
1065
1066                 do {
1067                         cmd[0] = TEST_UNIT_READY;
1068                         memset((void *) &cmd[1], 0, 9);
1069
1070                         the_result = scsi_execute_req(sdkp->device, cmd,
1071                                                       DMA_NONE, NULL, 0,
1072                                                       &sshdr, SD_TIMEOUT,
1073                                                       SD_MAX_RETRIES);
1074
1075                         /*
1076                          * If the drive has indicated to us that it
1077                          * doesn't have any media in it, don't bother
1078                          * with any more polling.
1079                          */
1080                         if (media_not_present(sdkp, &sshdr))
1081                                 return;
1082
1083                         if (the_result)
1084                                 sense_valid = scsi_sense_valid(&sshdr);
1085                         retries++;
1086                 } while (retries < 3 &&
1087                          (!scsi_status_is_good(the_result) ||
1088                           ((driver_byte(the_result) & DRIVER_SENSE) &&
1089                           sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
1090
1091                 if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
1092                         /* no sense, TUR either succeeded or failed
1093                          * with a status error */
1094                         if(!spintime && !scsi_status_is_good(the_result)) {
1095                                 sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1096                                 sd_print_result(sdkp, the_result);
1097                         }
1098                         break;
1099                 }
1100
1101                 /*
1102                  * The device does not want the automatic start to be issued.
1103                  */
1104                 if (sdkp->device->no_start_on_add) {
1105                         break;
1106                 }
1107
1108                 /*
1109                  * If manual intervention is required, or this is an
1110                  * absent USB storage device, a spinup is meaningless.
1111                  */
1112                 if (sense_valid &&
1113                     sshdr.sense_key == NOT_READY &&
1114                     sshdr.asc == 4 && sshdr.ascq == 3) {
1115                         break;          /* manual intervention required */
1116
1117                 /*
1118                  * Issue command to spin up drive when not ready
1119                  */
1120                 } else if (sense_valid && sshdr.sense_key == NOT_READY) {
1121                         if (!spintime) {
1122                                 sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
1123                                 cmd[0] = START_STOP;
1124                                 cmd[1] = 1;     /* Return immediately */
1125                                 memset((void *) &cmd[2], 0, 8);
1126                                 cmd[4] = 1;     /* Start spin cycle */
1127                                 if (sdkp->device->start_stop_pwr_cond)
1128                                         cmd[4] |= 1 << 4;
1129                                 scsi_execute_req(sdkp->device, cmd, DMA_NONE,
1130                                                  NULL, 0, &sshdr,
1131                                                  SD_TIMEOUT, SD_MAX_RETRIES);
1132                                 spintime_expire = jiffies + 100 * HZ;
1133                                 spintime = 1;
1134                         }
1135                         /* Wait 1 second for next try */
1136                         msleep(1000);
1137                         printk(".");
1138
1139                 /*
1140                  * Wait for USB flash devices with slow firmware.
1141                  * Yes, this sense key/ASC combination shouldn't
1142                  * occur here.  It's characteristic of these devices.
1143                  */
1144                 } else if (sense_valid &&
1145                                 sshdr.sense_key == UNIT_ATTENTION &&
1146                                 sshdr.asc == 0x28) {
1147                         if (!spintime) {
1148                                 spintime_expire = jiffies + 5 * HZ;
1149                                 spintime = 1;
1150                         }
1151                         /* Wait 1 second for next try */
1152                         msleep(1000);
1153                 } else {
1154                         /* we don't understand the sense code, so it's
1155                          * probably pointless to loop */
1156                         if(!spintime) {
1157                                 sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1158                                 sd_print_sense_hdr(sdkp, &sshdr);
1159                         }
1160                         break;
1161                 }
1162
1163         } while (spintime && time_before_eq(jiffies, spintime_expire));
1164
1165         if (spintime) {
1166                 if (scsi_status_is_good(the_result))
1167                         printk("ready\n");
1168                 else
1169                         printk("not responding...\n");
1170         }
1171 }
1172
1173 /*
1174  * read disk capacity
1175  */
1176 static void
1177 sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
1178 {
1179         unsigned char cmd[16];
1180         int the_result, retries;
1181         int sector_size = 0;
1182         int longrc = 0;
1183         struct scsi_sense_hdr sshdr;
1184         int sense_valid = 0;
1185         struct scsi_device *sdp = sdkp->device;
1186
1187 repeat:
1188         retries = 3;
1189         do {
1190                 if (longrc) {
1191                         memset((void *) cmd, 0, 16);
1192                         cmd[0] = SERVICE_ACTION_IN;
1193                         cmd[1] = SAI_READ_CAPACITY_16;
1194                         cmd[13] = 12;
1195                         memset((void *) buffer, 0, 12);
1196                 } else {
1197                         cmd[0] = READ_CAPACITY;
1198                         memset((void *) &cmd[1], 0, 9);
1199                         memset((void *) buffer, 0, 8);
1200                 }
1201
1202                 the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
1203                                               buffer, longrc ? 12 : 8, &sshdr,
1204                                               SD_TIMEOUT, SD_MAX_RETRIES);
1205
1206                 if (media_not_present(sdkp, &sshdr))
1207                         return;
1208
1209                 if (the_result)
1210                         sense_valid = scsi_sense_valid(&sshdr);
1211                 retries--;
1212
1213         } while (the_result && retries);
1214
1215         if (the_result && !longrc) {
1216                 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
1217                 sd_print_result(sdkp, the_result);
1218                 if (driver_byte(the_result) & DRIVER_SENSE)
1219                         sd_print_sense_hdr(sdkp, &sshdr);
1220                 else
1221                         sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
1222
1223                 /* Set dirty bit for removable devices if not ready -
1224                  * sometimes drives will not report this properly. */
1225                 if (sdp->removable &&
1226                     sense_valid && sshdr.sense_key == NOT_READY)
1227                         sdp->changed = 1;
1228
1229                 /* Either no media are present but the drive didn't tell us,
1230                    or they are present but the read capacity command fails */
1231                 /* sdkp->media_present = 0; -- not always correct */
1232                 sdkp->capacity = 0; /* unknown mapped to zero - as usual */
1233
1234                 return;
1235         } else if (the_result && longrc) {
1236                 /* READ CAPACITY(16) has been failed */
1237                 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
1238                 sd_print_result(sdkp, the_result);
1239                 sd_printk(KERN_NOTICE, sdkp, "Use 0xffffffff as device size\n");
1240
1241                 sdkp->capacity = 1 + (sector_t) 0xffffffff;
1242                 goto got_data;
1243         }
1244
1245         if (!longrc) {
1246                 sector_size = (buffer[4] << 24) |
1247                         (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
1248                 if (buffer[0] == 0xff && buffer[1] == 0xff &&
1249                     buffer[2] == 0xff && buffer[3] == 0xff) {
1250                         if(sizeof(sdkp->capacity) > 4) {
1251                                 sd_printk(KERN_NOTICE, sdkp, "Very big device. "
1252                                           "Trying to use READ CAPACITY(16).\n");
1253                                 longrc = 1;
1254                                 goto repeat;
1255                         }
1256                         sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use "
1257                                   "a kernel compiled with support for large "
1258                                   "block devices.\n");
1259                         sdkp->capacity = 0;
1260                         goto got_data;
1261                 }
1262                 sdkp->capacity = 1 + (((sector_t)buffer[0] << 24) |
1263                         (buffer[1] << 16) |
1264                         (buffer[2] << 8) |
1265                         buffer[3]);
1266         } else {
1267                 sdkp->capacity = 1 + (((u64)buffer[0] << 56) |
1268                         ((u64)buffer[1] << 48) |
1269                         ((u64)buffer[2] << 40) |
1270                         ((u64)buffer[3] << 32) |
1271                         ((sector_t)buffer[4] << 24) |
1272                         ((sector_t)buffer[5] << 16) |
1273                         ((sector_t)buffer[6] << 8)  |
1274                         (sector_t)buffer[7]);
1275
1276                 sector_size = (buffer[8] << 24) |
1277                         (buffer[9] << 16) | (buffer[10] << 8) | buffer[11];
1278         }
1279
1280         /* Some devices return the total number of sectors, not the
1281          * highest sector number.  Make the necessary adjustment. */
1282         if (sdp->fix_capacity) {
1283                 --sdkp->capacity;
1284
1285         /* Some devices have version which report the correct sizes
1286          * and others which do not. We guess size according to a heuristic
1287          * and err on the side of lowering the capacity. */
1288         } else {
1289                 if (sdp->guess_capacity)
1290                         if (sdkp->capacity & 0x01) /* odd sizes are odd */
1291                                 --sdkp->capacity;
1292         }
1293
1294 got_data:
1295         if (sector_size == 0) {
1296                 sector_size = 512;
1297                 sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
1298                           "assuming 512.\n");
1299         }
1300
1301         if (sector_size != 512 &&
1302             sector_size != 1024 &&
1303             sector_size != 2048 &&
1304             sector_size != 4096 &&
1305             sector_size != 256) {
1306                 sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
1307                           sector_size);
1308                 /*
1309                  * The user might want to re-format the drive with
1310                  * a supported sectorsize.  Once this happens, it
1311                  * would be relatively trivial to set the thing up.
1312                  * For this reason, we leave the thing in the table.
1313                  */
1314                 sdkp->capacity = 0;
1315                 /*
1316                  * set a bogus sector size so the normal read/write
1317                  * logic in the block layer will eventually refuse any
1318                  * request on this device without tripping over power
1319                  * of two sector size assumptions
1320                  */
1321                 sector_size = 512;
1322         }
1323         {
1324                 /*
1325                  * The msdos fs needs to know the hardware sector size
1326                  * So I have created this table. See ll_rw_blk.c
1327                  * Jacques Gelinas (Jacques@solucorp.qc.ca)
1328                  */
1329                 int hard_sector = sector_size;
1330                 sector_t sz = (sdkp->capacity/2) * (hard_sector/256);
1331                 struct request_queue *queue = sdp->request_queue;
1332                 sector_t mb = sz;
1333
1334                 blk_queue_hardsect_size(queue, hard_sector);
1335                 /* avoid 64-bit division on 32-bit platforms */
1336                 sector_div(sz, 625);
1337                 mb -= sz - 974;
1338                 sector_div(mb, 1950);
1339
1340                 sd_printk(KERN_NOTICE, sdkp,
1341                           "%llu %d-byte hardware sectors (%llu MB)\n",
1342                           (unsigned long long)sdkp->capacity,
1343                           hard_sector, (unsigned long long)mb);
1344         }
1345
1346         /* Rescale capacity to 512-byte units */
1347         if (sector_size == 4096)
1348                 sdkp->capacity <<= 3;
1349         else if (sector_size == 2048)
1350                 sdkp->capacity <<= 2;
1351         else if (sector_size == 1024)
1352                 sdkp->capacity <<= 1;
1353         else if (sector_size == 256)
1354                 sdkp->capacity >>= 1;
1355
1356         sdkp->device->sector_size = sector_size;
1357 }
1358
1359 /* called with buffer of length 512 */
1360 static inline int
1361 sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
1362                  unsigned char *buffer, int len, struct scsi_mode_data *data,
1363                  struct scsi_sense_hdr *sshdr)
1364 {
1365         return scsi_mode_sense(sdp, dbd, modepage, buffer, len,
1366                                SD_TIMEOUT, SD_MAX_RETRIES, data,
1367                                sshdr);
1368 }
1369
1370 /*
1371  * read write protect setting, if possible - called only in sd_revalidate_disk()
1372  * called with buffer of length SD_BUF_SIZE
1373  */
1374 static void
1375 sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
1376 {
1377         int res;
1378         struct scsi_device *sdp = sdkp->device;
1379         struct scsi_mode_data data;
1380
1381         set_disk_ro(sdkp->disk, 0);
1382         if (sdp->skip_ms_page_3f) {
1383                 sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
1384                 return;
1385         }
1386
1387         if (sdp->use_192_bytes_for_3f) {
1388                 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL);
1389         } else {
1390                 /*
1391                  * First attempt: ask for all pages (0x3F), but only 4 bytes.
1392                  * We have to start carefully: some devices hang if we ask
1393                  * for more than is available.
1394                  */
1395                 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL);
1396
1397                 /*
1398                  * Second attempt: ask for page 0 When only page 0 is
1399                  * implemented, a request for page 3F may return Sense Key
1400                  * 5: Illegal Request, Sense Code 24: Invalid field in
1401                  * CDB.
1402                  */
1403                 if (!scsi_status_is_good(res))
1404                         res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL);
1405
1406                 /*
1407                  * Third attempt: ask 255 bytes, as we did earlier.
1408                  */
1409                 if (!scsi_status_is_good(res))
1410                         res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255,
1411                                                &data, NULL);
1412         }
1413
1414         if (!scsi_status_is_good(res)) {
1415                 sd_printk(KERN_WARNING, sdkp,
1416                           "Test WP failed, assume Write Enabled\n");
1417         } else {
1418                 sdkp->write_prot = ((data.device_specific & 0x80) != 0);
1419                 set_disk_ro(sdkp->disk, sdkp->write_prot);
1420                 sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
1421                           sdkp->write_prot ? "on" : "off");
1422                 sd_printk(KERN_DEBUG, sdkp,
1423                           "Mode Sense: %02x %02x %02x %02x\n",
1424                           buffer[0], buffer[1], buffer[2], buffer[3]);
1425         }
1426 }
1427
1428 /*
1429  * sd_read_cache_type - called only from sd_revalidate_disk()
1430  * called with buffer of length SD_BUF_SIZE
1431  */
1432 static void
1433 sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
1434 {
1435         int len = 0, res;
1436         struct scsi_device *sdp = sdkp->device;
1437
1438         int dbd;
1439         int modepage;
1440         struct scsi_mode_data data;
1441         struct scsi_sense_hdr sshdr;
1442
1443         if (sdp->skip_ms_page_8)
1444                 goto defaults;
1445
1446         if (sdp->type == TYPE_RBC) {
1447                 modepage = 6;
1448                 dbd = 8;
1449         } else {
1450                 modepage = 8;
1451                 dbd = 0;
1452         }
1453
1454         /* cautiously ask */
1455         res = sd_do_mode_sense(sdp, dbd, modepage, buffer, 4, &data, &sshdr);
1456
1457         if (!scsi_status_is_good(res))
1458                 goto bad_sense;
1459
1460         if (!data.header_length) {
1461                 modepage = 6;
1462                 sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
1463         }
1464
1465         /* that went OK, now ask for the proper length */
1466         len = data.length;
1467
1468         /*
1469          * We're only interested in the first three bytes, actually.
1470          * But the data cache page is defined for the first 20.
1471          */
1472         if (len < 3)
1473                 goto bad_sense;
1474         if (len > 20)
1475                 len = 20;
1476
1477         /* Take headers and block descriptors into account */
1478         len += data.header_length + data.block_descriptor_length;
1479         if (len > SD_BUF_SIZE)
1480                 goto bad_sense;
1481
1482         /* Get the data */
1483         res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
1484
1485         if (scsi_status_is_good(res)) {
1486                 int offset = data.header_length + data.block_descriptor_length;
1487
1488                 if (offset >= SD_BUF_SIZE - 2) {
1489                         sd_printk(KERN_ERR, sdkp, "Malformed MODE SENSE response\n");
1490                         goto defaults;
1491                 }
1492
1493                 if ((buffer[offset] & 0x3f) != modepage) {
1494                         sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
1495                         goto defaults;
1496                 }
1497
1498                 if (modepage == 8) {
1499                         sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
1500                         sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
1501                 } else {
1502                         sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
1503                         sdkp->RCD = 0;
1504                 }
1505
1506                 sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
1507                 if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
1508                         sd_printk(KERN_NOTICE, sdkp,
1509                                   "Uses READ/WRITE(6), disabling FUA\n");
1510                         sdkp->DPOFUA = 0;
1511                 }
1512
1513                 sd_printk(KERN_NOTICE, sdkp,
1514                        "Write cache: %s, read cache: %s, %s\n",
1515                        sdkp->WCE ? "enabled" : "disabled",
1516                        sdkp->RCD ? "disabled" : "enabled",
1517                        sdkp->DPOFUA ? "supports DPO and FUA"
1518                        : "doesn't support DPO or FUA");
1519
1520                 return;
1521         }
1522
1523 bad_sense:
1524         if (scsi_sense_valid(&sshdr) &&
1525             sshdr.sense_key == ILLEGAL_REQUEST &&
1526             sshdr.asc == 0x24 && sshdr.ascq == 0x0)
1527                 /* Invalid field in CDB */
1528                 sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
1529         else
1530                 sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
1531
1532 defaults:
1533         sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
1534         sdkp->WCE = 0;
1535         sdkp->RCD = 0;
1536         sdkp->DPOFUA = 0;
1537 }
1538
1539 /**
1540  *      sd_revalidate_disk - called the first time a new disk is seen,
1541  *      performs disk spin up, read_capacity, etc.
1542  *      @disk: struct gendisk we care about
1543  **/
1544 static int sd_revalidate_disk(struct gendisk *disk)
1545 {
1546         struct scsi_disk *sdkp = scsi_disk(disk);
1547         struct scsi_device *sdp = sdkp->device;
1548         unsigned char *buffer;
1549         unsigned ordered;
1550
1551         SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
1552                                       "sd_revalidate_disk\n"));
1553
1554         /*
1555          * If the device is offline, don't try and read capacity or any
1556          * of the other niceties.
1557          */
1558         if (!scsi_device_online(sdp))
1559                 goto out;
1560
1561         buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
1562         if (!buffer) {
1563                 sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
1564                           "allocation failure.\n");
1565                 goto out;
1566         }
1567
1568         /* defaults, until the device tells us otherwise */
1569         sdp->sector_size = 512;
1570         sdkp->capacity = 0;
1571         sdkp->media_present = 1;
1572         sdkp->write_prot = 0;
1573         sdkp->WCE = 0;
1574         sdkp->RCD = 0;
1575
1576         sd_spinup_disk(sdkp);
1577
1578         /*
1579          * Without media there is no reason to ask; moreover, some devices
1580          * react badly if we do.
1581          */
1582         if (sdkp->media_present) {
1583                 sd_read_capacity(sdkp, buffer);
1584                 sd_read_write_protect_flag(sdkp, buffer);
1585                 sd_read_cache_type(sdkp, buffer);
1586         }
1587
1588         /*
1589          * We now have all cache related info, determine how we deal
1590          * with ordered requests.  Note that as the current SCSI
1591          * dispatch function can alter request order, we cannot use
1592          * QUEUE_ORDERED_TAG_* even when ordered tag is supported.
1593          */
1594         if (sdkp->WCE)
1595                 ordered = sdkp->DPOFUA
1596                         ? QUEUE_ORDERED_DRAIN_FUA : QUEUE_ORDERED_DRAIN_FLUSH;
1597         else
1598                 ordered = QUEUE_ORDERED_DRAIN;
1599
1600         blk_queue_ordered(sdkp->disk->queue, ordered, sd_prepare_flush);
1601
1602         set_capacity(disk, sdkp->capacity);
1603         kfree(buffer);
1604
1605  out:
1606         return 0;
1607 }
1608
1609 /**
1610  *      sd_probe - called during driver initialization and whenever a
1611  *      new scsi device is attached to the system. It is called once
1612  *      for each scsi device (not just disks) present.
1613  *      @dev: pointer to device object
1614  *
1615  *      Returns 0 if successful (or not interested in this scsi device
1616  *      (e.g. scanner)); 1 when there is an error.
1617  *
1618  *      Note: this function is invoked from the scsi mid-level.
1619  *      This function sets up the mapping between a given
1620  *      <host,channel,id,lun> (found in sdp) and new device name
1621  *      (e.g. /dev/sda). More precisely it is the block device major
1622  *      and minor number that is chosen here.
1623  *
1624  *      Assume sd_attach is not re-entrant (for time being)
1625  *      Also think about sd_attach() and sd_remove() running coincidentally.
1626  **/
1627 static int sd_probe(struct device *dev)
1628 {
1629         struct scsi_device *sdp = to_scsi_device(dev);
1630         struct scsi_disk *sdkp;
1631         struct gendisk *gd;
1632         u32 index;
1633         int error;
1634
1635         error = -ENODEV;
1636         if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)
1637                 goto out;
1638
1639         SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
1640                                         "sd_attach\n"));
1641
1642         error = -ENOMEM;
1643         sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
1644         if (!sdkp)
1645                 goto out;
1646
1647         gd = alloc_disk(16);
1648         if (!gd)
1649                 goto out_free;
1650
1651         if (!idr_pre_get(&sd_index_idr, GFP_KERNEL))
1652                 goto out_put;
1653
1654         spin_lock(&sd_index_lock);
1655         error = idr_get_new(&sd_index_idr, NULL, &index);
1656         spin_unlock(&sd_index_lock);
1657
1658         if (index >= SD_MAX_DISKS)
1659                 error = -EBUSY;
1660         if (error)
1661                 goto out_put;
1662
1663         sdkp->device = sdp;
1664         sdkp->driver = &sd_template;
1665         sdkp->disk = gd;
1666         sdkp->index = index;
1667         sdkp->openers = 0;
1668         sdkp->previous_state = 1;
1669
1670         if (!sdp->timeout) {
1671                 if (sdp->type != TYPE_MOD)
1672                         sdp->timeout = SD_TIMEOUT;
1673                 else
1674                         sdp->timeout = SD_MOD_TIMEOUT;
1675         }
1676
1677         device_initialize(&sdkp->dev);
1678         sdkp->dev.parent = &sdp->sdev_gendev;
1679         sdkp->dev.class = &sd_disk_class;
1680         strncpy(sdkp->dev.bus_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE);
1681
1682         if (device_add(&sdkp->dev))
1683                 goto out_put;
1684
1685         get_device(&sdp->sdev_gendev);
1686
1687         gd->major = sd_major((index & 0xf0) >> 4);
1688         gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
1689         gd->minors = 16;
1690         gd->fops = &sd_fops;
1691
1692         if (index < 26) {
1693                 sprintf(gd->disk_name, "sd%c", 'a' + index % 26);
1694         } else if (index < (26 + 1) * 26) {
1695                 sprintf(gd->disk_name, "sd%c%c",
1696                         'a' + index / 26 - 1,'a' + index % 26);
1697         } else {
1698                 const unsigned int m1 = (index / 26 - 1) / 26 - 1;
1699                 const unsigned int m2 = (index / 26 - 1) % 26;
1700                 const unsigned int m3 =  index % 26;
1701                 sprintf(gd->disk_name, "sd%c%c%c",
1702                         'a' + m1, 'a' + m2, 'a' + m3);
1703         }
1704
1705         gd->private_data = &sdkp->driver;
1706         gd->queue = sdkp->device->request_queue;
1707
1708         sd_revalidate_disk(gd);
1709
1710         blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
1711
1712         gd->driverfs_dev = &sdp->sdev_gendev;
1713         gd->flags = GENHD_FL_DRIVERFS;
1714         if (sdp->removable)
1715                 gd->flags |= GENHD_FL_REMOVABLE;
1716
1717         dev_set_drvdata(dev, sdkp);
1718         add_disk(gd);
1719
1720         sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
1721                   sdp->removable ? "removable " : "");
1722
1723         return 0;
1724
1725  out_put:
1726         put_disk(gd);
1727  out_free:
1728         kfree(sdkp);
1729  out:
1730         return error;
1731 }
1732
1733 /**
1734  *      sd_remove - called whenever a scsi disk (previously recognized by
1735  *      sd_probe) is detached from the system. It is called (potentially
1736  *      multiple times) during sd module unload.
1737  *      @sdp: pointer to mid level scsi device object
1738  *
1739  *      Note: this function is invoked from the scsi mid-level.
1740  *      This function potentially frees up a device name (e.g. /dev/sdc)
1741  *      that could be re-used by a subsequent sd_probe().
1742  *      This function is not called when the built-in sd driver is "exit-ed".
1743  **/
1744 static int sd_remove(struct device *dev)
1745 {
1746         struct scsi_disk *sdkp = dev_get_drvdata(dev);
1747
1748         device_del(&sdkp->dev);
1749         del_gendisk(sdkp->disk);
1750         sd_shutdown(dev);
1751
1752         mutex_lock(&sd_ref_mutex);
1753         dev_set_drvdata(dev, NULL);
1754         put_device(&sdkp->dev);
1755         mutex_unlock(&sd_ref_mutex);
1756
1757         return 0;
1758 }
1759
1760 /**
1761  *      scsi_disk_release - Called to free the scsi_disk structure
1762  *      @dev: pointer to embedded class device
1763  *
1764  *      sd_ref_mutex must be held entering this routine.  Because it is
1765  *      called on last put, you should always use the scsi_disk_get()
1766  *      scsi_disk_put() helpers which manipulate the semaphore directly
1767  *      and never do a direct put_device.
1768  **/
1769 static void scsi_disk_release(struct device *dev)
1770 {
1771         struct scsi_disk *sdkp = to_scsi_disk(dev);
1772         struct gendisk *disk = sdkp->disk;
1773
1774         spin_lock(&sd_index_lock);
1775         idr_remove(&sd_index_idr, sdkp->index);
1776         spin_unlock(&sd_index_lock);
1777
1778         disk->private_data = NULL;
1779         put_disk(disk);
1780         put_device(&sdkp->device->sdev_gendev);
1781
1782         kfree(sdkp);
1783 }
1784
1785 static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
1786 {
1787         unsigned char cmd[6] = { START_STOP };  /* START_VALID */
1788         struct scsi_sense_hdr sshdr;
1789         struct scsi_device *sdp = sdkp->device;
1790         int res;
1791
1792         if (start)
1793                 cmd[4] |= 1;    /* START */
1794
1795         if (sdp->start_stop_pwr_cond)
1796                 cmd[4] |= start ? 1 << 4 : 3 << 4;      /* Active or Standby */
1797
1798         if (!scsi_device_online(sdp))
1799                 return -ENODEV;
1800
1801         res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
1802                                SD_TIMEOUT, SD_MAX_RETRIES);
1803         if (res) {
1804                 sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
1805                 sd_print_result(sdkp, res);
1806                 if (driver_byte(res) & DRIVER_SENSE)
1807                         sd_print_sense_hdr(sdkp, &sshdr);
1808         }
1809
1810         return res;
1811 }
1812
1813 /*
1814  * Send a SYNCHRONIZE CACHE instruction down to the device through
1815  * the normal SCSI command structure.  Wait for the command to
1816  * complete.
1817  */
1818 static void sd_shutdown(struct device *dev)
1819 {
1820         struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
1821
1822         if (!sdkp)
1823                 return;         /* this can happen */
1824
1825         if (sdkp->WCE) {
1826                 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
1827                 sd_sync_cache(sdkp);
1828         }
1829
1830         if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
1831                 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
1832                 sd_start_stop_device(sdkp, 0);
1833         }
1834
1835         scsi_disk_put(sdkp);
1836 }
1837
1838 static int sd_suspend(struct device *dev, pm_message_t mesg)
1839 {
1840         struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
1841         int ret = 0;
1842
1843         if (!sdkp)
1844                 return 0;       /* this can happen */
1845
1846         if (sdkp->WCE) {
1847                 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
1848                 ret = sd_sync_cache(sdkp);
1849                 if (ret)
1850                         goto done;
1851         }
1852
1853         if ((mesg.event & PM_EVENT_SLEEP) && sdkp->device->manage_start_stop) {
1854                 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
1855                 ret = sd_start_stop_device(sdkp, 0);
1856         }
1857
1858 done:
1859         scsi_disk_put(sdkp);
1860         return ret;
1861 }
1862
1863 static int sd_resume(struct device *dev)
1864 {
1865         struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
1866         int ret = 0;
1867
1868         if (!sdkp->device->manage_start_stop)
1869                 goto done;
1870
1871         sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
1872         ret = sd_start_stop_device(sdkp, 1);
1873
1874 done:
1875         scsi_disk_put(sdkp);
1876         return ret;
1877 }
1878
1879 /**
1880  *      init_sd - entry point for this driver (both when built in or when
1881  *      a module).
1882  *
1883  *      Note: this function registers this driver with the scsi mid-level.
1884  **/
1885 static int __init init_sd(void)
1886 {
1887         int majors = 0, i, err;
1888
1889         SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
1890
1891         for (i = 0; i < SD_MAJORS; i++)
1892                 if (register_blkdev(sd_major(i), "sd") == 0)
1893                         majors++;
1894
1895         if (!majors)
1896                 return -ENODEV;
1897
1898         err = class_register(&sd_disk_class);
1899         if (err)
1900                 goto err_out;
1901
1902         err = scsi_register_driver(&sd_template.gendrv);
1903         if (err)
1904                 goto err_out_class;
1905
1906         return 0;
1907
1908 err_out_class:
1909         class_unregister(&sd_disk_class);
1910 err_out:
1911         for (i = 0; i < SD_MAJORS; i++)
1912                 unregister_blkdev(sd_major(i), "sd");
1913         return err;
1914 }
1915
1916 /**
1917  *      exit_sd - exit point for this driver (when it is a module).
1918  *
1919  *      Note: this function unregisters this driver from the scsi mid-level.
1920  **/
1921 static void __exit exit_sd(void)
1922 {
1923         int i;
1924
1925         SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
1926
1927         scsi_unregister_driver(&sd_template.gendrv);
1928         class_unregister(&sd_disk_class);
1929
1930         for (i = 0; i < SD_MAJORS; i++)
1931                 unregister_blkdev(sd_major(i), "sd");
1932 }
1933
1934 module_init(init_sd);
1935 module_exit(exit_sd);
1936
1937 static void sd_print_sense_hdr(struct scsi_disk *sdkp,
1938                                struct scsi_sense_hdr *sshdr)
1939 {
1940         sd_printk(KERN_INFO, sdkp, "");
1941         scsi_show_sense_hdr(sshdr);
1942         sd_printk(KERN_INFO, sdkp, "");
1943         scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
1944 }
1945
1946 static void sd_print_result(struct scsi_disk *sdkp, int result)
1947 {
1948         sd_printk(KERN_INFO, sdkp, "");
1949         scsi_show_result(result);
1950 }
1951