ide-disk.c revision 3cd5f1eae093a7d6ff8a63c746eba9d6f689ba91
1/* 2 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below) 3 * Copyright (C) 1998-2002 Linux ATA Development 4 * Andre Hedrick <andre@linux-ide.org> 5 * Copyright (C) 2003 Red Hat <alan@redhat.com> 6 * Copyright (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz 7 */ 8 9/* 10 * Mostly written by Mark Lord <mlord@pobox.com> 11 * and Gadi Oxman <gadio@netvision.net.il> 12 * and Andre Hedrick <andre@linux-ide.org> 13 * 14 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c. 15 */ 16 17#define IDEDISK_VERSION "1.18" 18 19#include <linux/module.h> 20#include <linux/types.h> 21#include <linux/string.h> 22#include <linux/kernel.h> 23#include <linux/timer.h> 24#include <linux/mm.h> 25#include <linux/interrupt.h> 26#include <linux/major.h> 27#include <linux/errno.h> 28#include <linux/genhd.h> 29#include <linux/slab.h> 30#include <linux/delay.h> 31#include <linux/mutex.h> 32#include <linux/leds.h> 33#include <linux/ide.h> 34 35#include <asm/byteorder.h> 36#include <asm/irq.h> 37#include <asm/uaccess.h> 38#include <asm/io.h> 39#include <asm/div64.h> 40 41#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT) 42#define IDE_DISK_MINORS (1 << PARTN_BITS) 43#else 44#define IDE_DISK_MINORS 0 45#endif 46 47struct ide_disk_obj { 48 ide_drive_t *drive; 49 ide_driver_t *driver; 50 struct gendisk *disk; 51 struct kref kref; 52 unsigned int openers; /* protected by BKL for now */ 53}; 54 55static DEFINE_MUTEX(idedisk_ref_mutex); 56 57#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref) 58 59#define ide_disk_g(disk) \ 60 container_of((disk)->private_data, struct ide_disk_obj, driver) 61 62static void ide_disk_release(struct kref *); 63 64static struct ide_disk_obj *ide_disk_get(struct gendisk *disk) 65{ 66 struct ide_disk_obj *idkp = NULL; 67 68 mutex_lock(&idedisk_ref_mutex); 69 idkp = ide_disk_g(disk); 70 if (idkp) { 71 if (ide_device_get(idkp->drive)) 72 idkp = NULL; 73 else 74 kref_get(&idkp->kref); 75 } 76 mutex_unlock(&idedisk_ref_mutex); 77 return idkp; 78} 79 80static void ide_disk_put(struct ide_disk_obj *idkp) 81{ 82 ide_drive_t *drive = idkp->drive; 83 84 mutex_lock(&idedisk_ref_mutex); 85 kref_put(&idkp->kref, ide_disk_release); 86 ide_device_put(drive); 87 mutex_unlock(&idedisk_ref_mutex); 88} 89 90/* 91 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity" 92 * value for this drive (from its reported identification information). 93 * 94 * Returns: 1 if lba_capacity looks sensible 95 * 0 otherwise 96 * 97 * It is called only once for each drive. 98 */ 99static int lba_capacity_is_ok(u16 *id) 100{ 101 unsigned long lba_sects, chs_sects, head, tail; 102 103 /* No non-LBA info .. so valid! */ 104 if (id[ATA_ID_CYLS] == 0) 105 return 1; 106 107 lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY); 108 109 /* 110 * The ATA spec tells large drives to return 111 * C/H/S = 16383/16/63 independent of their size. 112 * Some drives can be jumpered to use 15 heads instead of 16. 113 * Some drives can be jumpered to use 4092 cyls instead of 16383. 114 */ 115 if ((id[ATA_ID_CYLS] == 16383 || 116 (id[ATA_ID_CYLS] == 4092 && id[ATA_ID_CUR_CYLS] == 16383)) && 117 id[ATA_ID_SECTORS] == 63 && 118 (id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) && 119 (lba_sects >= 16383 * 63 * id[ATA_ID_HEADS])) 120 return 1; 121 122 chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS]; 123 124 /* perform a rough sanity check on lba_sects: within 10% is OK */ 125 if ((lba_sects - chs_sects) < chs_sects/10) 126 return 1; 127 128 /* some drives have the word order reversed */ 129 head = ((lba_sects >> 16) & 0xffff); 130 tail = (lba_sects & 0xffff); 131 lba_sects = (head | (tail << 16)); 132 if ((lba_sects - chs_sects) < chs_sects/10) { 133 *(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects); 134 return 1; /* lba_capacity is (now) good */ 135 } 136 137 return 0; /* lba_capacity value may be bad */ 138} 139 140static const u8 ide_rw_cmds[] = { 141 ATA_CMD_READ_MULTI, 142 ATA_CMD_WRITE_MULTI, 143 ATA_CMD_READ_MULTI_EXT, 144 ATA_CMD_WRITE_MULTI_EXT, 145 ATA_CMD_PIO_READ, 146 ATA_CMD_PIO_WRITE, 147 ATA_CMD_PIO_READ_EXT, 148 ATA_CMD_PIO_WRITE_EXT, 149 ATA_CMD_READ, 150 ATA_CMD_WRITE, 151 ATA_CMD_READ_EXT, 152 ATA_CMD_WRITE_EXT, 153}; 154 155static const u8 ide_data_phases[] = { 156 TASKFILE_MULTI_IN, 157 TASKFILE_MULTI_OUT, 158 TASKFILE_IN, 159 TASKFILE_OUT, 160 TASKFILE_IN_DMA, 161 TASKFILE_OUT_DMA, 162}; 163 164static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma) 165{ 166 u8 index, lba48, write; 167 168 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0; 169 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0; 170 171 if (dma) 172 index = 8; 173 else 174 index = drive->mult_count ? 0 : 4; 175 176 task->tf.command = ide_rw_cmds[index + lba48 + write]; 177 178 if (dma) 179 index = 8; /* fixup index */ 180 181 task->data_phase = ide_data_phases[index / 2 + write]; 182} 183 184/* 185 * __ide_do_rw_disk() issues READ and WRITE commands to a disk, 186 * using LBA if supported, or CHS otherwise, to address sectors. 187 */ 188static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, 189 sector_t block) 190{ 191 ide_hwif_t *hwif = HWIF(drive); 192 unsigned int dma = drive->using_dma; 193 u16 nsectors = (u16)rq->nr_sectors; 194 u8 lba48 = (drive->addressing == 1) ? 1 : 0; 195 ide_task_t task; 196 struct ide_taskfile *tf = &task.tf; 197 ide_startstop_t rc; 198 199 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) { 200 if (block + rq->nr_sectors > 1ULL << 28) 201 dma = 0; 202 else 203 lba48 = 0; 204 } 205 206 if (!dma) { 207 ide_init_sg_cmd(drive, rq); 208 ide_map_sg(drive, rq); 209 } 210 211 memset(&task, 0, sizeof(task)); 212 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 213 214 if (drive->select.b.lba) { 215 if (lba48) { 216 pr_debug("%s: LBA=0x%012llx\n", drive->name, 217 (unsigned long long)block); 218 219 tf->hob_nsect = (nsectors >> 8) & 0xff; 220 tf->hob_lbal = (u8)(block >> 24); 221 if (sizeof(block) != 4) { 222 tf->hob_lbam = (u8)((u64)block >> 32); 223 tf->hob_lbah = (u8)((u64)block >> 40); 224 } 225 226 tf->nsect = nsectors & 0xff; 227 tf->lbal = (u8) block; 228 tf->lbam = (u8)(block >> 8); 229 tf->lbah = (u8)(block >> 16); 230 231 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB); 232 } else { 233 tf->nsect = nsectors & 0xff; 234 tf->lbal = block; 235 tf->lbam = block >>= 8; 236 tf->lbah = block >>= 8; 237 tf->device = (block >> 8) & 0xf; 238 } 239 } else { 240 unsigned int sect, head, cyl, track; 241 242 track = (int)block / drive->sect; 243 sect = (int)block % drive->sect + 1; 244 head = track % drive->head; 245 cyl = track / drive->head; 246 247 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect); 248 249 tf->nsect = nsectors & 0xff; 250 tf->lbal = sect; 251 tf->lbam = cyl; 252 tf->lbah = cyl >> 8; 253 tf->device = head; 254 } 255 256 if (rq_data_dir(rq)) 257 task.tf_flags |= IDE_TFLAG_WRITE; 258 259 ide_tf_set_cmd(drive, &task, dma); 260 if (!dma) 261 hwif->data_phase = task.data_phase; 262 task.rq = rq; 263 264 rc = do_rw_taskfile(drive, &task); 265 266 if (rc == ide_stopped && dma) { 267 /* fallback to PIO */ 268 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK; 269 ide_tf_set_cmd(drive, &task, 0); 270 hwif->data_phase = task.data_phase; 271 ide_init_sg_cmd(drive, rq); 272 rc = do_rw_taskfile(drive, &task); 273 } 274 275 return rc; 276} 277 278/* 279 * 268435455 == 137439 MB or 28bit limit 280 * 320173056 == 163929 MB or 48bit addressing 281 * 1073741822 == 549756 MB or 48bit addressing fake drive 282 */ 283 284static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq, 285 sector_t block) 286{ 287 ide_hwif_t *hwif = HWIF(drive); 288 289 BUG_ON(drive->blocked); 290 291 if (!blk_fs_request(rq)) { 292 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command"); 293 ide_end_request(drive, 0, 0); 294 return ide_stopped; 295 } 296 297 ledtrig_ide_activity(); 298 299 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n", 300 drive->name, rq_data_dir(rq) == READ ? "read" : "writ", 301 (unsigned long long)block, rq->nr_sectors, 302 (unsigned long)rq->buffer); 303 304 if (hwif->rw_disk) 305 hwif->rw_disk(drive, rq); 306 307 return __ide_do_rw_disk(drive, rq, block); 308} 309 310/* 311 * Queries for true maximum capacity of the drive. 312 * Returns maximum LBA address (> 0) of the drive, 0 if failed. 313 */ 314static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48) 315{ 316 ide_task_t args; 317 struct ide_taskfile *tf = &args.tf; 318 u64 addr = 0; 319 320 /* Create IDE/ATA command request structure */ 321 memset(&args, 0, sizeof(ide_task_t)); 322 if (lba48) 323 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT; 324 else 325 tf->command = ATA_CMD_READ_NATIVE_MAX; 326 tf->device = ATA_LBA; 327 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 328 if (lba48) 329 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB); 330 /* submit command request */ 331 ide_no_data_taskfile(drive, &args); 332 333 /* if OK, compute maximum address value */ 334 if ((tf->status & 0x01) == 0) 335 addr = ide_get_lba_addr(tf, lba48) + 1; 336 337 return addr; 338} 339 340/* 341 * Sets maximum virtual LBA address of the drive. 342 * Returns new maximum virtual LBA address (> 0) or 0 on failure. 343 */ 344static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48) 345{ 346 ide_task_t args; 347 struct ide_taskfile *tf = &args.tf; 348 u64 addr_set = 0; 349 350 addr_req--; 351 /* Create IDE/ATA command request structure */ 352 memset(&args, 0, sizeof(ide_task_t)); 353 tf->lbal = (addr_req >> 0) & 0xff; 354 tf->lbam = (addr_req >>= 8) & 0xff; 355 tf->lbah = (addr_req >>= 8) & 0xff; 356 if (lba48) { 357 tf->hob_lbal = (addr_req >>= 8) & 0xff; 358 tf->hob_lbam = (addr_req >>= 8) & 0xff; 359 tf->hob_lbah = (addr_req >>= 8) & 0xff; 360 tf->command = ATA_CMD_SET_MAX_EXT; 361 } else { 362 tf->device = (addr_req >>= 8) & 0x0f; 363 tf->command = ATA_CMD_SET_MAX; 364 } 365 tf->device |= ATA_LBA; 366 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 367 if (lba48) 368 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB); 369 /* submit command request */ 370 ide_no_data_taskfile(drive, &args); 371 /* if OK, compute maximum address value */ 372 if ((tf->status & 0x01) == 0) 373 addr_set = ide_get_lba_addr(tf, lba48) + 1; 374 375 return addr_set; 376} 377 378static unsigned long long sectors_to_MB(unsigned long long n) 379{ 380 n <<= 9; /* make it bytes */ 381 do_div(n, 1000000); /* make it MB */ 382 return n; 383} 384 385/* 386 * The same here. 387 */ 388static inline int idedisk_supports_lba48(const u16 *id) 389{ 390 return (id[ATA_ID_COMMAND_SET_2] & 0x0400) && 391 (id[ATA_ID_CFS_ENABLE_2] & 0x0400) && 392 ata_id_u64(id, ATA_ID_LBA_CAPACITY_2); 393} 394 395/* 396 * Some disks report total number of sectors instead of 397 * maximum sector address. We list them here. 398 */ 399static const struct drive_list_entry hpa_list[] = { 400 { "ST340823A", NULL }, 401 { "ST320413A", NULL }, 402 { "ST310211A", NULL }, 403 { NULL, NULL } 404}; 405 406static void idedisk_check_hpa(ide_drive_t *drive) 407{ 408 unsigned long long capacity, set_max; 409 int lba48 = idedisk_supports_lba48(drive->id); 410 411 capacity = drive->capacity64; 412 413 set_max = idedisk_read_native_max_address(drive, lba48); 414 415 if (ide_in_drive_list(drive->id, hpa_list)) { 416 /* 417 * Since we are inclusive wrt to firmware revisions do this 418 * extra check and apply the workaround only when needed. 419 */ 420 if (set_max == capacity + 1) 421 set_max--; 422 } 423 424 if (set_max <= capacity) 425 return; 426 427 printk(KERN_INFO "%s: Host Protected Area detected.\n" 428 "\tcurrent capacity is %llu sectors (%llu MB)\n" 429 "\tnative capacity is %llu sectors (%llu MB)\n", 430 drive->name, 431 capacity, sectors_to_MB(capacity), 432 set_max, sectors_to_MB(set_max)); 433 434 set_max = idedisk_set_max_address(drive, set_max, lba48); 435 436 if (set_max) { 437 drive->capacity64 = set_max; 438 printk(KERN_INFO "%s: Host Protected Area disabled.\n", 439 drive->name); 440 } 441} 442 443static void init_idedisk_capacity(ide_drive_t *drive) 444{ 445 u16 *id = drive->id; 446 /* 447 * If this drive supports the Host Protected Area feature set, 448 * then we may need to change our opinion about the drive's capacity. 449 */ 450 int hpa = ata_id_hpa_enabled(id); 451 452 if (idedisk_supports_lba48(id)) { 453 /* drive speaks 48-bit LBA */ 454 drive->select.b.lba = 1; 455 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2); 456 if (hpa) 457 idedisk_check_hpa(drive); 458 } else if (ata_id_has_lba(id) && lba_capacity_is_ok(id)) { 459 /* drive speaks 28-bit LBA */ 460 drive->select.b.lba = 1; 461 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY); 462 if (hpa) 463 idedisk_check_hpa(drive); 464 } else { 465 /* drive speaks boring old 28-bit CHS */ 466 drive->capacity64 = drive->cyl * drive->head * drive->sect; 467 } 468} 469 470static sector_t idedisk_capacity(ide_drive_t *drive) 471{ 472 return drive->capacity64; 473} 474 475#ifdef CONFIG_IDE_PROC_FS 476static int smart_enable(ide_drive_t *drive) 477{ 478 ide_task_t args; 479 struct ide_taskfile *tf = &args.tf; 480 481 memset(&args, 0, sizeof(ide_task_t)); 482 tf->feature = ATA_SMART_ENABLE; 483 tf->lbam = ATA_SMART_LBAM_PASS; 484 tf->lbah = ATA_SMART_LBAH_PASS; 485 tf->command = ATA_CMD_SMART; 486 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 487 return ide_no_data_taskfile(drive, &args); 488} 489 490static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd) 491{ 492 ide_task_t args; 493 struct ide_taskfile *tf = &args.tf; 494 495 memset(&args, 0, sizeof(ide_task_t)); 496 tf->feature = sub_cmd; 497 tf->nsect = 0x01; 498 tf->lbam = ATA_SMART_LBAM_PASS; 499 tf->lbah = ATA_SMART_LBAH_PASS; 500 tf->command = ATA_CMD_SMART; 501 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 502 args.data_phase = TASKFILE_IN; 503 (void) smart_enable(drive); 504 return ide_raw_taskfile(drive, &args, buf, 1); 505} 506 507static int proc_idedisk_read_cache 508 (char *page, char **start, off_t off, int count, int *eof, void *data) 509{ 510 ide_drive_t *drive = (ide_drive_t *) data; 511 char *out = page; 512 int len; 513 514 if (drive->id_read) 515 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2); 516 else 517 len = sprintf(out, "(none)\n"); 518 519 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 520} 521 522static int proc_idedisk_read_capacity 523 (char *page, char **start, off_t off, int count, int *eof, void *data) 524{ 525 ide_drive_t*drive = (ide_drive_t *)data; 526 int len; 527 528 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive)); 529 530 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 531} 532 533static int proc_idedisk_read_smart(char *page, char **start, off_t off, 534 int count, int *eof, void *data, u8 sub_cmd) 535{ 536 ide_drive_t *drive = (ide_drive_t *)data; 537 int len = 0, i = 0; 538 539 if (get_smart_data(drive, page, sub_cmd) == 0) { 540 unsigned short *val = (unsigned short *) page; 541 char *out = ((char *)val) + (SECTOR_WORDS * 4); 542 page = out; 543 do { 544 out += sprintf(out, "%04x%c", le16_to_cpu(*val), 545 (++i & 7) ? ' ' : '\n'); 546 val += 1; 547 } while (i < (SECTOR_WORDS * 2)); 548 len = out - page; 549 } 550 551 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 552} 553 554static int proc_idedisk_read_sv 555 (char *page, char **start, off_t off, int count, int *eof, void *data) 556{ 557 return proc_idedisk_read_smart(page, start, off, count, eof, data, 558 ATA_SMART_READ_VALUES); 559} 560 561static int proc_idedisk_read_st 562 (char *page, char **start, off_t off, int count, int *eof, void *data) 563{ 564 return proc_idedisk_read_smart(page, start, off, count, eof, data, 565 ATA_SMART_READ_THRESHOLDS); 566} 567 568static ide_proc_entry_t idedisk_proc[] = { 569 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL }, 570 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL }, 571 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL }, 572 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL }, 573 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL }, 574 { NULL, 0, NULL, NULL } 575}; 576#endif /* CONFIG_IDE_PROC_FS */ 577 578static void idedisk_prepare_flush(struct request_queue *q, struct request *rq) 579{ 580 ide_drive_t *drive = q->queuedata; 581 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC); 582 583 /* FIXME: map struct ide_taskfile on rq->cmd[] */ 584 BUG_ON(task == NULL); 585 586 memset(task, 0, sizeof(*task)); 587 if (ide_id_has_flush_cache_ext(drive->id) && 588 (drive->capacity64 >= (1UL << 28))) 589 task->tf.command = ATA_CMD_FLUSH_EXT; 590 else 591 task->tf.command = ATA_CMD_FLUSH; 592 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE | 593 IDE_TFLAG_DYN; 594 task->data_phase = TASKFILE_NO_DATA; 595 596 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 597 rq->cmd_flags |= REQ_SOFTBARRIER; 598 rq->special = task; 599} 600 601/* 602 * This is tightly woven into the driver->do_special can not touch. 603 * DON'T do it again until a total personality rewrite is committed. 604 */ 605static int set_multcount(ide_drive_t *drive, int arg) 606{ 607 struct request *rq; 608 int error; 609 610 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff)) 611 return -EINVAL; 612 613 if (drive->special.b.set_multmode) 614 return -EBUSY; 615 616 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 617 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 618 619 drive->mult_req = arg; 620 drive->special.b.set_multmode = 1; 621 error = blk_execute_rq(drive->queue, NULL, rq, 0); 622 blk_put_request(rq); 623 624 return (drive->mult_count == arg) ? 0 : -EIO; 625} 626 627static int set_nowerr(ide_drive_t *drive, int arg) 628{ 629 if (arg < 0 || arg > 1) 630 return -EINVAL; 631 632 if (ide_spin_wait_hwgroup(drive)) 633 return -EBUSY; 634 drive->nowerr = arg; 635 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT; 636 spin_unlock_irq(&ide_lock); 637 return 0; 638} 639 640static void update_ordered(ide_drive_t *drive) 641{ 642 u16 *id = drive->id; 643 unsigned ordered = QUEUE_ORDERED_NONE; 644 prepare_flush_fn *prep_fn = NULL; 645 646 if (drive->wcache) { 647 unsigned long long capacity; 648 int barrier; 649 /* 650 * We must avoid issuing commands a drive does not 651 * understand or we may crash it. We check flush cache 652 * is supported. We also check we have the LBA48 flush 653 * cache if the drive capacity is too large. By this 654 * time we have trimmed the drive capacity if LBA48 is 655 * not available so we don't need to recheck that. 656 */ 657 capacity = idedisk_capacity(drive); 658 barrier = ide_id_has_flush_cache(id) && !drive->noflush && 659 (drive->addressing == 0 || capacity <= (1ULL << 28) || 660 ide_id_has_flush_cache_ext(id)); 661 662 printk(KERN_INFO "%s: cache flushes %ssupported\n", 663 drive->name, barrier ? "" : "not "); 664 665 if (barrier) { 666 ordered = QUEUE_ORDERED_DRAIN_FLUSH; 667 prep_fn = idedisk_prepare_flush; 668 } 669 } else 670 ordered = QUEUE_ORDERED_DRAIN; 671 672 blk_queue_ordered(drive->queue, ordered, prep_fn); 673} 674 675static int write_cache(ide_drive_t *drive, int arg) 676{ 677 ide_task_t args; 678 int err = 1; 679 680 if (arg < 0 || arg > 1) 681 return -EINVAL; 682 683 if (ide_id_has_flush_cache(drive->id)) { 684 memset(&args, 0, sizeof(ide_task_t)); 685 args.tf.feature = arg ? 686 SETFEATURES_WC_ON : SETFEATURES_WC_OFF; 687 args.tf.command = ATA_CMD_SET_FEATURES; 688 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 689 err = ide_no_data_taskfile(drive, &args); 690 if (err == 0) 691 drive->wcache = arg; 692 } 693 694 update_ordered(drive); 695 696 return err; 697} 698 699static int do_idedisk_flushcache(ide_drive_t *drive) 700{ 701 ide_task_t args; 702 703 memset(&args, 0, sizeof(ide_task_t)); 704 if (ide_id_has_flush_cache_ext(drive->id)) 705 args.tf.command = ATA_CMD_FLUSH_EXT; 706 else 707 args.tf.command = ATA_CMD_FLUSH; 708 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 709 return ide_no_data_taskfile(drive, &args); 710} 711 712static int set_acoustic(ide_drive_t *drive, int arg) 713{ 714 ide_task_t args; 715 716 if (arg < 0 || arg > 254) 717 return -EINVAL; 718 719 memset(&args, 0, sizeof(ide_task_t)); 720 args.tf.feature = arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF; 721 args.tf.nsect = arg; 722 args.tf.command = ATA_CMD_SET_FEATURES; 723 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 724 ide_no_data_taskfile(drive, &args); 725 drive->acoustic = arg; 726 return 0; 727} 728 729/* 730 * drive->addressing: 731 * 0: 28-bit 732 * 1: 48-bit 733 * 2: 48-bit capable doing 28-bit 734 */ 735static int set_lba_addressing(ide_drive_t *drive, int arg) 736{ 737 if (arg < 0 || arg > 2) 738 return -EINVAL; 739 740 drive->addressing = 0; 741 742 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) 743 return 0; 744 745 if (!idedisk_supports_lba48(drive->id)) 746 return -EIO; 747 drive->addressing = arg; 748 return 0; 749} 750 751#ifdef CONFIG_IDE_PROC_FS 752static void idedisk_add_settings(ide_drive_t *drive) 753{ 754 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, 755 &drive->bios_cyl, NULL); 756 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, 757 &drive->bios_head, NULL); 758 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, 759 &drive->bios_sect, NULL); 760 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, 761 &drive->addressing, set_lba_addressing); 762 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, 763 drive->id[ATA_ID_MAX_MULTSECT] & 0xff, 1, 1, 764 &drive->mult_count, set_multcount); 765 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, 766 &drive->nowerr, set_nowerr); 767 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, 768 &drive->lun, NULL); 769 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, 770 &drive->wcache, write_cache); 771 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, 772 &drive->acoustic, set_acoustic); 773 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, 774 &drive->failures, NULL); 775 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 776 1, 1, &drive->max_failures, NULL); 777} 778#else 779static inline void idedisk_add_settings(ide_drive_t *drive) { ; } 780#endif 781 782static void idedisk_setup(ide_drive_t *drive) 783{ 784 ide_hwif_t *hwif = drive->hwif; 785 u16 *id = drive->id; 786 char *m = (char *)&id[ATA_ID_PROD]; 787 unsigned long long capacity; 788 789 idedisk_add_settings(drive); 790 791 if (drive->id_read == 0) 792 return; 793 794 if (drive->removable) { 795 /* 796 * Removable disks (eg. SYQUEST); ignore 'WD' drives 797 */ 798 if (m[0] != 'W' || m[1] != 'D') 799 drive->doorlocking = 1; 800 } 801 802 (void)set_lba_addressing(drive, 1); 803 804 if (drive->addressing == 1) { 805 int max_s = 2048; 806 807 if (max_s > hwif->rqsize) 808 max_s = hwif->rqsize; 809 810 blk_queue_max_sectors(drive->queue, max_s); 811 } 812 813 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, 814 drive->queue->max_sectors / 2); 815 816 /* calculate drive capacity, and select LBA if possible */ 817 init_idedisk_capacity(drive); 818 819 /* limit drive capacity to 137GB if LBA48 cannot be used */ 820 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) { 821 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity " 822 "%llu sectors (%llu MB)\n", 823 drive->name, (unsigned long long)drive->capacity64, 824 sectors_to_MB(drive->capacity64)); 825 drive->capacity64 = 1ULL << 28; 826 } 827 828 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) { 829 if (drive->capacity64 > 1ULL << 28) { 830 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode" 831 " will be used for accessing sectors " 832 "> %u\n", drive->name, 1 << 28); 833 } else 834 drive->addressing = 0; 835 } 836 837 /* 838 * if possible, give fdisk access to more of the drive, 839 * by correcting bios_cyls: 840 */ 841 capacity = idedisk_capacity(drive); 842 843 if (!drive->forced_geom) { 844 845 if (idedisk_supports_lba48(drive->id)) { 846 /* compatibility */ 847 drive->bios_sect = 63; 848 drive->bios_head = 255; 849 } 850 851 if (drive->bios_sect && drive->bios_head) { 852 unsigned int cap0 = capacity; /* truncate to 32 bits */ 853 unsigned int cylsz, cyl; 854 855 if (cap0 != capacity) 856 drive->bios_cyl = 65535; 857 else { 858 cylsz = drive->bios_sect * drive->bios_head; 859 cyl = cap0 / cylsz; 860 if (cyl > 65535) 861 cyl = 65535; 862 if (cyl > drive->bios_cyl) 863 drive->bios_cyl = cyl; 864 } 865 } 866 } 867 printk(KERN_INFO "%s: %llu sectors (%llu MB)", 868 drive->name, capacity, sectors_to_MB(capacity)); 869 870 /* Only print cache size when it was specified */ 871 if (id[ATA_ID_BUF_SIZE]) 872 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2); 873 874 printk(KERN_CONT ", CHS=%d/%d/%d\n", 875 drive->bios_cyl, drive->bios_head, drive->bios_sect); 876 877 /* write cache enabled? */ 878 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id)) 879 drive->wcache = 1; 880 881 write_cache(drive, 1); 882} 883 884static void ide_cacheflush_p(ide_drive_t *drive) 885{ 886 if (!drive->wcache || !ide_id_has_flush_cache(drive->id)) 887 return; 888 889 if (do_idedisk_flushcache(drive)) 890 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name); 891} 892 893static void ide_disk_remove(ide_drive_t *drive) 894{ 895 struct ide_disk_obj *idkp = drive->driver_data; 896 struct gendisk *g = idkp->disk; 897 898 ide_proc_unregister_driver(drive, idkp->driver); 899 900 del_gendisk(g); 901 902 ide_cacheflush_p(drive); 903 904 ide_disk_put(idkp); 905} 906 907static void ide_disk_release(struct kref *kref) 908{ 909 struct ide_disk_obj *idkp = to_ide_disk(kref); 910 ide_drive_t *drive = idkp->drive; 911 struct gendisk *g = idkp->disk; 912 913 drive->driver_data = NULL; 914 g->private_data = NULL; 915 put_disk(g); 916 kfree(idkp); 917} 918 919static int ide_disk_probe(ide_drive_t *drive); 920 921/* 922 * On HPA drives the capacity needs to be 923 * reinitilized on resume otherwise the disk 924 * can not be used and a hard reset is required 925 */ 926static void ide_disk_resume(ide_drive_t *drive) 927{ 928 if (ata_id_hpa_enabled(drive->id)) 929 init_idedisk_capacity(drive); 930} 931 932static void ide_device_shutdown(ide_drive_t *drive) 933{ 934#ifdef CONFIG_ALPHA 935 /* On Alpha, halt(8) doesn't actually turn the machine off, 936 it puts you into the sort of firmware monitor. Typically, 937 it's used to boot another kernel image, so it's not much 938 different from reboot(8). Therefore, we don't need to 939 spin down the disk in this case, especially since Alpha 940 firmware doesn't handle disks in standby mode properly. 941 On the other hand, it's reasonably safe to turn the power 942 off when the shutdown process reaches the firmware prompt, 943 as the firmware initialization takes rather long time - 944 at least 10 seconds, which should be sufficient for 945 the disk to expire its write cache. */ 946 if (system_state != SYSTEM_POWER_OFF) { 947#else 948 if (system_state == SYSTEM_RESTART) { 949#endif 950 ide_cacheflush_p(drive); 951 return; 952 } 953 954 printk(KERN_INFO "Shutdown: %s\n", drive->name); 955 956 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND); 957} 958 959static ide_driver_t idedisk_driver = { 960 .gen_driver = { 961 .owner = THIS_MODULE, 962 .name = "ide-disk", 963 .bus = &ide_bus_type, 964 }, 965 .probe = ide_disk_probe, 966 .remove = ide_disk_remove, 967 .resume = ide_disk_resume, 968 .shutdown = ide_device_shutdown, 969 .version = IDEDISK_VERSION, 970 .media = ide_disk, 971 .supports_dsc_overlap = 0, 972 .do_request = ide_do_rw_disk, 973 .end_request = ide_end_request, 974 .error = __ide_error, 975#ifdef CONFIG_IDE_PROC_FS 976 .proc = idedisk_proc, 977#endif 978}; 979 980static int idedisk_set_doorlock(ide_drive_t *drive, int on) 981{ 982 ide_task_t task; 983 984 memset(&task, 0, sizeof(task)); 985 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK; 986 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 987 988 return ide_no_data_taskfile(drive, &task); 989} 990 991static int idedisk_open(struct inode *inode, struct file *filp) 992{ 993 struct gendisk *disk = inode->i_bdev->bd_disk; 994 struct ide_disk_obj *idkp; 995 ide_drive_t *drive; 996 997 idkp = ide_disk_get(disk); 998 if (idkp == NULL) 999 return -ENXIO; 1000 1001 drive = idkp->drive; 1002 1003 idkp->openers++; 1004 1005 if (drive->removable && idkp->openers == 1) { 1006 check_disk_change(inode->i_bdev); 1007 /* 1008 * Ignore the return code from door_lock, 1009 * since the open() has already succeeded, 1010 * and the door_lock is irrelevant at this point. 1011 */ 1012 if (drive->doorlocking && idedisk_set_doorlock(drive, 1)) 1013 drive->doorlocking = 0; 1014 } 1015 return 0; 1016} 1017 1018static int idedisk_release(struct inode *inode, struct file *filp) 1019{ 1020 struct gendisk *disk = inode->i_bdev->bd_disk; 1021 struct ide_disk_obj *idkp = ide_disk_g(disk); 1022 ide_drive_t *drive = idkp->drive; 1023 1024 if (idkp->openers == 1) 1025 ide_cacheflush_p(drive); 1026 1027 if (drive->removable && idkp->openers == 1) { 1028 if (drive->doorlocking && idedisk_set_doorlock(drive, 0)) 1029 drive->doorlocking = 0; 1030 } 1031 1032 idkp->openers--; 1033 1034 ide_disk_put(idkp); 1035 1036 return 0; 1037} 1038 1039static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo) 1040{ 1041 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1042 ide_drive_t *drive = idkp->drive; 1043 1044 geo->heads = drive->bios_head; 1045 geo->sectors = drive->bios_sect; 1046 geo->cylinders = (u16)drive->bios_cyl; /* truncate */ 1047 return 0; 1048} 1049 1050static int idedisk_ioctl(struct inode *inode, struct file *file, 1051 unsigned int cmd, unsigned long arg) 1052{ 1053 unsigned long flags; 1054 struct block_device *bdev = inode->i_bdev; 1055 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1056 ide_drive_t *drive = idkp->drive; 1057 int err, (*setfunc)(ide_drive_t *, int); 1058 u8 *val; 1059 1060 switch (cmd) { 1061 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val; 1062 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val; 1063 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val; 1064 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val; 1065 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val; 1066 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val; 1067 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val; 1068 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val; 1069 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val; 1070 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val; 1071 } 1072 1073 return generic_ide_ioctl(drive, file, bdev, cmd, arg); 1074 1075read_val: 1076 mutex_lock(&ide_setting_mtx); 1077 spin_lock_irqsave(&ide_lock, flags); 1078 err = *val; 1079 spin_unlock_irqrestore(&ide_lock, flags); 1080 mutex_unlock(&ide_setting_mtx); 1081 return err >= 0 ? put_user(err, (long __user *)arg) : err; 1082 1083set_val: 1084 if (bdev != bdev->bd_contains) 1085 err = -EINVAL; 1086 else { 1087 if (!capable(CAP_SYS_ADMIN)) 1088 err = -EACCES; 1089 else { 1090 mutex_lock(&ide_setting_mtx); 1091 err = setfunc(drive, arg); 1092 mutex_unlock(&ide_setting_mtx); 1093 } 1094 } 1095 return err; 1096} 1097 1098static int idedisk_media_changed(struct gendisk *disk) 1099{ 1100 struct ide_disk_obj *idkp = ide_disk_g(disk); 1101 ide_drive_t *drive = idkp->drive; 1102 1103 /* do not scan partitions twice if this is a removable device */ 1104 if (drive->attach) { 1105 drive->attach = 0; 1106 return 0; 1107 } 1108 /* if removable, always assume it was changed */ 1109 return drive->removable; 1110} 1111 1112static int idedisk_revalidate_disk(struct gendisk *disk) 1113{ 1114 struct ide_disk_obj *idkp = ide_disk_g(disk); 1115 set_capacity(disk, idedisk_capacity(idkp->drive)); 1116 return 0; 1117} 1118 1119static struct block_device_operations idedisk_ops = { 1120 .owner = THIS_MODULE, 1121 .open = idedisk_open, 1122 .release = idedisk_release, 1123 .ioctl = idedisk_ioctl, 1124 .getgeo = idedisk_getgeo, 1125 .media_changed = idedisk_media_changed, 1126 .revalidate_disk = idedisk_revalidate_disk 1127}; 1128 1129MODULE_DESCRIPTION("ATA DISK Driver"); 1130 1131static int ide_disk_probe(ide_drive_t *drive) 1132{ 1133 struct ide_disk_obj *idkp; 1134 struct gendisk *g; 1135 1136 /* strstr("foo", "") is non-NULL */ 1137 if (!strstr("ide-disk", drive->driver_req)) 1138 goto failed; 1139 if (!drive->present) 1140 goto failed; 1141 if (drive->media != ide_disk) 1142 goto failed; 1143 1144 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); 1145 if (!idkp) 1146 goto failed; 1147 1148 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif)); 1149 if (!g) 1150 goto out_free_idkp; 1151 1152 ide_init_disk(g, drive); 1153 1154 ide_proc_register_driver(drive, &idedisk_driver); 1155 1156 kref_init(&idkp->kref); 1157 1158 idkp->drive = drive; 1159 idkp->driver = &idedisk_driver; 1160 idkp->disk = g; 1161 1162 g->private_data = &idkp->driver; 1163 1164 drive->driver_data = idkp; 1165 1166 idedisk_setup(drive); 1167 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) { 1168 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", 1169 drive->name, drive->head); 1170 drive->attach = 0; 1171 } else 1172 drive->attach = 1; 1173 1174 g->minors = IDE_DISK_MINORS; 1175 g->driverfs_dev = &drive->gendev; 1176 g->flags |= GENHD_FL_EXT_DEVT; 1177 if (drive->removable) 1178 g->flags |= GENHD_FL_REMOVABLE; 1179 set_capacity(g, idedisk_capacity(drive)); 1180 g->fops = &idedisk_ops; 1181 add_disk(g); 1182 return 0; 1183 1184out_free_idkp: 1185 kfree(idkp); 1186failed: 1187 return -ENODEV; 1188} 1189 1190static void __exit idedisk_exit(void) 1191{ 1192 driver_unregister(&idedisk_driver.gen_driver); 1193} 1194 1195static int __init idedisk_init(void) 1196{ 1197 return driver_register(&idedisk_driver.gen_driver); 1198} 1199 1200MODULE_ALIAS("ide:*m-disk*"); 1201module_init(idedisk_init); 1202module_exit(idedisk_exit); 1203MODULE_LICENSE("GPL"); 1204