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