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