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 if (sense_valid && sshdr.sense_key == NOT_READY) { 1174 if (sshdr.asc == 4 && sshdr.ascq == 3) 1175 break; /* manual intervention required */ 1176 if (sshdr.asc == 4 && sshdr.ascq == 0xb) 1177 break; /* standby */ 1178 if (sshdr.asc == 4 && sshdr.ascq == 0xc) 1179 break; /* unavailable */ 1180 /* 1181 * Issue command to spin up drive when not ready 1182 */ 1183 if (!spintime) { 1184 sd_printk(KERN_NOTICE, sdkp, "Spinning up disk..."); 1185 cmd[0] = START_STOP; 1186 cmd[1] = 1; /* Return immediately */ 1187 memset((void *) &cmd[2], 0, 8); 1188 cmd[4] = 1; /* Start spin cycle */ 1189 if (sdkp->device->start_stop_pwr_cond) 1190 cmd[4] |= 1 << 4; 1191 scsi_execute_req(sdkp->device, cmd, DMA_NONE, 1192 NULL, 0, &sshdr, 1193 SD_TIMEOUT, SD_MAX_RETRIES, 1194 NULL); 1195 spintime_expire = jiffies + 100 * HZ; 1196 spintime = 1; 1197 } 1198 /* Wait 1 second for next try */ 1199 msleep(1000); 1200 printk("."); 1201 1202 /* 1203 * Wait for USB flash devices with slow firmware. 1204 * Yes, this sense key/ASC combination shouldn't 1205 * occur here. It's characteristic of these devices. 1206 */ 1207 } else if (sense_valid && 1208 sshdr.sense_key == UNIT_ATTENTION && 1209 sshdr.asc == 0x28) { 1210 if (!spintime) { 1211 spintime_expire = jiffies + 5 * HZ; 1212 spintime = 1; 1213 } 1214 /* Wait 1 second for next try */ 1215 msleep(1000); 1216 } else { 1217 /* we don't understand the sense code, so it's 1218 * probably pointless to loop */ 1219 if(!spintime) { 1220 sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n"); 1221 sd_print_sense_hdr(sdkp, &sshdr); 1222 } 1223 break; 1224 } 1225 1226 } while (spintime && time_before_eq(jiffies, spintime_expire)); 1227 1228 if (spintime) { 1229 if (scsi_status_is_good(the_result)) 1230 printk("ready\n"); 1231 else 1232 printk("not responding...\n"); 1233 } 1234 } 1235 1236 1237 /* 1238 * Determine whether disk supports Data Integrity Field. 1239 */ 1240 void sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer) 1241 { 1242 struct scsi_device *sdp = sdkp->device; 1243 u8 type; 1244 1245 if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0) 1246 type = 0; 1247 else 1248 type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */ 1249 1250 sdkp->protection_type = type; 1251 1252 switch (type) { 1253 case SD_DIF_TYPE0_PROTECTION: 1254 case SD_DIF_TYPE1_PROTECTION: 1255 case SD_DIF_TYPE3_PROTECTION: 1256 break; 1257 1258 case SD_DIF_TYPE2_PROTECTION: 1259 sd_printk(KERN_ERR, sdkp, "formatted with DIF Type 2 " \ 1260 "protection which is currently unsupported. " \ 1261 "Disabling disk!\n"); 1262 goto disable; 1263 1264 default: 1265 sd_printk(KERN_ERR, sdkp, "formatted with unknown " \ 1266 "protection type %d. Disabling disk!\n", type); 1267 goto disable; 1268 } 1269 1270 return; 1271 1272 disable: 1273 sdkp->capacity = 0; 1274 } 1275 1276 /* 1277 * read disk capacity 1278 */ 1279 static void 1280 sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer) 1281 { 1282 unsigned char cmd[16]; 1283 int the_result, retries; 1284 int sector_size = 0; 1285 /* Force READ CAPACITY(16) when PROTECT=1 */ 1286 int longrc = scsi_device_protection(sdkp->device) ? 1 : 0; 1287 struct scsi_sense_hdr sshdr; 1288 int sense_valid = 0; 1289 struct scsi_device *sdp = sdkp->device; 1290 1291 repeat: 1292 retries = 3; 1293 do { 1294 if (longrc) { 1295 memset((void *) cmd, 0, 16); 1296 cmd[0] = SERVICE_ACTION_IN; 1297 cmd[1] = SAI_READ_CAPACITY_16; 1298 cmd[13] = 13; 1299 memset((void *) buffer, 0, 13); 1300 } else { 1301 cmd[0] = READ_CAPACITY; 1302 memset((void *) &cmd[1], 0, 9); 1303 memset((void *) buffer, 0, 8); 1304 } 1305 1306 the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE, 1307 buffer, longrc ? 13 : 8, &sshdr, 1308 SD_TIMEOUT, SD_MAX_RETRIES, NULL); 1309 1310 if (media_not_present(sdkp, &sshdr)) 1311 return; 1312 1313 if (the_result) 1314 sense_valid = scsi_sense_valid(&sshdr); 1315 retries--; 1316 1317 } while (the_result && retries); 1318 1319 if (the_result && !longrc) { 1320 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n"); 1321 sd_print_result(sdkp, the_result); 1322 if (driver_byte(the_result) & DRIVER_SENSE) 1323 sd_print_sense_hdr(sdkp, &sshdr); 1324 else 1325 sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n"); 1326 1327 /* Set dirty bit for removable devices if not ready - 1328 * sometimes drives will not report this properly. */ 1329 if (sdp->removable && 1330 sense_valid && sshdr.sense_key == NOT_READY) 1331 sdp->changed = 1; 1332 1333 /* Either no media are present but the drive didn't tell us, 1334 or they are present but the read capacity command fails */ 1335 /* sdkp->media_present = 0; -- not always correct */ 1336 sdkp->capacity = 0; /* unknown mapped to zero - as usual */ 1337 1338 return; 1339 } else if (the_result && longrc) { 1340 /* READ CAPACITY(16) has been failed */ 1341 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n"); 1342 sd_print_result(sdkp, the_result); 1343 sd_printk(KERN_NOTICE, sdkp, "Use 0xffffffff as device size\n"); 1344 1345 sdkp->capacity = 1 + (sector_t) 0xffffffff; 1346 goto got_data; 1347 } 1348 1349 if (!longrc) { 1350 sector_size = (buffer[4] << 24) | 1351 (buffer[5] << 16) | (buffer[6] << 8) | buffer[7]; 1352 if (buffer[0] == 0xff && buffer[1] == 0xff && 1353 buffer[2] == 0xff && buffer[3] == 0xff) { 1354 if(sizeof(sdkp->capacity) > 4) { 1355 sd_printk(KERN_NOTICE, sdkp, "Very big device. " 1356 "Trying to use READ CAPACITY(16).\n"); 1357 longrc = 1; 1358 goto repeat; 1359 } 1360 sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use " 1361 "a kernel compiled with support for large " 1362 "block devices.\n"); 1363 sdkp->capacity = 0; 1364 goto got_data; 1365 } 1366 sdkp->capacity = 1 + (((sector_t)buffer[0] << 24) | 1367 (buffer[1] << 16) | 1368 (buffer[2] << 8) | 1369 buffer[3]); 1370 } else { 1371 sdkp->capacity = 1 + (((u64)buffer[0] << 56) | 1372 ((u64)buffer[1] << 48) | 1373 ((u64)buffer[2] << 40) | 1374 ((u64)buffer[3] << 32) | 1375 ((sector_t)buffer[4] << 24) | 1376 ((sector_t)buffer[5] << 16) | 1377 ((sector_t)buffer[6] << 8) | 1378 (sector_t)buffer[7]); 1379 1380 sector_size = (buffer[8] << 24) | 1381 (buffer[9] << 16) | (buffer[10] << 8) | buffer[11]; 1382 1383 sd_read_protection_type(sdkp, buffer); 1384 } 1385 1386 /* Some devices return the total number of sectors, not the 1387 * highest sector number. Make the necessary adjustment. */ 1388 if (sdp->fix_capacity) { 1389 --sdkp->capacity; 1390 1391 /* Some devices have version which report the correct sizes 1392 * and others which do not. We guess size according to a heuristic 1393 * and err on the side of lowering the capacity. */ 1394 } else { 1395 if (sdp->guess_capacity) 1396 if (sdkp->capacity & 0x01) /* odd sizes are odd */ 1397 --sdkp->capacity; 1398 } 1399 1400 got_data: 1401 if (sector_size == 0) { 1402 sector_size = 512; 1403 sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, " 1404 "assuming 512.\n"); 1405 } 1406 1407 if (sector_size != 512 && 1408 sector_size != 1024 && 1409 sector_size != 2048 && 1410 sector_size != 4096 && 1411 sector_size != 256) { 1412 sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n", 1413 sector_size); 1414 /* 1415 * The user might want to re-format the drive with 1416 * a supported sectorsize. Once this happens, it 1417 * would be relatively trivial to set the thing up. 1418 * For this reason, we leave the thing in the table. 1419 */ 1420 sdkp->capacity = 0; 1421 /* 1422 * set a bogus sector size so the normal read/write 1423 * logic in the block layer will eventually refuse any 1424 * request on this device without tripping over power 1425 * of two sector size assumptions 1426 */ 1427 sector_size = 512; 1428 } 1429 blk_queue_hardsect_size(sdp->request_queue, sector_size); 1430 1431 { 1432 char cap_str_2[10], cap_str_10[10]; 1433 u64 sz = (u64)sdkp->capacity << ilog2(sector_size); 1434 1435 string_get_size(sz, STRING_UNITS_2, cap_str_2, 1436 sizeof(cap_str_2)); 1437 string_get_size(sz, STRING_UNITS_10, cap_str_10, 1438 sizeof(cap_str_10)); 1439 1440 sd_printk(KERN_NOTICE, sdkp, 1441 "%llu %d-byte hardware sectors: (%s/%s)\n", 1442 (unsigned long long)sdkp->capacity, 1443 sector_size, cap_str_10, cap_str_2); 1444 } 1445 1446 /* Rescale capacity to 512-byte units */ 1447 if (sector_size == 4096) 1448 sdkp->capacity <<= 3; 1449 else if (sector_size == 2048) 1450 sdkp->capacity <<= 2; 1451 else if (sector_size == 1024) 1452 sdkp->capacity <<= 1; 1453 else if (sector_size == 256) 1454 sdkp->capacity >>= 1; 1455 1456 sdkp->device->sector_size = sector_size; 1457 } 1458 1459 /* called with buffer of length 512 */ 1460 static inline int 1461 sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage, 1462 unsigned char *buffer, int len, struct scsi_mode_data *data, 1463 struct scsi_sense_hdr *sshdr) 1464 { 1465 return scsi_mode_sense(sdp, dbd, modepage, buffer, len, 1466 SD_TIMEOUT, SD_MAX_RETRIES, data, 1467 sshdr); 1468 } 1469 1470 /* 1471 * read write protect setting, if possible - called only in sd_revalidate_disk() 1472 * called with buffer of length SD_BUF_SIZE 1473 */ 1474 static void 1475 sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer) 1476 { 1477 int res; 1478 struct scsi_device *sdp = sdkp->device; 1479 struct scsi_mode_data data; 1480 1481 set_disk_ro(sdkp->disk, 0); 1482 if (sdp->skip_ms_page_3f) { 1483 sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n"); 1484 return; 1485 } 1486 1487 if (sdp->use_192_bytes_for_3f) { 1488 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL); 1489 } else { 1490 /* 1491 * First attempt: ask for all pages (0x3F), but only 4 bytes. 1492 * We have to start carefully: some devices hang if we ask 1493 * for more than is available. 1494 */ 1495 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL); 1496 1497 /* 1498 * Second attempt: ask for page 0 When only page 0 is 1499 * implemented, a request for page 3F may return Sense Key 1500 * 5: Illegal Request, Sense Code 24: Invalid field in 1501 * CDB. 1502 */ 1503 if (!scsi_status_is_good(res)) 1504 res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL); 1505 1506 /* 1507 * Third attempt: ask 255 bytes, as we did earlier. 1508 */ 1509 if (!scsi_status_is_good(res)) 1510 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255, 1511 &data, NULL); 1512 } 1513 1514 if (!scsi_status_is_good(res)) { 1515 sd_printk(KERN_WARNING, sdkp, 1516 "Test WP failed, assume Write Enabled\n"); 1517 } else { 1518 sdkp->write_prot = ((data.device_specific & 0x80) != 0); 1519 set_disk_ro(sdkp->disk, sdkp->write_prot); 1520 sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n", 1521 sdkp->write_prot ? "on" : "off"); 1522 sd_printk(KERN_DEBUG, sdkp, 1523 "Mode Sense: %02x %02x %02x %02x\n", 1524 buffer[0], buffer[1], buffer[2], buffer[3]); 1525 } 1526 } 1527 1528 /* 1529 * sd_read_cache_type - called only from sd_revalidate_disk() 1530 * called with buffer of length SD_BUF_SIZE 1531 */ 1532 static void 1533 sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer) 1534 { 1535 int len = 0, res; 1536 struct scsi_device *sdp = sdkp->device; 1537 1538 int dbd; 1539 int modepage; 1540 struct scsi_mode_data data; 1541 struct scsi_sense_hdr sshdr; 1542 1543 if (sdp->skip_ms_page_8) 1544 goto defaults; 1545 1546 if (sdp->type == TYPE_RBC) { 1547 modepage = 6; 1548 dbd = 8; 1549 } else { 1550 modepage = 8; 1551 dbd = 0; 1552 } 1553 1554 /* cautiously ask */ 1555 res = sd_do_mode_sense(sdp, dbd, modepage, buffer, 4, &data, &sshdr); 1556 1557 if (!scsi_status_is_good(res)) 1558 goto bad_sense; 1559 1560 if (!data.header_length) { 1561 modepage = 6; 1562 sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n"); 1563 } 1564 1565 /* that went OK, now ask for the proper length */ 1566 len = data.length; 1567 1568 /* 1569 * We're only interested in the first three bytes, actually. 1570 * But the data cache page is defined for the first 20. 1571 */ 1572 if (len < 3) 1573 goto bad_sense; 1574 if (len > 20) 1575 len = 20; 1576 1577 /* Take headers and block descriptors into account */ 1578 len += data.header_length + data.block_descriptor_length; 1579 if (len > SD_BUF_SIZE) 1580 goto bad_sense; 1581 1582 /* Get the data */ 1583 res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr); 1584 1585 if (scsi_status_is_good(res)) { 1586 int offset = data.header_length + data.block_descriptor_length; 1587 1588 if (offset >= SD_BUF_SIZE - 2) { 1589 sd_printk(KERN_ERR, sdkp, "Malformed MODE SENSE response\n"); 1590 goto defaults; 1591 } 1592 1593 if ((buffer[offset] & 0x3f) != modepage) { 1594 sd_printk(KERN_ERR, sdkp, "Got wrong page\n"); 1595 goto defaults; 1596 } 1597 1598 if (modepage == 8) { 1599 sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0); 1600 sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0); 1601 } else { 1602 sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0); 1603 sdkp->RCD = 0; 1604 } 1605 1606 sdkp->DPOFUA = (data.device_specific & 0x10) != 0; 1607 if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) { 1608 sd_printk(KERN_NOTICE, sdkp, 1609 "Uses READ/WRITE(6), disabling FUA\n"); 1610 sdkp->DPOFUA = 0; 1611 } 1612 1613 sd_printk(KERN_NOTICE, sdkp, 1614 "Write cache: %s, read cache: %s, %s\n", 1615 sdkp->WCE ? "enabled" : "disabled", 1616 sdkp->RCD ? "disabled" : "enabled", 1617 sdkp->DPOFUA ? "supports DPO and FUA" 1618 : "doesn't support DPO or FUA"); 1619 1620 return; 1621 } 1622 1623 bad_sense: 1624 if (scsi_sense_valid(&sshdr) && 1625 sshdr.sense_key == ILLEGAL_REQUEST && 1626 sshdr.asc == 0x24 && sshdr.ascq == 0x0) 1627 /* Invalid field in CDB */ 1628 sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n"); 1629 else 1630 sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n"); 1631 1632 defaults: 1633 sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n"); 1634 sdkp->WCE = 0; 1635 sdkp->RCD = 0; 1636 sdkp->DPOFUA = 0; 1637 } 1638 1639 /* 1640 * The ATO bit indicates whether the DIF application tag is available 1641 * for use by the operating system. 1642 */ 1643 void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer) 1644 { 1645 int res, offset; 1646 struct scsi_device *sdp = sdkp->device; 1647 struct scsi_mode_data data; 1648 struct scsi_sense_hdr sshdr; 1649 1650 if (sdp->type != TYPE_DISK) 1651 return; 1652 1653 if (sdkp->protection_type == 0) 1654 return; 1655 1656 res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT, 1657 SD_MAX_RETRIES, &data, &sshdr); 1658 1659 if (!scsi_status_is_good(res) || !data.header_length || 1660 data.length < 6) { 1661 sd_printk(KERN_WARNING, sdkp, 1662 "getting Control mode page failed, assume no ATO\n"); 1663 1664 if (scsi_sense_valid(&sshdr)) 1665 sd_print_sense_hdr(sdkp, &sshdr); 1666 1667 return; 1668 } 1669 1670 offset = data.header_length + data.block_descriptor_length; 1671 1672 if ((buffer[offset] & 0x3f) != 0x0a) { 1673 sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n"); 1674 return; 1675 } 1676 1677 if ((buffer[offset + 5] & 0x80) == 0) 1678 return; 1679 1680 sdkp->ATO = 1; 1681 1682 return; 1683 } 1684 1685 /** 1686 * sd_revalidate_disk - called the first time a new disk is seen, 1687 * performs disk spin up, read_capacity, etc. 1688 * @disk: struct gendisk we care about 1689 **/ 1690 static int sd_revalidate_disk(struct gendisk *disk) 1691 { 1692 struct scsi_disk *sdkp = scsi_disk(disk); 1693 struct scsi_device *sdp = sdkp->device; 1694 unsigned char *buffer; 1695 unsigned ordered; 1696 1697 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, 1698 "sd_revalidate_disk\n")); 1699 1700 /* 1701 * If the device is offline, don't try and read capacity or any 1702 * of the other niceties. 1703 */ 1704 if (!scsi_device_online(sdp)) 1705 goto out; 1706 1707 buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL); 1708 if (!buffer) { 1709 sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory " 1710 "allocation failure.\n"); 1711 goto out; 1712 } 1713 1714 /* defaults, until the device tells us otherwise */ 1715 sdp->sector_size = 512; 1716 sdkp->capacity = 0; 1717 sdkp->media_present = 1; 1718 sdkp->write_prot = 0; 1719 sdkp->WCE = 0; 1720 sdkp->RCD = 0; 1721 sdkp->ATO = 0; 1722 1723 sd_spinup_disk(sdkp); 1724 1725 /* 1726 * Without media there is no reason to ask; moreover, some devices 1727 * react badly if we do. 1728 */ 1729 if (sdkp->media_present) { 1730 sd_read_capacity(sdkp, buffer); 1731 sd_read_write_protect_flag(sdkp, buffer); 1732 sd_read_cache_type(sdkp, buffer); 1733 sd_read_app_tag_own(sdkp, buffer); 1734 } 1735 1736 /* 1737 * We now have all cache related info, determine how we deal 1738 * with ordered requests. Note that as the current SCSI 1739 * dispatch function can alter request order, we cannot use 1740 * QUEUE_ORDERED_TAG_* even when ordered tag is supported. 1741 */ 1742 if (sdkp->WCE) 1743 ordered = sdkp->DPOFUA 1744 ? QUEUE_ORDERED_DRAIN_FUA : QUEUE_ORDERED_DRAIN_FLUSH; 1745 else 1746 ordered = QUEUE_ORDERED_DRAIN; 1747 1748 blk_queue_ordered(sdkp->disk->queue, ordered, sd_prepare_flush); 1749 1750 set_capacity(disk, sdkp->capacity); 1751 kfree(buffer); 1752 1753 out: 1754 return 0; 1755 } 1756 1757 /** 1758 * sd_format_disk_name - format disk name 1759 * @prefix: name prefix - ie. "sd" for SCSI disks 1760 * @index: index of the disk to format name for 1761 * @buf: output buffer 1762 * @buflen: length of the output buffer 1763 * 1764 * SCSI disk names starts at sda. The 26th device is sdz and the 1765 * 27th is sdaa. The last one for two lettered suffix is sdzz 1766 * which is followed by sdaaa. 1767 * 1768 * This is basically 26 base counting with one extra 'nil' entry 1769 * at the beggining from the second digit on and can be 1770 * determined using similar method as 26 base conversion with the 1771 * index shifted -1 after each digit is computed. 1772 * 1773 * CONTEXT: 1774 * Don't care. 1775 * 1776 * RETURNS: 1777 * 0 on success, -errno on failure. 1778 */ 1779 static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen) 1780 { 1781 const int base = 'z' - 'a' + 1; 1782 char *begin = buf + strlen(prefix); 1783 char *end = buf + buflen; 1784 char *p; 1785 int unit; 1786 1787 p = end - 1; 1788 *p = '\0'; 1789 unit = base; 1790 do { 1791 if (p == begin) 1792 return -EINVAL; 1793 *--p = 'a' + (index % unit); 1794 index = (index / unit) - 1; 1795 } while (index >= 0); 1796 1797 memmove(begin, p, end - p); 1798 memcpy(buf, prefix, strlen(prefix)); 1799 1800 return 0; 1801 } 1802 1803 /* 1804 * The asynchronous part of sd_probe 1805 */ 1806 static void sd_probe_async(void *data, async_cookie_t cookie) 1807 { 1808 struct scsi_disk *sdkp = data; 1809 struct scsi_device *sdp; 1810 struct gendisk *gd; 1811 u32 index; 1812 struct device *dev; 1813 1814 sdp = sdkp->device; 1815 gd = sdkp->disk; 1816 index = sdkp->index; 1817 dev = &sdp->sdev_gendev; 1818 1819 if (!sdp->request_queue->rq_timeout) { 1820 if (sdp->type != TYPE_MOD) 1821 blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT); 1822 else 1823 blk_queue_rq_timeout(sdp->request_queue, 1824 SD_MOD_TIMEOUT); 1825 } 1826 1827 device_initialize(&sdkp->dev); 1828 sdkp->dev.parent = &sdp->sdev_gendev; 1829 sdkp->dev.class = &sd_disk_class; 1830 dev_set_name(&sdkp->dev, dev_name(&sdp->sdev_gendev)); 1831 1832 if (device_add(&sdkp->dev)) 1833 goto out_free_index; 1834 1835 get_device(&sdp->sdev_gendev); 1836 1837 if (index < SD_MAX_DISKS) { 1838 gd->major = sd_major((index & 0xf0) >> 4); 1839 gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00); 1840 gd->minors = SD_MINORS; 1841 } 1842 gd->fops = &sd_fops; 1843 gd->private_data = &sdkp->driver; 1844 gd->queue = sdkp->device->request_queue; 1845 1846 sd_revalidate_disk(gd); 1847 1848 blk_queue_prep_rq(sdp->request_queue, sd_prep_fn); 1849 1850 gd->driverfs_dev = &sdp->sdev_gendev; 1851 gd->flags = GENHD_FL_EXT_DEVT | GENHD_FL_DRIVERFS; 1852 if (sdp->removable) 1853 gd->flags |= GENHD_FL_REMOVABLE; 1854 1855 dev_set_drvdata(dev, sdkp); 1856 add_disk(gd); 1857 sd_dif_config_host(sdkp); 1858 1859 sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n", 1860 sdp->removable ? "removable " : ""); 1861 1862 return; 1863 1864 out_free_index: 1865 ida_remove(&sd_index_ida, index); 1866 } 1867 1868 /** 1869 * sd_probe - called during driver initialization and whenever a 1870 * new scsi device is attached to the system. It is called once 1871 * for each scsi device (not just disks) present. 1872 * @dev: pointer to device object 1873 * 1874 * Returns 0 if successful (or not interested in this scsi device 1875 * (e.g. scanner)); 1 when there is an error. 1876 * 1877 * Note: this function is invoked from the scsi mid-level. 1878 * This function sets up the mapping between a given 1879 * <host,channel,id,lun> (found in sdp) and new device name 1880 * (e.g. /dev/sda). More precisely it is the block device major 1881 * and minor number that is chosen here. 1882 * 1883 * Assume sd_attach is not re-entrant (for time being) 1884 * Also think about sd_attach() and sd_remove() running coincidentally. 1885 **/ 1886 static int sd_probe(struct device *dev) 1887 { 1888 struct scsi_device *sdp = to_scsi_device(dev); 1889 struct scsi_disk *sdkp; 1890 struct gendisk *gd; 1891 u32 index; 1892 int error; 1893 1894 error = -ENODEV; 1895 if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC) 1896 goto out; 1897 1898 SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp, 1899 "sd_attach\n")); 1900 1901 error = -ENOMEM; 1902 sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL); 1903 if (!sdkp) 1904 goto out; 1905 1906 gd = alloc_disk(SD_MINORS); 1907 if (!gd) 1908 goto out_free; 1909 1910 do { 1911 if (!ida_pre_get(&sd_index_ida, GFP_KERNEL)) 1912 goto out_put; 1913 1914 spin_lock(&sd_index_lock); 1915 error = ida_get_new(&sd_index_ida, &index); 1916 spin_unlock(&sd_index_lock); 1917 } while (error == -EAGAIN); 1918 1919 if (error) 1920 goto out_put; 1921 1922 error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN); 1923 if (error) 1924 goto out_free_index; 1925 1926 sdkp->device = sdp; 1927 sdkp->driver = &sd_template; 1928 sdkp->disk = gd; 1929 sdkp->index = index; 1930 sdkp->openers = 0; 1931 sdkp->previous_state = 1; 1932 1933 async_schedule(sd_probe_async, sdkp); 1934 1935 return 0; 1936 1937 out_free_index: 1938 spin_lock(&sd_index_lock); 1939 ida_remove(&sd_index_ida, index); 1940 spin_unlock(&sd_index_lock); 1941 out_put: 1942 put_disk(gd); 1943 out_free: 1944 kfree(sdkp); 1945 out: 1946 return error; 1947 } 1948 1949 /** 1950 * sd_remove - called whenever a scsi disk (previously recognized by 1951 * sd_probe) is detached from the system. It is called (potentially 1952 * multiple times) during sd module unload. 1953 * @sdp: pointer to mid level scsi device object 1954 * 1955 * Note: this function is invoked from the scsi mid-level. 1956 * This function potentially frees up a device name (e.g. /dev/sdc) 1957 * that could be re-used by a subsequent sd_probe(). 1958 * This function is not called when the built-in sd driver is "exit-ed". 1959 **/ 1960 static int sd_remove(struct device *dev) 1961 { 1962 struct scsi_disk *sdkp = dev_get_drvdata(dev); 1963 1964 device_del(&sdkp->dev); 1965 del_gendisk(sdkp->disk); 1966 sd_shutdown(dev); 1967 1968 mutex_lock(&sd_ref_mutex); 1969 dev_set_drvdata(dev, NULL); 1970 put_device(&sdkp->dev); 1971 mutex_unlock(&sd_ref_mutex); 1972 1973 return 0; 1974 } 1975 1976 /** 1977 * scsi_disk_release - Called to free the scsi_disk structure 1978 * @dev: pointer to embedded class device 1979 * 1980 * sd_ref_mutex must be held entering this routine. Because it is 1981 * called on last put, you should always use the scsi_disk_get() 1982 * scsi_disk_put() helpers which manipulate the semaphore directly 1983 * and never do a direct put_device. 1984 **/ 1985 static void scsi_disk_release(struct device *dev) 1986 { 1987 struct scsi_disk *sdkp = to_scsi_disk(dev); 1988 struct gendisk *disk = sdkp->disk; 1989 1990 spin_lock(&sd_index_lock); 1991 ida_remove(&sd_index_ida, sdkp->index); 1992 spin_unlock(&sd_index_lock); 1993 1994 disk->private_data = NULL; 1995 put_disk(disk); 1996 put_device(&sdkp->device->sdev_gendev); 1997 1998 kfree(sdkp); 1999 } 2000 2001 static int sd_start_stop_device(struct scsi_disk *sdkp, int start) 2002 { 2003 unsigned char cmd[6] = { START_STOP }; /* START_VALID */ 2004 struct scsi_sense_hdr sshdr; 2005 struct scsi_device *sdp = sdkp->device; 2006 int res; 2007 2008 if (start) 2009 cmd[4] |= 1; /* START */ 2010 2011 if (sdp->start_stop_pwr_cond) 2012 cmd[4] |= start ? 1 << 4 : 3 << 4; /* Active or Standby */ 2013 2014 if (!scsi_device_online(sdp)) 2015 return -ENODEV; 2016 2017 res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr, 2018 SD_TIMEOUT, SD_MAX_RETRIES, NULL); 2019 if (res) { 2020 sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n"); 2021 sd_print_result(sdkp, res); 2022 if (driver_byte(res) & DRIVER_SENSE) 2023 sd_print_sense_hdr(sdkp, &sshdr); 2024 } 2025 2026 return res; 2027 } 2028 2029 /* 2030 * Send a SYNCHRONIZE CACHE instruction down to the device through 2031 * the normal SCSI command structure. Wait for the command to 2032 * complete. 2033 */ 2034 static void sd_shutdown(struct device *dev) 2035 { 2036 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev); 2037 2038 if (!sdkp) 2039 return; /* this can happen */ 2040 2041 if (sdkp->WCE) { 2042 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n"); 2043 sd_sync_cache(sdkp); 2044 } 2045 2046 if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) { 2047 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n"); 2048 sd_start_stop_device(sdkp, 0); 2049 } 2050 2051 scsi_disk_put(sdkp); 2052 } 2053 2054 static int sd_suspend(struct device *dev, pm_message_t mesg) 2055 { 2056 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev); 2057 int ret = 0; 2058 2059 if (!sdkp) 2060 return 0; /* this can happen */ 2061 2062 if (sdkp->WCE) { 2063 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n"); 2064 ret = sd_sync_cache(sdkp); 2065 if (ret) 2066 goto done; 2067 } 2068 2069 if ((mesg.event & PM_EVENT_SLEEP) && sdkp->device->manage_start_stop) { 2070 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n"); 2071 ret = sd_start_stop_device(sdkp, 0); 2072 } 2073 2074 done: 2075 scsi_disk_put(sdkp); 2076 return ret; 2077 } 2078 2079 static int sd_resume(struct device *dev) 2080 { 2081 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev); 2082 int ret = 0; 2083 2084 if (!sdkp->device->manage_start_stop) 2085 goto done; 2086 2087 sd_printk(KERN_NOTICE, sdkp, "Starting disk\n"); 2088 ret = sd_start_stop_device(sdkp, 1); 2089 2090 done: 2091 scsi_disk_put(sdkp); 2092 return ret; 2093 } 2094 2095 /** 2096 * init_sd - entry point for this driver (both when built in or when 2097 * a module). 2098 * 2099 * Note: this function registers this driver with the scsi mid-level. 2100 **/ 2101 static int __init init_sd(void) 2102 { 2103 int majors = 0, i, err; 2104 2105 SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n")); 2106 2107 for (i = 0; i < SD_MAJORS; i++) 2108 if (register_blkdev(sd_major(i), "sd") == 0) 2109 majors++; 2110 2111 if (!majors) 2112 return -ENODEV; 2113 2114 err = class_register(&sd_disk_class); 2115 if (err) 2116 goto err_out; 2117 2118 err = scsi_register_driver(&sd_template.gendrv); 2119 if (err) 2120 goto err_out_class; 2121 2122 return 0; 2123 2124 err_out_class: 2125 class_unregister(&sd_disk_class); 2126 err_out: 2127 for (i = 0; i < SD_MAJORS; i++) 2128 unregister_blkdev(sd_major(i), "sd"); 2129 return err; 2130 } 2131 2132 /** 2133 * exit_sd - exit point for this driver (when it is a module). 2134 * 2135 * Note: this function unregisters this driver from the scsi mid-level. 2136 **/ 2137 static void __exit exit_sd(void) 2138 { 2139 int i; 2140 2141 SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n")); 2142 2143 scsi_unregister_driver(&sd_template.gendrv); 2144 class_unregister(&sd_disk_class); 2145 2146 for (i = 0; i < SD_MAJORS; i++) 2147 unregister_blkdev(sd_major(i), "sd"); 2148 } 2149 2150 module_init(init_sd); 2151 module_exit(exit_sd); 2152 2153 static void sd_print_sense_hdr(struct scsi_disk *sdkp, 2154 struct scsi_sense_hdr *sshdr) 2155 { 2156 sd_printk(KERN_INFO, sdkp, ""); 2157 scsi_show_sense_hdr(sshdr); 2158 sd_printk(KERN_INFO, sdkp, ""); 2159 scsi_show_extd_sense(sshdr->asc, sshdr->ascq); 2160 } 2161 2162 static void sd_print_result(struct scsi_disk *sdkp, int result) 2163 { 2164 sd_printk(KERN_INFO, sdkp, ""); 2165 scsi_show_result(result); 2166 } 2167 2168