1 files changed, 225 insertions, 180 deletions

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 5a8f55fea5ff..00e46662296f 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -58,16 +58,10 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_ioctl.h>
 #include <scsi/scsicam.h>
+#include <scsi/sd.h>
 
 #include "scsi_logging.h"
 
-/*
- * More than enough for everybody ;)  The huge number of majors
- * is a leftover from 16bit dev_t days, we don't really need that
- * much numberspace.
- */
-#define SD_MAJORS       16
-
 MODULE_AUTHOR("Eric Youngdale");
 MODULE_DESCRIPTION("SCSI disk (sd) driver");
 MODULE_LICENSE("GPL");
@@ -88,45 +82,9 @@ MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
-
-/*
- * This is limited by the naming scheme enforced in sd_probe,
- * add another character to it if you really need more disks.
- */
-#define SD_MAX_DISKS    (((26 * 26) + 26 + 1) * 26)
-
-/*
- * Time out in seconds for disks and Magneto-opticals (which are slower).
- */
-#define SD_TIMEOUT              (30 * HZ)
-#define SD_MOD_TIMEOUT          (75 * HZ)
-
-/*
- * Number of allowed retries
- */
-#define SD_MAX_RETRIES          5
-#define SD_PASSTHROUGH_RETRIES  1
-
-/*
- * Size of the initial data buffer for mode and read capacity data
- */
-#define SD_BUF_SIZE             512
-
-struct scsi_disk {
-        struct scsi_driver *driver;     /* always &sd_template */
-        struct scsi_device *device;
-        struct class_device cdev;
-        struct gendisk  *disk;
-        unsigned int    openers;        /* protected by BKL for now, yuck */
-        sector_t        capacity;       /* size in 512-byte sectors */
-        u32             index;
-        u8              media_present;
-        u8              write_prot;
-        unsigned        WCE : 1;        /* state of disk WCE bit */
-        unsigned        RCD : 1;        /* state of disk RCD bit, unused */
-        unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
-};
-#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,cdev)
+MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
+MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
+MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
 
 static DEFINE_IDR(sd_index_idr);
 static DEFINE_SPINLOCK(sd_index_lock);
@@ -136,20 +94,6 @@ static DEFINE_SPINLOCK(sd_index_lock);
  * object after last put) */
 static DEFINE_MUTEX(sd_ref_mutex);
 
-static int sd_revalidate_disk(struct gendisk *disk);
-static void sd_rw_intr(struct scsi_cmnd * SCpnt);
-
-static int sd_probe(struct device *);
-static int sd_remove(struct device *);
-static void sd_shutdown(struct device *dev);
-static void sd_rescan(struct device *);
-static int sd_init_command(struct scsi_cmnd *);
-static int sd_issue_flush(struct device *, sector_t *);
-static void sd_prepare_flush(request_queue_t *, struct request *);
-static void sd_read_capacity(struct scsi_disk *sdkp, char *diskname,
-                             unsigned char *buffer);
-static void scsi_disk_release(struct class_device *cdev);
-
 static const char *sd_cache_types[] = {
         "write through", "none", "write back",
         "write back, no read (daft)"
@@ -199,13 +143,27 @@ static ssize_t sd_store_cache_type(struct class_device *cdev, const char *buf,
         if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
                              SD_MAX_RETRIES, &data, &sshdr)) {
                 if (scsi_sense_valid(&sshdr))
-                        scsi_print_sense_hdr(sdkp->disk->disk_name, &sshdr);
+                        sd_print_sense_hdr(sdkp, &sshdr);
                 return -EINVAL;
         }
         sd_revalidate_disk(sdkp->disk);
         return count;
 }
 
+static ssize_t sd_store_manage_start_stop(struct class_device *cdev,
+                                          const char *buf, size_t count)
+{
+        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_device *sdp = sdkp->device;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
+
+        return count;
+}
+
 static ssize_t sd_store_allow_restart(struct class_device *cdev, const char *buf,
                                       size_t count)
 {
@@ -238,6 +196,14 @@ static ssize_t sd_show_fua(struct class_device *cdev, char *buf)
         return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
 }
 
+static ssize_t sd_show_manage_start_stop(struct class_device *cdev, char *buf)
+{
+        struct scsi_disk *sdkp = to_scsi_disk(cdev);
+        struct scsi_device *sdp = sdkp->device;
+
+        return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
+}
+
 static ssize_t sd_show_allow_restart(struct class_device *cdev, char *buf)
 {
         struct scsi_disk *sdkp = to_scsi_disk(cdev);
@@ -251,6 +217,8 @@ static struct class_device_attribute sd_disk_attrs[] = {
         __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
         __ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
                sd_store_allow_restart),
+        __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
+               sd_store_manage_start_stop),
         __ATTR_NULL,
 };
 
@@ -267,6 +235,8 @@ static struct scsi_driver sd_template = {
                 .name           = "sd",
                 .probe          = sd_probe,
                 .remove         = sd_remove,
+                .suspend        = sd_suspend,
+                .resume         = sd_resume,
                 .shutdown       = sd_shutdown,
         },
         .rescan                 = sd_rescan,
@@ -371,15 +341,19 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
         unsigned int this_count = SCpnt->request_bufflen >> 9;
         unsigned int timeout = sdp->timeout;
 
-        SCSI_LOG_HLQUEUE(1, printk("sd_init_command: disk=%s, block=%llu, "
-                            "count=%d\n", disk->disk_name,
-                         (unsigned long long)block, this_count));
+        SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
+                                        "sd_init_command: block=%llu, "
+                                        "count=%d\n",
+                                        (unsigned long long)block,
+                                        this_count));
 
         if (!sdp || !scsi_device_online(sdp) ||
             block + rq->nr_sectors > get_capacity(disk)) {
-                SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n", 
-                                 rq->nr_sectors));
-                SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%p\n", SCpnt));
+                SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
+                                                "Finishing %ld sectors\n",
+                                                rq->nr_sectors));
+                SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
+                                                "Retry with 0x%p\n", SCpnt));
                 return 0;
         }
 
@@ -391,8 +365,8 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
                 /* printk("SCSI disk has been changed. Prohibiting further I/O.\n"); */
                 return 0;
         }
-        SCSI_LOG_HLQUEUE(2, printk("%s : block=%llu\n",
-                                   disk->disk_name, (unsigned long long)block));
+        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
+                                        (unsigned long long)block));
 
         /*
          * If we have a 1K hardware sectorsize, prevent access to single
@@ -407,7 +381,8 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
          */
         if (sdp->sector_size == 1024) {
                 if ((block & 1) || (rq->nr_sectors & 1)) {
-                        printk(KERN_ERR "sd: Bad block number requested");
+                        scmd_printk(KERN_ERR, SCpnt,
+                                    "Bad block number requested\n");
                         return 0;
                 } else {
                         block = block >> 1;
@@ -416,7 +391,8 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
         }
         if (sdp->sector_size == 2048) {
                 if ((block & 3) || (rq->nr_sectors & 3)) {
-                        printk(KERN_ERR "sd: Bad block number requested");
+                        scmd_printk(KERN_ERR, SCpnt,
+                                    "Bad block number requested\n");
                         return 0;
                 } else {
                         block = block >> 2;
@@ -425,7 +401,8 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
         }
         if (sdp->sector_size == 4096) {
                 if ((block & 7) || (rq->nr_sectors & 7)) {
-                        printk(KERN_ERR "sd: Bad block number requested");
+                        scmd_printk(KERN_ERR, SCpnt,
+                                    "Bad block number requested\n");
                         return 0;
                 } else {
                         block = block >> 3;
@@ -442,13 +419,15 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
                 SCpnt->cmnd[0] = READ_6;
                 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
         } else {
-                printk(KERN_ERR "sd: Unknown command %x\n", rq->cmd_flags);
+                scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
                 return 0;
         }
 
-        SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%ld 512 byte blocks.\n", 
-                disk->disk_name, (rq_data_dir(rq) == WRITE) ? 
-                "writing" : "reading", this_count, rq->nr_sectors));
+        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
+                                        "%s %d/%ld 512 byte blocks.\n",
+                                        (rq_data_dir(rq) == WRITE) ?
+                                        "writing" : "reading", this_count,
+                                        rq->nr_sectors));
 
         SCpnt->cmnd[1] = 0;
         
@@ -490,7 +469,8 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
                          * during operation and thus turned off
                          * use_10_for_rw.
                          */
-                        printk(KERN_ERR "sd: FUA write on READ/WRITE(6) drive\n");
+                        scmd_printk(KERN_ERR, SCpnt,
+                                    "FUA write on READ/WRITE(6) drive\n");
                         return 0;
                 }
 
@@ -549,7 +529,7 @@ static int sd_open(struct inode *inode, struct file *filp)
                 return -ENXIO;
 
 
-        SCSI_LOG_HLQUEUE(3, printk("sd_open: disk=%s\n", disk->disk_name));
+        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
 
         sdev = sdkp->device;
 
@@ -619,7 +599,7 @@ static int sd_release(struct inode *inode, struct file *filp)
         struct scsi_disk *sdkp = scsi_disk(disk);
         struct scsi_device *sdev = sdkp->device;
 
-        SCSI_LOG_HLQUEUE(3, printk("sd_release: disk=%s\n", disk->disk_name));
+        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
 
         if (!--sdkp->openers && sdev->removable) {
                 if (scsi_block_when_processing_errors(sdev))
@@ -732,8 +712,7 @@ static int sd_media_changed(struct gendisk *disk)
         struct scsi_device *sdp = sdkp->device;
         int retval;
 
-        SCSI_LOG_HLQUEUE(3, printk("sd_media_changed: disk=%s\n",
-                                                disk->disk_name));
+        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_media_changed\n"));
 
         if (!sdp->removable)
                 return 0;
@@ -786,9 +765,10 @@ not_present:
         return 1;
 }
 
-static int sd_sync_cache(struct scsi_device *sdp)
+static int sd_sync_cache(struct scsi_disk *sdkp)
 {
         int retries, res;
+        struct scsi_device *sdp = sdkp->device;
         struct scsi_sense_hdr sshdr;
 
         if (!scsi_device_online(sdp))
@@ -809,28 +789,27 @@ static int sd_sync_cache(struct scsi_device *sdp)
                         break;
         }
 
-        if (res) {              printk(KERN_WARNING "FAILED\n  status = %x, message = %02x, "
-                                    "host = %d, driver = %02x\n  ",
-                                    status_byte(res), msg_byte(res),
-                                    host_byte(res), driver_byte(res));
-                        if (driver_byte(res) & DRIVER_SENSE)
-                                scsi_print_sense_hdr("sd", &sshdr);
+        if (res) {
+                sd_print_result(sdkp, res);
+                if (driver_byte(res) & DRIVER_SENSE)
+                        sd_print_sense_hdr(sdkp, &sshdr);
         }
 
-        return res;
+        if (res)
+                return -EIO;
+        return 0;
 }
 
 static int sd_issue_flush(struct device *dev, sector_t *error_sector)
 {
         int ret = 0;
-        struct scsi_device *sdp = to_scsi_device(dev);
         struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
 
         if (!sdkp)
                return -ENODEV;
 
         if (sdkp->WCE)
-                ret = sd_sync_cache(sdp);
+                ret = sd_sync_cache(sdkp);
         scsi_disk_put(sdkp);
         return ret;
 }
@@ -928,12 +907,14 @@ static void sd_rw_intr(struct scsi_cmnd * SCpnt)
                         sense_deferred = scsi_sense_is_deferred(&sshdr);
         }
 #ifdef CONFIG_SCSI_LOGGING
-        SCSI_LOG_HLCOMPLETE(1, printk("sd_rw_intr: %s: res=0x%x\n", 
-                                SCpnt->request->rq_disk->disk_name, result));
+        SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
         if (sense_valid) {
-                SCSI_LOG_HLCOMPLETE(1, printk("sd_rw_intr: sb[respc,sk,asc,"
-                                "ascq]=%x,%x,%x,%x\n", sshdr.response_code,
-                                sshdr.sense_key, sshdr.asc, sshdr.ascq));
+                SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
+                                                   "sd_rw_intr: sb[respc,sk,asc,"
+                                                   "ascq]=%x,%x,%x,%x\n",
+                                                   sshdr.response_code,
+                                                   sshdr.sense_key, sshdr.asc,
+                                                   sshdr.ascq));
         }
 #endif
         if (driver_byte(result) != DRIVER_SENSE &&
@@ -1025,7 +1006,7 @@ static int media_not_present(struct scsi_disk *sdkp,
  * spinup disk - called only in sd_revalidate_disk()
  */
 static void
-sd_spinup_disk(struct scsi_disk *sdkp, char *diskname)
+sd_spinup_disk(struct scsi_disk *sdkp)
 {
         unsigned char cmd[10];
         unsigned long spintime_expire = 0;
@@ -1069,9 +1050,10 @@ sd_spinup_disk(struct scsi_disk *sdkp, char *diskname)
                 if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
                         /* no sense, TUR either succeeded or failed
                          * with a status error */
-                        if(!spintime && !scsi_status_is_good(the_result))
-                                printk(KERN_NOTICE "%s: Unit Not Ready, "
-                                       "error = 0x%x\n", diskname, the_result);
+                        if(!spintime && !scsi_status_is_good(the_result)) {
+                                sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
+                                sd_print_result(sdkp, the_result);
+                        }
                         break;
                 }
                                         
@@ -1096,8 +1078,7 @@ sd_spinup_disk(struct scsi_disk *sdkp, char *diskname)
                  */
                 } else if (sense_valid && sshdr.sense_key == NOT_READY) {
                         if (!spintime) {
-                                printk(KERN_NOTICE "%s: Spinning up disk...",
-                                       diskname);
+                                sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
                                 cmd[0] = START_STOP;
                                 cmd[1] = 1;     /* Return immediately */
                                 memset((void *) &cmd[2], 0, 8);
@@ -1130,9 +1111,8 @@ sd_spinup_disk(struct scsi_disk *sdkp, char *diskname)
                         /* we don't understand the sense code, so it's
                          * probably pointless to loop */
                         if(!spintime) {
-                                printk(KERN_NOTICE "%s: Unit Not Ready, "
-                                        "sense:\n", diskname);
-                                scsi_print_sense_hdr("", &sshdr);
+                                sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
+                                sd_print_sense_hdr(sdkp, &sshdr);
                         }
                         break;
                 }
@@ -1151,8 +1131,7 @@ sd_spinup_disk(struct scsi_disk *sdkp, char *diskname)
  * read disk capacity
  */
 static void
-sd_read_capacity(struct scsi_disk *sdkp, char *diskname,
-                 unsigned char *buffer)
+sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
 {
         unsigned char cmd[16];
         int the_result, retries;
@@ -1191,18 +1170,12 @@ repeat:
         } while (the_result && retries);
 
         if (the_result && !longrc) {
-                printk(KERN_NOTICE "%s : READ CAPACITY failed.\n"
-                       "%s : status=%x, message=%02x, host=%d, driver=%02x \n",
-                       diskname, diskname,
-                       status_byte(the_result),
-                       msg_byte(the_result),
-                       host_byte(the_result),
-                       driver_byte(the_result));
-
+                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
+                sd_print_result(sdkp, the_result);
                 if (driver_byte(the_result) & DRIVER_SENSE)
-                        scsi_print_sense_hdr("sd", &sshdr);
+                        sd_print_sense_hdr(sdkp, &sshdr);
                 else
-                        printk("%s : sense not available. \n", diskname);
+                        sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
 
                 /* Set dirty bit for removable devices if not ready -
                  * sometimes drives will not report this properly. */
@@ -1218,16 +1191,10 @@ repeat:
                 return;
         } else if (the_result && longrc) {
                 /* READ CAPACITY(16) has been failed */
-                printk(KERN_NOTICE "%s : READ CAPACITY(16) failed.\n"
-                       "%s : status=%x, message=%02x, host=%d, driver=%02x \n",
-                       diskname, diskname,
-                       status_byte(the_result),
-                       msg_byte(the_result),
-                       host_byte(the_result),
-                       driver_byte(the_result));
-                printk(KERN_NOTICE "%s : use 0xffffffff as device size\n",
-                       diskname);
-                
+                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
+                sd_print_result(sdkp, the_result);
+                sd_printk(KERN_NOTICE, sdkp, "Use 0xffffffff as device size\n");
+
                 sdkp->capacity = 1 + (sector_t) 0xffffffff;             
                 goto got_data;
         }       
@@ -1238,14 +1205,14 @@ repeat:
                 if (buffer[0] == 0xff && buffer[1] == 0xff &&
                     buffer[2] == 0xff && buffer[3] == 0xff) {
                         if(sizeof(sdkp->capacity) > 4) {
-                                printk(KERN_NOTICE "%s : very big device. try to use"
-                                       " READ CAPACITY(16).\n", diskname);
+                                sd_printk(KERN_NOTICE, sdkp, "Very big device. "
+                                          "Trying to use READ CAPACITY(16).\n");
                                 longrc = 1;
                                 goto repeat;
                         }
-                        printk(KERN_ERR "%s: too big for this kernel.  Use a "
-                               "kernel compiled with support for large block "
-                               "devices.\n", diskname);
+                        sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use "
+                                  "a kernel compiled with support for large "
+                                  "block devices.\n");
                         sdkp->capacity = 0;
                         goto got_data;
                 }
@@ -1284,8 +1251,8 @@ repeat:
 got_data:
         if (sector_size == 0) {
                 sector_size = 512;
-                printk(KERN_NOTICE "%s : sector size 0 reported, "
-                       "assuming 512.\n", diskname);
+                sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
+                          "assuming 512.\n");
         }
 
         if (sector_size != 512 &&
@@ -1293,8 +1260,8 @@ got_data:
             sector_size != 2048 &&
             sector_size != 4096 &&
             sector_size != 256) {
-                printk(KERN_NOTICE "%s : unsupported sector size "
-                       "%d.\n", diskname, sector_size);
+                sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
+                          sector_size);
                 /*
                  * The user might want to re-format the drive with
                  * a supported sectorsize.  Once this happens, it
@@ -1327,10 +1294,10 @@ got_data:
                 mb -= sz - 974;
                 sector_div(mb, 1950);
 
-                printk(KERN_NOTICE "SCSI device %s: "
-                       "%llu %d-byte hdwr sectors (%llu MB)\n",
-                       diskname, (unsigned long long)sdkp->capacity,
-                       hard_sector, (unsigned long long)mb);
+                sd_printk(KERN_NOTICE, sdkp,
+                          "%llu %d-byte hardware sectors (%llu MB)\n",
+                          (unsigned long long)sdkp->capacity,
+                          hard_sector, (unsigned long long)mb);
         }
 
         /* Rescale capacity to 512-byte units */
@@ -1362,8 +1329,7 @@ sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
  * called with buffer of length SD_BUF_SIZE
  */
 static void
-sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
-                           unsigned char *buffer)
+sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
 {
         int res;
         struct scsi_device *sdp = sdkp->device;
@@ -1371,7 +1337,7 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
 
         set_disk_ro(sdkp->disk, 0);
         if (sdp->skip_ms_page_3f) {
-                printk(KERN_NOTICE "%s: assuming Write Enabled\n", diskname);
+                sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
                 return;
         }
 
@@ -1403,15 +1369,16 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
         }
 
         if (!scsi_status_is_good(res)) {
-                printk(KERN_WARNING
-                       "%s: test WP failed, assume Write Enabled\n", diskname);
+                sd_printk(KERN_WARNING, sdkp,
+                          "Test WP failed, assume Write Enabled\n");
         } else {
                 sdkp->write_prot = ((data.device_specific & 0x80) != 0);
                 set_disk_ro(sdkp->disk, sdkp->write_prot);
-                printk(KERN_NOTICE "%s: Write Protect is %s\n", diskname,
-                       sdkp->write_prot ? "on" : "off");
-                printk(KERN_DEBUG "%s: Mode Sense: %02x %02x %02x %02x\n",
-                       diskname, buffer[0], buffer[1], buffer[2], buffer[3]);
+                sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
+                          sdkp->write_prot ? "on" : "off");
+                sd_printk(KERN_DEBUG, sdkp,
+                          "Mode Sense: %02x %02x %02x %02x\n",
+                          buffer[0], buffer[1], buffer[2], buffer[3]);
         }
 }
 
@@ -1420,8 +1387,7 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, char *diskname,
  * called with buffer of length SD_BUF_SIZE
  */
 static void
-sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
-                   unsigned char *buffer)
+sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
 {
         int len = 0, res;
         struct scsi_device *sdp = sdkp->device;
@@ -1450,8 +1416,7 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
 
         if (!data.header_length) {
                 modepage = 6;
-                printk(KERN_ERR "%s: missing header in MODE_SENSE response\n",
-                       diskname);
+                sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
         }
 
         /* that went OK, now ask for the proper length */
@@ -1478,13 +1443,12 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
                 int offset = data.header_length + data.block_descriptor_length;
 
                 if (offset >= SD_BUF_SIZE - 2) {
-                        printk(KERN_ERR "%s: malformed MODE SENSE response",
-                                diskname);
+                        sd_printk(KERN_ERR, sdkp, "Malformed MODE SENSE response\n");
                         goto defaults;
                 }
 
                 if ((buffer[offset] & 0x3f) != modepage) {
-                        printk(KERN_ERR "%s: got wrong page\n", diskname);
+                        sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
                         goto defaults;
                 }
 
@@ -1498,14 +1462,13 @@ sd_read_cache_type(struct scsi_disk *sdkp, char *diskname,
 
                 sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
                 if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
-                        printk(KERN_NOTICE "SCSI device %s: uses "
-                               "READ/WRITE(6), disabling FUA\n", diskname);
+                        sd_printk(KERN_NOTICE, sdkp,
+                                  "Uses READ/WRITE(6), disabling FUA\n");
                         sdkp->DPOFUA = 0;
                 }
 
-                printk(KERN_NOTICE "SCSI device %s: "
-                       "write cache: %s, read cache: %s, %s\n",
-                       diskname,
+                sd_printk(KERN_NOTICE, sdkp,
+                       "Write cache: %s, read cache: %s, %s\n",
                        sdkp->WCE ? "enabled" : "disabled",
                        sdkp->RCD ? "disabled" : "enabled",
                        sdkp->DPOFUA ? "supports DPO and FUA"
@@ -1518,15 +1481,13 @@ bad_sense:
         if (scsi_sense_valid(&sshdr) &&
             sshdr.sense_key == ILLEGAL_REQUEST &&
             sshdr.asc == 0x24 && sshdr.ascq == 0x0)
-                printk(KERN_NOTICE "%s: cache data unavailable\n",
-                       diskname);       /* Invalid field in CDB */
+                /* Invalid field in CDB */
+                sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
         else
-                printk(KERN_ERR "%s: asking for cache data failed\n",
-                       diskname);
+                sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
 
 defaults:
-        printk(KERN_ERR "%s: assuming drive cache: write through\n",
-               diskname);
+        sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
         sdkp->WCE = 0;
         sdkp->RCD = 0;
         sdkp->DPOFUA = 0;
@@ -1544,7 +1505,8 @@ static int sd_revalidate_disk(struct gendisk *disk)
         unsigned char *buffer;
         unsigned ordered;
 
-        SCSI_LOG_HLQUEUE(3, printk("sd_revalidate_disk: disk=%s\n", disk->disk_name));
+        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
+                                      "sd_revalidate_disk\n"));
 
         /*
          * If the device is offline, don't try and read capacity or any
@@ -1555,8 +1517,8 @@ static int sd_revalidate_disk(struct gendisk *disk)
 
         buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL | __GFP_DMA);
         if (!buffer) {
-                printk(KERN_WARNING "(sd_revalidate_disk:) Memory allocation "
-                       "failure.\n");
+                sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
+                          "allocation failure.\n");
                 goto out;
         }
 
@@ -1568,16 +1530,16 @@ static int sd_revalidate_disk(struct gendisk *disk)
         sdkp->WCE = 0;
         sdkp->RCD = 0;
 
-        sd_spinup_disk(sdkp, disk->disk_name);
+        sd_spinup_disk(sdkp);
 
         /*
          * Without media there is no reason to ask; moreover, some devices
          * react badly if we do.
          */
         if (sdkp->media_present) {
-                sd_read_capacity(sdkp, disk->disk_name, buffer);
-                sd_read_write_protect_flag(sdkp, disk->disk_name, buffer);
-                sd_read_cache_type(sdkp, disk->disk_name, buffer);
+                sd_read_capacity(sdkp, buffer);
+                sd_read_write_protect_flag(sdkp, buffer);
+                sd_read_cache_type(sdkp, buffer);
         }
 
         /*
@@ -1709,8 +1671,8 @@ static int sd_probe(struct device *dev)
         dev_set_drvdata(dev, sdkp);
         add_disk(gd);
 
-        sdev_printk(KERN_NOTICE, sdp, "Attached scsi %sdisk %s\n",
-                    sdp->removable ? "removable " : "", gd->disk_name);
+        sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
+                  sdp->removable ? "removable " : "");
 
         return 0;
 
@@ -1774,6 +1736,31 @@ static void scsi_disk_release(struct class_device *cdev)
         kfree(sdkp);
 }
 
+static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
+{
+        unsigned char cmd[6] = { START_STOP };  /* START_VALID */
+        struct scsi_sense_hdr sshdr;
+        struct scsi_device *sdp = sdkp->device;
+        int res;
+
+        if (start)
+                cmd[4] |= 1;    /* START */
+
+        if (!scsi_device_online(sdp))
+                return -ENODEV;
+
+        res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
+                               SD_TIMEOUT, SD_MAX_RETRIES);
+        if (res) {
+                sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
+                sd_print_result(sdkp, res);
+                if (driver_byte(res) & DRIVER_SENSE)
+                        sd_print_sense_hdr(sdkp, &sshdr);
+        }
+
+        return res;
+}
+
 /*
  * Send a SYNCHRONIZE CACHE instruction down to the device through
  * the normal SCSI command structure.  Wait for the command to
@@ -1781,20 +1768,62 @@ static void scsi_disk_release(struct class_device *cdev)
  */
 static void sd_shutdown(struct device *dev)
 {
-        struct scsi_device *sdp = to_scsi_device(dev);
         struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
 
         if (!sdkp)
                 return;         /* this can happen */
 
         if (sdkp->WCE) {
-                printk(KERN_NOTICE "Synchronizing SCSI cache for disk %s: \n",
-                                sdkp->disk->disk_name);
-                sd_sync_cache(sdp);
+                sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
+                sd_sync_cache(sdkp);
+        }
+
+        if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
+                sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
+                sd_start_stop_device(sdkp, 0);
         }
+
         scsi_disk_put(sdkp);
 }
 
+static int sd_suspend(struct device *dev, pm_message_t mesg)
+{
+        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
+        int ret;
+
+        if (!sdkp)
+                return 0;       /* this can happen */
+
+        if (sdkp->WCE) {
+                sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
+                ret = sd_sync_cache(sdkp);
+                if (ret)
+                        return ret;
+        }
+
+        if (mesg.event == PM_EVENT_SUSPEND &&
+            sdkp->device->manage_start_stop) {
+                sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
+                ret = sd_start_stop_device(sdkp, 0);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static int sd_resume(struct device *dev)
+{
+        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
+
+        if (!sdkp->device->manage_start_stop)
+                return 0;
+
+        sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
+
+        return sd_start_stop_device(sdkp, 1);
+}
+
 /**
  *      init_sd - entry point for this driver (both when built in or when
  *      a module).
@@ -1852,3 +1881,19 @@ static void __exit exit_sd(void)
 
 module_init(init_sd);
 module_exit(exit_sd);
+
+static void sd_print_sense_hdr(struct scsi_disk *sdkp,
+                               struct scsi_sense_hdr *sshdr)
+{
+        sd_printk(KERN_INFO, sdkp, "");
+        scsi_show_sense_hdr(sshdr);
+        sd_printk(KERN_INFO, sdkp, "");
+        scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
+}
+
+static void sd_print_result(struct scsi_disk *sdkp, int result)
+{
+        sd_printk(KERN_INFO, sdkp, "");
+        scsi_show_result(result);
+}
+