ide-disk.c revision ab1b67a6230648cf65b0342d9887fee890160ca8
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 448static void init_idedisk_capacity(ide_drive_t *drive) 449{ 450 struct hd_driveid *id = drive->id; 451 /* 452 * If this drive supports the Host Protected Area feature set, 453 * then we may need to change our opinion about the drive's capacity. 454 */ 455 int hpa = idedisk_supports_hpa(id); 456 457 if (idedisk_supports_lba48(id)) { 458 /* drive speaks 48-bit LBA */ 459 drive->select.b.lba = 1; 460 drive->capacity64 = id->lba_capacity_2; 461 if (hpa) 462 idedisk_check_hpa(drive); 463 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) { 464 /* drive speaks 28-bit LBA */ 465 drive->select.b.lba = 1; 466 drive->capacity64 = id->lba_capacity; 467 if (hpa) 468 idedisk_check_hpa(drive); 469 } else { 470 /* drive speaks boring old 28-bit CHS */ 471 drive->capacity64 = drive->cyl * drive->head * drive->sect; 472 } 473} 474 475static sector_t idedisk_capacity(ide_drive_t *drive) 476{ 477 return drive->capacity64 - drive->sect0; 478} 479 480#ifdef CONFIG_IDE_PROC_FS 481static int smart_enable(ide_drive_t *drive) 482{ 483 ide_task_t args; 484 struct ide_taskfile *tf = &args.tf; 485 486 memset(&args, 0, sizeof(ide_task_t)); 487 tf->feature = SMART_ENABLE; 488 tf->lbam = SMART_LCYL_PASS; 489 tf->lbah = SMART_HCYL_PASS; 490 tf->command = WIN_SMART; 491 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 492 return ide_no_data_taskfile(drive, &args); 493} 494 495static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd) 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 = sub_cmd; 502 tf->nsect = 0x01; 503 tf->lbam = SMART_LCYL_PASS; 504 tf->lbah = SMART_HCYL_PASS; 505 tf->command = WIN_SMART; 506 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 507 args.data_phase = TASKFILE_IN; 508 (void) smart_enable(drive); 509 return ide_raw_taskfile(drive, &args, buf, 1); 510} 511 512static int proc_idedisk_read_cache 513 (char *page, char **start, off_t off, int count, int *eof, void *data) 514{ 515 ide_drive_t *drive = (ide_drive_t *) data; 516 char *out = page; 517 int len; 518 519 if (drive->id_read) 520 len = sprintf(out, "%i\n", drive->id->buf_size / 2); 521 else 522 len = sprintf(out, "(none)\n"); 523 524 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 525} 526 527static int proc_idedisk_read_capacity 528 (char *page, char **start, off_t off, int count, int *eof, void *data) 529{ 530 ide_drive_t*drive = (ide_drive_t *)data; 531 int len; 532 533 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive)); 534 535 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 536} 537 538static int proc_idedisk_read_smart(char *page, char **start, off_t off, 539 int count, int *eof, void *data, u8 sub_cmd) 540{ 541 ide_drive_t *drive = (ide_drive_t *)data; 542 int len = 0, i = 0; 543 544 if (get_smart_data(drive, page, sub_cmd) == 0) { 545 unsigned short *val = (unsigned short *) page; 546 char *out = ((char *)val) + (SECTOR_WORDS * 4); 547 page = out; 548 do { 549 out += sprintf(out, "%04x%c", le16_to_cpu(*val), 550 (++i & 7) ? ' ' : '\n'); 551 val += 1; 552 } while (i < (SECTOR_WORDS * 2)); 553 len = out - page; 554 } 555 556 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 557} 558 559static int proc_idedisk_read_sv 560 (char *page, char **start, off_t off, int count, int *eof, void *data) 561{ 562 return proc_idedisk_read_smart(page, start, off, count, eof, data, 563 SMART_READ_VALUES); 564} 565 566static int proc_idedisk_read_st 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_THRESHOLDS); 571} 572 573static ide_proc_entry_t idedisk_proc[] = { 574 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL }, 575 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL }, 576 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL }, 577 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL }, 578 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL }, 579 { NULL, 0, NULL, NULL } 580}; 581#endif /* CONFIG_IDE_PROC_FS */ 582 583static void idedisk_prepare_flush(struct request_queue *q, struct request *rq) 584{ 585 ide_drive_t *drive = q->queuedata; 586 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC); 587 588 /* FIXME: map struct ide_taskfile on rq->cmd[] */ 589 BUG_ON(task == NULL); 590 591 memset(task, 0, sizeof(*task)); 592 if (ide_id_has_flush_cache_ext(drive->id) && 593 (drive->capacity64 >= (1UL << 28))) 594 task->tf.command = WIN_FLUSH_CACHE_EXT; 595 else 596 task->tf.command = WIN_FLUSH_CACHE; 597 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE | 598 IDE_TFLAG_DYN; 599 task->data_phase = TASKFILE_NO_DATA; 600 601 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 602 rq->cmd_flags |= REQ_SOFTBARRIER; 603 rq->special = task; 604} 605 606/* 607 * This is tightly woven into the driver->do_special can not touch. 608 * DON'T do it again until a total personality rewrite is committed. 609 */ 610static int set_multcount(ide_drive_t *drive, int arg) 611{ 612 struct request *rq; 613 int error; 614 615 if (arg < 0 || arg > drive->id->max_multsect) 616 return -EINVAL; 617 618 if (drive->special.b.set_multmode) 619 return -EBUSY; 620 621 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 622 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 623 624 drive->mult_req = arg; 625 drive->special.b.set_multmode = 1; 626 error = blk_execute_rq(drive->queue, NULL, rq, 0); 627 blk_put_request(rq); 628 629 return (drive->mult_count == arg) ? 0 : -EIO; 630} 631 632static int set_nowerr(ide_drive_t *drive, int arg) 633{ 634 if (arg < 0 || arg > 1) 635 return -EINVAL; 636 637 if (ide_spin_wait_hwgroup(drive)) 638 return -EBUSY; 639 drive->nowerr = arg; 640 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT; 641 spin_unlock_irq(&ide_lock); 642 return 0; 643} 644 645static void update_ordered(ide_drive_t *drive) 646{ 647 struct hd_driveid *id = drive->id; 648 unsigned ordered = QUEUE_ORDERED_NONE; 649 prepare_flush_fn *prep_fn = NULL; 650 651 if (drive->wcache) { 652 unsigned long long capacity; 653 int barrier; 654 /* 655 * We must avoid issuing commands a drive does not 656 * understand or we may crash it. We check flush cache 657 * is supported. We also check we have the LBA48 flush 658 * cache if the drive capacity is too large. By this 659 * time we have trimmed the drive capacity if LBA48 is 660 * not available so we don't need to recheck that. 661 */ 662 capacity = idedisk_capacity(drive); 663 barrier = ide_id_has_flush_cache(id) && !drive->noflush && 664 (drive->addressing == 0 || capacity <= (1ULL << 28) || 665 ide_id_has_flush_cache_ext(id)); 666 667 printk(KERN_INFO "%s: cache flushes %ssupported\n", 668 drive->name, barrier ? "" : "not "); 669 670 if (barrier) { 671 ordered = QUEUE_ORDERED_DRAIN_FLUSH; 672 prep_fn = idedisk_prepare_flush; 673 } 674 } else 675 ordered = QUEUE_ORDERED_DRAIN; 676 677 blk_queue_ordered(drive->queue, ordered, prep_fn); 678} 679 680static int write_cache(ide_drive_t *drive, int arg) 681{ 682 ide_task_t args; 683 int err = 1; 684 685 if (arg < 0 || arg > 1) 686 return -EINVAL; 687 688 if (ide_id_has_flush_cache(drive->id)) { 689 memset(&args, 0, sizeof(ide_task_t)); 690 args.tf.feature = arg ? 691 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE; 692 args.tf.command = WIN_SETFEATURES; 693 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 694 err = ide_no_data_taskfile(drive, &args); 695 if (err == 0) 696 drive->wcache = arg; 697 } 698 699 update_ordered(drive); 700 701 return err; 702} 703 704static int do_idedisk_flushcache(ide_drive_t *drive) 705{ 706 ide_task_t args; 707 708 memset(&args, 0, sizeof(ide_task_t)); 709 if (ide_id_has_flush_cache_ext(drive->id)) 710 args.tf.command = WIN_FLUSH_CACHE_EXT; 711 else 712 args.tf.command = WIN_FLUSH_CACHE; 713 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 714 return ide_no_data_taskfile(drive, &args); 715} 716 717static int set_acoustic(ide_drive_t *drive, int arg) 718{ 719 ide_task_t args; 720 721 if (arg < 0 || arg > 254) 722 return -EINVAL; 723 724 memset(&args, 0, sizeof(ide_task_t)); 725 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM; 726 args.tf.nsect = arg; 727 args.tf.command = WIN_SETFEATURES; 728 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 729 ide_no_data_taskfile(drive, &args); 730 drive->acoustic = arg; 731 return 0; 732} 733 734/* 735 * drive->addressing: 736 * 0: 28-bit 737 * 1: 48-bit 738 * 2: 48-bit capable doing 28-bit 739 */ 740static int set_lba_addressing(ide_drive_t *drive, int arg) 741{ 742 if (arg < 0 || arg > 2) 743 return -EINVAL; 744 745 drive->addressing = 0; 746 747 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) 748 return 0; 749 750 if (!idedisk_supports_lba48(drive->id)) 751 return -EIO; 752 drive->addressing = arg; 753 return 0; 754} 755 756#ifdef CONFIG_IDE_PROC_FS 757static void idedisk_add_settings(ide_drive_t *drive) 758{ 759 struct hd_driveid *id = drive->id; 760 761 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, 762 &drive->bios_cyl, NULL); 763 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, 764 &drive->bios_head, NULL); 765 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, 766 &drive->bios_sect, NULL); 767 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, 768 &drive->addressing, set_lba_addressing); 769 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, 770 id->max_multsect, 1, 1, &drive->mult_count, 771 set_multcount); 772 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, 773 &drive->nowerr, set_nowerr); 774 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, 775 &drive->lun, NULL); 776 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, 777 &drive->wcache, write_cache); 778 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, 779 &drive->acoustic, set_acoustic); 780 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, 781 &drive->failures, NULL); 782 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 783 1, 1, &drive->max_failures, NULL); 784} 785#else 786static inline void idedisk_add_settings(ide_drive_t *drive) { ; } 787#endif 788 789static void idedisk_setup(ide_drive_t *drive) 790{ 791 ide_hwif_t *hwif = drive->hwif; 792 struct hd_driveid *id = drive->id; 793 unsigned long long capacity; 794 795 idedisk_add_settings(drive); 796 797 if (drive->id_read == 0) 798 return; 799 800 if (drive->removable) { 801 /* 802 * Removable disks (eg. SYQUEST); ignore 'WD' drives 803 */ 804 if (id->model[0] != 'W' || id->model[1] != 'D') 805 drive->doorlocking = 1; 806 } 807 808 (void)set_lba_addressing(drive, 1); 809 810 if (drive->addressing == 1) { 811 int max_s = 2048; 812 813 if (max_s > hwif->rqsize) 814 max_s = hwif->rqsize; 815 816 blk_queue_max_sectors(drive->queue, max_s); 817 } 818 819 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, 820 drive->queue->max_sectors / 2); 821 822 /* calculate drive capacity, and select LBA if possible */ 823 init_idedisk_capacity(drive); 824 825 /* limit drive capacity to 137GB if LBA48 cannot be used */ 826 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) { 827 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity " 828 "%llu sectors (%llu MB)\n", 829 drive->name, (unsigned long long)drive->capacity64, 830 sectors_to_MB(drive->capacity64)); 831 drive->capacity64 = 1ULL << 28; 832 } 833 834 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) { 835 if (drive->capacity64 > 1ULL << 28) { 836 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode" 837 " will be used for accessing sectors " 838 "> %u\n", drive->name, 1 << 28); 839 } else 840 drive->addressing = 0; 841 } 842 843 /* 844 * if possible, give fdisk access to more of the drive, 845 * by correcting bios_cyls: 846 */ 847 capacity = idedisk_capacity(drive); 848 849 if (!drive->forced_geom) { 850 851 if (idedisk_supports_lba48(drive->id)) { 852 /* compatibility */ 853 drive->bios_sect = 63; 854 drive->bios_head = 255; 855 } 856 857 if (drive->bios_sect && drive->bios_head) { 858 unsigned int cap0 = capacity; /* truncate to 32 bits */ 859 unsigned int cylsz, cyl; 860 861 if (cap0 != capacity) 862 drive->bios_cyl = 65535; 863 else { 864 cylsz = drive->bios_sect * drive->bios_head; 865 cyl = cap0 / cylsz; 866 if (cyl > 65535) 867 cyl = 65535; 868 if (cyl > drive->bios_cyl) 869 drive->bios_cyl = cyl; 870 } 871 } 872 } 873 printk(KERN_INFO "%s: %llu sectors (%llu MB)", 874 drive->name, capacity, sectors_to_MB(capacity)); 875 876 /* Only print cache size when it was specified */ 877 if (id->buf_size) 878 printk(KERN_CONT " w/%dKiB Cache", id->buf_size / 2); 879 880 printk(KERN_CONT ", CHS=%d/%d/%d\n", 881 drive->bios_cyl, drive->bios_head, drive->bios_sect); 882 883 /* write cache enabled? */ 884 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5))) 885 drive->wcache = 1; 886 887 write_cache(drive, 1); 888} 889 890static void ide_cacheflush_p(ide_drive_t *drive) 891{ 892 if (!drive->wcache || !ide_id_has_flush_cache(drive->id)) 893 return; 894 895 if (do_idedisk_flushcache(drive)) 896 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name); 897} 898 899static void ide_disk_remove(ide_drive_t *drive) 900{ 901 struct ide_disk_obj *idkp = drive->driver_data; 902 struct gendisk *g = idkp->disk; 903 904 ide_proc_unregister_driver(drive, idkp->driver); 905 906 del_gendisk(g); 907 908 ide_cacheflush_p(drive); 909 910 ide_disk_put(idkp); 911} 912 913static void ide_disk_release(struct kref *kref) 914{ 915 struct ide_disk_obj *idkp = to_ide_disk(kref); 916 ide_drive_t *drive = idkp->drive; 917 struct gendisk *g = idkp->disk; 918 919 drive->driver_data = NULL; 920 g->private_data = NULL; 921 put_disk(g); 922 kfree(idkp); 923} 924 925static int ide_disk_probe(ide_drive_t *drive); 926 927/* 928 * On HPA drives the capacity needs to be 929 * reinitilized on resume otherwise the disk 930 * can not be used and a hard reset is required 931 */ 932static void ide_disk_resume(ide_drive_t *drive) 933{ 934 if (idedisk_supports_hpa(drive->id)) 935 init_idedisk_capacity(drive); 936} 937 938static void ide_device_shutdown(ide_drive_t *drive) 939{ 940#ifdef CONFIG_ALPHA 941 /* On Alpha, halt(8) doesn't actually turn the machine off, 942 it puts you into the sort of firmware monitor. Typically, 943 it's used to boot another kernel image, so it's not much 944 different from reboot(8). Therefore, we don't need to 945 spin down the disk in this case, especially since Alpha 946 firmware doesn't handle disks in standby mode properly. 947 On the other hand, it's reasonably safe to turn the power 948 off when the shutdown process reaches the firmware prompt, 949 as the firmware initialization takes rather long time - 950 at least 10 seconds, which should be sufficient for 951 the disk to expire its write cache. */ 952 if (system_state != SYSTEM_POWER_OFF) { 953#else 954 if (system_state == SYSTEM_RESTART) { 955#endif 956 ide_cacheflush_p(drive); 957 return; 958 } 959 960 printk(KERN_INFO "Shutdown: %s\n", drive->name); 961 962 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND); 963} 964 965static ide_driver_t idedisk_driver = { 966 .gen_driver = { 967 .owner = THIS_MODULE, 968 .name = "ide-disk", 969 .bus = &ide_bus_type, 970 }, 971 .probe = ide_disk_probe, 972 .remove = ide_disk_remove, 973 .resume = ide_disk_resume, 974 .shutdown = ide_device_shutdown, 975 .version = IDEDISK_VERSION, 976 .media = ide_disk, 977 .supports_dsc_overlap = 0, 978 .do_request = ide_do_rw_disk, 979 .end_request = ide_end_request, 980 .error = __ide_error, 981#ifdef CONFIG_IDE_PROC_FS 982 .proc = idedisk_proc, 983#endif 984}; 985 986static int idedisk_set_doorlock(ide_drive_t *drive, int on) 987{ 988 ide_task_t task; 989 990 memset(&task, 0, sizeof(task)); 991 task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK; 992 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 993 994 return ide_no_data_taskfile(drive, &task); 995} 996 997static int idedisk_open(struct inode *inode, struct file *filp) 998{ 999 struct gendisk *disk = inode->i_bdev->bd_disk; 1000 struct ide_disk_obj *idkp; 1001 ide_drive_t *drive; 1002 1003 idkp = ide_disk_get(disk); 1004 if (idkp == NULL) 1005 return -ENXIO; 1006 1007 drive = idkp->drive; 1008 1009 idkp->openers++; 1010 1011 if (drive->removable && idkp->openers == 1) { 1012 check_disk_change(inode->i_bdev); 1013 /* 1014 * Ignore the return code from door_lock, 1015 * since the open() has already succeeded, 1016 * and the door_lock is irrelevant at this point. 1017 */ 1018 if (drive->doorlocking && idedisk_set_doorlock(drive, 1)) 1019 drive->doorlocking = 0; 1020 } 1021 return 0; 1022} 1023 1024static int idedisk_release(struct inode *inode, struct file *filp) 1025{ 1026 struct gendisk *disk = inode->i_bdev->bd_disk; 1027 struct ide_disk_obj *idkp = ide_disk_g(disk); 1028 ide_drive_t *drive = idkp->drive; 1029 1030 if (idkp->openers == 1) 1031 ide_cacheflush_p(drive); 1032 1033 if (drive->removable && idkp->openers == 1) { 1034 if (drive->doorlocking && idedisk_set_doorlock(drive, 0)) 1035 drive->doorlocking = 0; 1036 } 1037 1038 idkp->openers--; 1039 1040 ide_disk_put(idkp); 1041 1042 return 0; 1043} 1044 1045static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo) 1046{ 1047 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1048 ide_drive_t *drive = idkp->drive; 1049 1050 geo->heads = drive->bios_head; 1051 geo->sectors = drive->bios_sect; 1052 geo->cylinders = (u16)drive->bios_cyl; /* truncate */ 1053 return 0; 1054} 1055 1056static int idedisk_ioctl(struct inode *inode, struct file *file, 1057 unsigned int cmd, unsigned long arg) 1058{ 1059 unsigned long flags; 1060 struct block_device *bdev = inode->i_bdev; 1061 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1062 ide_drive_t *drive = idkp->drive; 1063 int err, (*setfunc)(ide_drive_t *, int); 1064 u8 *val; 1065 1066 switch (cmd) { 1067 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val; 1068 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val; 1069 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val; 1070 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val; 1071 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val; 1072 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val; 1073 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val; 1074 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val; 1075 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val; 1076 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val; 1077 } 1078 1079 return generic_ide_ioctl(drive, file, bdev, cmd, arg); 1080 1081read_val: 1082 mutex_lock(&ide_setting_mtx); 1083 spin_lock_irqsave(&ide_lock, flags); 1084 err = *val; 1085 spin_unlock_irqrestore(&ide_lock, flags); 1086 mutex_unlock(&ide_setting_mtx); 1087 return err >= 0 ? put_user(err, (long __user *)arg) : err; 1088 1089set_val: 1090 if (bdev != bdev->bd_contains) 1091 err = -EINVAL; 1092 else { 1093 if (!capable(CAP_SYS_ADMIN)) 1094 err = -EACCES; 1095 else { 1096 mutex_lock(&ide_setting_mtx); 1097 err = setfunc(drive, arg); 1098 mutex_unlock(&ide_setting_mtx); 1099 } 1100 } 1101 return err; 1102} 1103 1104static int idedisk_media_changed(struct gendisk *disk) 1105{ 1106 struct ide_disk_obj *idkp = ide_disk_g(disk); 1107 ide_drive_t *drive = idkp->drive; 1108 1109 /* do not scan partitions twice if this is a removable device */ 1110 if (drive->attach) { 1111 drive->attach = 0; 1112 return 0; 1113 } 1114 /* if removable, always assume it was changed */ 1115 return drive->removable; 1116} 1117 1118static int idedisk_revalidate_disk(struct gendisk *disk) 1119{ 1120 struct ide_disk_obj *idkp = ide_disk_g(disk); 1121 set_capacity(disk, idedisk_capacity(idkp->drive)); 1122 return 0; 1123} 1124 1125static struct block_device_operations idedisk_ops = { 1126 .owner = THIS_MODULE, 1127 .open = idedisk_open, 1128 .release = idedisk_release, 1129 .ioctl = idedisk_ioctl, 1130 .getgeo = idedisk_getgeo, 1131 .media_changed = idedisk_media_changed, 1132 .revalidate_disk = idedisk_revalidate_disk 1133}; 1134 1135MODULE_DESCRIPTION("ATA DISK Driver"); 1136 1137static int ide_disk_probe(ide_drive_t *drive) 1138{ 1139 struct ide_disk_obj *idkp; 1140 struct gendisk *g; 1141 1142 /* strstr("foo", "") is non-NULL */ 1143 if (!strstr("ide-disk", drive->driver_req)) 1144 goto failed; 1145 if (!drive->present) 1146 goto failed; 1147 if (drive->media != ide_disk) 1148 goto failed; 1149 1150 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); 1151 if (!idkp) 1152 goto failed; 1153 1154 g = alloc_disk_node(1 << PARTN_BITS, 1155 hwif_to_node(drive->hwif)); 1156 if (!g) 1157 goto out_free_idkp; 1158 1159 ide_init_disk(g, drive); 1160 1161 ide_proc_register_driver(drive, &idedisk_driver); 1162 1163 kref_init(&idkp->kref); 1164 1165 idkp->drive = drive; 1166 idkp->driver = &idedisk_driver; 1167 idkp->disk = g; 1168 1169 g->private_data = &idkp->driver; 1170 1171 drive->driver_data = idkp; 1172 1173 idedisk_setup(drive); 1174 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) { 1175 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", 1176 drive->name, drive->head); 1177 drive->attach = 0; 1178 } else 1179 drive->attach = 1; 1180 1181 g->minors = 1 << PARTN_BITS; 1182 g->driverfs_dev = &drive->gendev; 1183 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0; 1184 set_capacity(g, idedisk_capacity(drive)); 1185 g->fops = &idedisk_ops; 1186 add_disk(g); 1187 return 0; 1188 1189out_free_idkp: 1190 kfree(idkp); 1191failed: 1192 return -ENODEV; 1193} 1194 1195static void __exit idedisk_exit(void) 1196{ 1197 driver_unregister(&idedisk_driver.gen_driver); 1198} 1199 1200static int __init idedisk_init(void) 1201{ 1202 return driver_register(&idedisk_driver.gen_driver); 1203} 1204 1205MODULE_ALIAS("ide:*m-disk*"); 1206module_init(idedisk_init); 1207module_exit(idedisk_exit); 1208MODULE_LICENSE("GPL"); 1209