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