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