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