ide-disk.c revision d12faa2736ebdee025a9aa07b2683c5fa8c86553
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//#define DEBUG 20 21#include <linux/module.h> 22#include <linux/types.h> 23#include <linux/string.h> 24#include <linux/kernel.h> 25#include <linux/timer.h> 26#include <linux/mm.h> 27#include <linux/interrupt.h> 28#include <linux/major.h> 29#include <linux/errno.h> 30#include <linux/genhd.h> 31#include <linux/slab.h> 32#include <linux/delay.h> 33#include <linux/mutex.h> 34#include <linux/leds.h> 35 36#define _IDE_DISK 37 38#include <linux/ide.h> 39 40#include <asm/byteorder.h> 41#include <asm/irq.h> 42#include <asm/uaccess.h> 43#include <asm/io.h> 44#include <asm/div64.h> 45 46struct ide_disk_obj { 47 ide_drive_t *drive; 48 ide_driver_t *driver; 49 struct gendisk *disk; 50 struct kref kref; 51 unsigned int openers; /* protected by BKL for now */ 52}; 53 54static DEFINE_MUTEX(idedisk_ref_mutex); 55 56#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref) 57 58#define ide_disk_g(disk) \ 59 container_of((disk)->private_data, struct ide_disk_obj, driver) 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 kref_get(&idkp->kref); 69 mutex_unlock(&idedisk_ref_mutex); 70 return idkp; 71} 72 73static void ide_disk_release(struct kref *); 74 75static void ide_disk_put(struct ide_disk_obj *idkp) 76{ 77 mutex_lock(&idedisk_ref_mutex); 78 kref_put(&idkp->kref, ide_disk_release); 79 mutex_unlock(&idedisk_ref_mutex); 80} 81 82/* 83 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity" 84 * value for this drive (from its reported identification information). 85 * 86 * Returns: 1 if lba_capacity looks sensible 87 * 0 otherwise 88 * 89 * It is called only once for each drive. 90 */ 91static int lba_capacity_is_ok (struct hd_driveid *id) 92{ 93 unsigned long lba_sects, chs_sects, head, tail; 94 95 /* No non-LBA info .. so valid! */ 96 if (id->cyls == 0) 97 return 1; 98 99 /* 100 * The ATA spec tells large drives to return 101 * C/H/S = 16383/16/63 independent of their size. 102 * Some drives can be jumpered to use 15 heads instead of 16. 103 * Some drives can be jumpered to use 4092 cyls instead of 16383. 104 */ 105 if ((id->cyls == 16383 106 || (id->cyls == 4092 && id->cur_cyls == 16383)) && 107 id->sectors == 63 && 108 (id->heads == 15 || id->heads == 16) && 109 (id->lba_capacity >= 16383*63*id->heads)) 110 return 1; 111 112 lba_sects = id->lba_capacity; 113 chs_sects = id->cyls * id->heads * id->sectors; 114 115 /* perform a rough sanity check on lba_sects: within 10% is OK */ 116 if ((lba_sects - chs_sects) < chs_sects/10) 117 return 1; 118 119 /* some drives have the word order reversed */ 120 head = ((lba_sects >> 16) & 0xffff); 121 tail = (lba_sects & 0xffff); 122 lba_sects = (head | (tail << 16)); 123 if ((lba_sects - chs_sects) < chs_sects/10) { 124 id->lba_capacity = lba_sects; 125 return 1; /* lba_capacity is (now) good */ 126 } 127 128 return 0; /* lba_capacity value may be bad */ 129} 130 131static const u8 ide_rw_cmds[] = { 132 WIN_MULTREAD, 133 WIN_MULTWRITE, 134 WIN_MULTREAD_EXT, 135 WIN_MULTWRITE_EXT, 136 WIN_READ, 137 WIN_WRITE, 138 WIN_READ_EXT, 139 WIN_WRITE_EXT, 140 WIN_READDMA, 141 WIN_WRITEDMA, 142 WIN_READDMA_EXT, 143 WIN_WRITEDMA_EXT, 144}; 145 146static const u8 ide_data_phases[] = { 147 TASKFILE_MULTI_IN, 148 TASKFILE_MULTI_OUT, 149 TASKFILE_IN, 150 TASKFILE_OUT, 151 TASKFILE_IN_DMA, 152 TASKFILE_OUT_DMA, 153}; 154 155static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma) 156{ 157 u8 index, lba48, write; 158 159 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0; 160 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0; 161 162 if (dma) 163 index = drive->vdma ? 4 : 8; 164 else 165 index = drive->mult_count ? 0 : 4; 166 167 task->tf.command = ide_rw_cmds[index + lba48 + write]; 168 169 if (dma) 170 index = 8; /* fixup index */ 171 172 task->data_phase = ide_data_phases[index / 2 + write]; 173} 174 175/* 176 * __ide_do_rw_disk() issues READ and WRITE commands to a disk, 177 * using LBA if supported, or CHS otherwise, to address sectors. 178 */ 179static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block) 180{ 181 ide_hwif_t *hwif = HWIF(drive); 182 unsigned int dma = drive->using_dma; 183 u16 nsectors = (u16)rq->nr_sectors; 184 u8 lba48 = (drive->addressing == 1) ? 1 : 0; 185 ide_task_t task; 186 struct ide_taskfile *tf = &task.tf; 187 ide_startstop_t rc; 188 189 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) { 190 if (block + rq->nr_sectors > 1ULL << 28) 191 dma = 0; 192 else 193 lba48 = 0; 194 } 195 196 if (!dma) { 197 ide_init_sg_cmd(drive, rq); 198 ide_map_sg(drive, rq); 199 } 200 201 memset(&task, 0, sizeof(task)); 202 task.tf_flags = IDE_TFLAG_NO_SELECT_MASK; /* FIXME? */ 203 task.tf_flags |= (IDE_TFLAG_TF | IDE_TFLAG_DEVICE); 204 205 if (drive->select.b.lba) { 206 if (lba48) { 207 pr_debug("%s: LBA=0x%012llx\n", drive->name, 208 (unsigned long long)block); 209 210 tf->hob_nsect = (nsectors >> 8) & 0xff; 211 tf->hob_lbal = (u8)(block >> 24); 212 if (sizeof(block) != 4) { 213 tf->hob_lbam = (u8)((u64)block >> 32); 214 tf->hob_lbah = (u8)((u64)block >> 40); 215 } 216 217 tf->nsect = nsectors & 0xff; 218 tf->lbal = (u8) block; 219 tf->lbam = (u8)(block >> 8); 220 tf->lbah = (u8)(block >> 16); 221 222 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB); 223 } else { 224 tf->nsect = nsectors & 0xff; 225 tf->lbal = block; 226 tf->lbam = block >>= 8; 227 tf->lbah = block >>= 8; 228 tf->device = (block >> 8) & 0xf; 229 } 230 } else { 231 unsigned int sect,head,cyl,track; 232 track = (int)block / drive->sect; 233 sect = (int)block % drive->sect + 1; 234 head = track % drive->head; 235 cyl = track / drive->head; 236 237 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect); 238 239 tf->nsect = nsectors & 0xff; 240 tf->lbal = sect; 241 tf->lbam = cyl; 242 tf->lbah = cyl >> 8; 243 tf->device = head; 244 } 245 246 if (rq_data_dir(rq)) 247 task.tf_flags |= IDE_TFLAG_WRITE; 248 249 ide_tf_set_cmd(drive, &task, dma); 250 if (!dma) 251 hwif->data_phase = task.data_phase; 252 task.rq = rq; 253 254 rc = do_rw_taskfile(drive, &task); 255 256 if (rc == ide_stopped && dma) { 257 /* fallback to PIO */ 258 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK; 259 ide_tf_set_cmd(drive, &task, 0); 260 hwif->data_phase = task.data_phase; 261 ide_init_sg_cmd(drive, rq); 262 rc = do_rw_taskfile(drive, &task); 263 } 264 265 return rc; 266} 267 268/* 269 * 268435455 == 137439 MB or 28bit limit 270 * 320173056 == 163929 MB or 48bit addressing 271 * 1073741822 == 549756 MB or 48bit addressing fake drive 272 */ 273 274static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, 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 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 531} 532 533static int proc_idedisk_read_capacity 534 (char *page, char **start, off_t off, int count, int *eof, void *data) 535{ 536 ide_drive_t*drive = (ide_drive_t *)data; 537 int len; 538 539 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive)); 540 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 541} 542 543static int proc_idedisk_read_smart_thresholds 544 (char *page, char **start, off_t off, int count, int *eof, void *data) 545{ 546 ide_drive_t *drive = (ide_drive_t *)data; 547 int len = 0, i = 0; 548 549 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) { 550 unsigned short *val = (unsigned short *) page; 551 char *out = ((char *)val) + (SECTOR_WORDS * 4); 552 page = out; 553 do { 554 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n'); 555 val += 1; 556 } while (i < (SECTOR_WORDS * 2)); 557 len = out - page; 558 } 559 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 560} 561 562static int proc_idedisk_read_smart_values 563 (char *page, char **start, off_t off, int count, int *eof, void *data) 564{ 565 ide_drive_t *drive = (ide_drive_t *)data; 566 int len = 0, i = 0; 567 568 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) { 569 unsigned short *val = (unsigned short *) page; 570 char *out = ((char *)val) + (SECTOR_WORDS * 4); 571 page = out; 572 do { 573 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n'); 574 val += 1; 575 } while (i < (SECTOR_WORDS * 2)); 576 len = out - page; 577 } 578 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 579} 580 581static ide_proc_entry_t idedisk_proc[] = { 582 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL }, 583 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL }, 584 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL }, 585 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL }, 586 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL }, 587 { NULL, 0, NULL, NULL } 588}; 589#endif /* CONFIG_IDE_PROC_FS */ 590 591static void idedisk_prepare_flush(struct request_queue *q, struct request *rq) 592{ 593 ide_drive_t *drive = q->queuedata; 594 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC); 595 596 /* FIXME: map struct ide_taskfile on rq->cmd[] */ 597 BUG_ON(task == NULL); 598 599 memset(task, 0, sizeof(*task)); 600 if (ide_id_has_flush_cache_ext(drive->id) && 601 (drive->capacity64 >= (1UL << 28))) 602 task->tf.command = WIN_FLUSH_CACHE_EXT; 603 else 604 task->tf.command = WIN_FLUSH_CACHE; 605 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE | 606 IDE_TFLAG_DYN; 607 task->data_phase = TASKFILE_NO_DATA; 608 609 rq->cmd_type = REQ_TYPE_ATA_TASKFILE; 610 rq->cmd_flags |= REQ_SOFTBARRIER; 611 rq->special = task; 612} 613 614/* 615 * This is tightly woven into the driver->do_special can not touch. 616 * DON'T do it again until a total personality rewrite is committed. 617 */ 618static int set_multcount(ide_drive_t *drive, int arg) 619{ 620 struct request rq; 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 ide_init_drive_cmd (&rq); 629 rq.cmd_type = REQ_TYPE_ATA_TASKFILE; 630 631 drive->mult_req = arg; 632 drive->special.b.set_multmode = 1; 633 (void) ide_do_drive_cmd (drive, &rq, ide_wait); 634 return (drive->mult_count == arg) ? 0 : -EIO; 635} 636 637static int set_nowerr(ide_drive_t *drive, int arg) 638{ 639 if (arg < 0 || arg > 1) 640 return -EINVAL; 641 642 if (ide_spin_wait_hwgroup(drive)) 643 return -EBUSY; 644 drive->nowerr = arg; 645 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT; 646 spin_unlock_irq(&ide_lock); 647 return 0; 648} 649 650static void update_ordered(ide_drive_t *drive) 651{ 652 struct hd_driveid *id = drive->id; 653 unsigned ordered = QUEUE_ORDERED_NONE; 654 prepare_flush_fn *prep_fn = NULL; 655 656 if (drive->wcache) { 657 unsigned long long capacity; 658 int barrier; 659 /* 660 * We must avoid issuing commands a drive does not 661 * understand or we may crash it. We check flush cache 662 * is supported. We also check we have the LBA48 flush 663 * cache if the drive capacity is too large. By this 664 * time we have trimmed the drive capacity if LBA48 is 665 * not available so we don't need to recheck that. 666 */ 667 capacity = idedisk_capacity(drive); 668 barrier = ide_id_has_flush_cache(id) && !drive->noflush && 669 (drive->addressing == 0 || capacity <= (1ULL << 28) || 670 ide_id_has_flush_cache_ext(id)); 671 672 printk(KERN_INFO "%s: cache flushes %ssupported\n", 673 drive->name, barrier ? "" : "not "); 674 675 if (barrier) { 676 ordered = QUEUE_ORDERED_DRAIN_FLUSH; 677 prep_fn = idedisk_prepare_flush; 678 } 679 } else 680 ordered = QUEUE_ORDERED_DRAIN; 681 682 blk_queue_ordered(drive->queue, ordered, prep_fn); 683} 684 685static int write_cache(ide_drive_t *drive, int arg) 686{ 687 ide_task_t args; 688 int err = 1; 689 690 if (arg < 0 || arg > 1) 691 return -EINVAL; 692 693 if (ide_id_has_flush_cache(drive->id)) { 694 memset(&args, 0, sizeof(ide_task_t)); 695 args.tf.feature = arg ? 696 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE; 697 args.tf.command = WIN_SETFEATURES; 698 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 699 err = ide_no_data_taskfile(drive, &args); 700 if (err == 0) 701 drive->wcache = arg; 702 } 703 704 update_ordered(drive); 705 706 return err; 707} 708 709static int do_idedisk_flushcache (ide_drive_t *drive) 710{ 711 ide_task_t args; 712 713 memset(&args, 0, sizeof(ide_task_t)); 714 if (ide_id_has_flush_cache_ext(drive->id)) 715 args.tf.command = WIN_FLUSH_CACHE_EXT; 716 else 717 args.tf.command = WIN_FLUSH_CACHE; 718 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 719 return ide_no_data_taskfile(drive, &args); 720} 721 722static int set_acoustic (ide_drive_t *drive, int arg) 723{ 724 ide_task_t args; 725 726 if (arg < 0 || arg > 254) 727 return -EINVAL; 728 729 memset(&args, 0, sizeof(ide_task_t)); 730 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM; 731 args.tf.nsect = arg; 732 args.tf.command = WIN_SETFEATURES; 733 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 734 ide_no_data_taskfile(drive, &args); 735 drive->acoustic = arg; 736 return 0; 737} 738 739/* 740 * drive->addressing: 741 * 0: 28-bit 742 * 1: 48-bit 743 * 2: 48-bit capable doing 28-bit 744 */ 745static int set_lba_addressing(ide_drive_t *drive, int arg) 746{ 747 if (arg < 0 || arg > 2) 748 return -EINVAL; 749 750 drive->addressing = 0; 751 752 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) 753 return 0; 754 755 if (!idedisk_supports_lba48(drive->id)) 756 return -EIO; 757 drive->addressing = arg; 758 return 0; 759} 760 761#ifdef CONFIG_IDE_PROC_FS 762static void idedisk_add_settings(ide_drive_t *drive) 763{ 764 struct hd_driveid *id = drive->id; 765 766 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL); 767 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL); 768 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL); 769 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing); 770 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount); 771 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr); 772 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL); 773 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache); 774 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic); 775 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL); 776 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL); 777} 778#else 779static inline void idedisk_add_settings(ide_drive_t *drive) { ; } 780#endif 781 782static void idedisk_setup (ide_drive_t *drive) 783{ 784 ide_hwif_t *hwif = drive->hwif; 785 struct hd_driveid *id = drive->id; 786 unsigned long long capacity; 787 788 idedisk_add_settings(drive); 789 790 if (drive->id_read == 0) 791 return; 792 793 if (drive->removable) { 794 /* 795 * Removable disks (eg. SYQUEST); ignore 'WD' drives 796 */ 797 if (id->model[0] != 'W' || id->model[1] != 'D') { 798 drive->doorlocking = 1; 799 } 800 } 801 802 (void)set_lba_addressing(drive, 1); 803 804 if (drive->addressing == 1) { 805 int max_s = 2048; 806 807 if (max_s > hwif->rqsize) 808 max_s = hwif->rqsize; 809 810 blk_queue_max_sectors(drive->queue, max_s); 811 } 812 813 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2); 814 815 /* calculate drive capacity, and select LBA if possible */ 816 init_idedisk_capacity (drive); 817 818 /* limit drive capacity to 137GB if LBA48 cannot be used */ 819 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) { 820 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity " 821 "%llu sectors (%llu MB)\n", 822 drive->name, (unsigned long long)drive->capacity64, 823 sectors_to_MB(drive->capacity64)); 824 drive->capacity64 = 1ULL << 28; 825 } 826 827 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) { 828 if (drive->capacity64 > 1ULL << 28) { 829 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will" 830 " be used for accessing sectors > %u\n", 831 drive->name, 1 << 28); 832 } else 833 drive->addressing = 0; 834 } 835 836 /* 837 * if possible, give fdisk access to more of the drive, 838 * by correcting bios_cyls: 839 */ 840 capacity = idedisk_capacity (drive); 841 if (!drive->forced_geom) { 842 843 if (idedisk_supports_lba48(drive->id)) { 844 /* compatibility */ 845 drive->bios_sect = 63; 846 drive->bios_head = 255; 847 } 848 849 if (drive->bios_sect && drive->bios_head) { 850 unsigned int cap0 = capacity; /* truncate to 32 bits */ 851 unsigned int cylsz, cyl; 852 853 if (cap0 != capacity) 854 drive->bios_cyl = 65535; 855 else { 856 cylsz = drive->bios_sect * drive->bios_head; 857 cyl = cap0 / cylsz; 858 if (cyl > 65535) 859 cyl = 65535; 860 if (cyl > drive->bios_cyl) 861 drive->bios_cyl = cyl; 862 } 863 } 864 } 865 printk(KERN_INFO "%s: %llu sectors (%llu MB)", 866 drive->name, capacity, sectors_to_MB(capacity)); 867 868 /* Only print cache size when it was specified */ 869 if (id->buf_size) 870 printk(KERN_CONT " w/%dKiB Cache", id->buf_size / 2); 871 872 printk(KERN_CONT ", CHS=%d/%d/%d\n", 873 drive->bios_cyl, drive->bios_head, drive->bios_sect); 874 875 /* write cache enabled? */ 876 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5))) 877 drive->wcache = 1; 878 879 write_cache(drive, 1); 880} 881 882static void ide_cacheflush_p(ide_drive_t *drive) 883{ 884 if (!drive->wcache || !ide_id_has_flush_cache(drive->id)) 885 return; 886 887 if (do_idedisk_flushcache(drive)) 888 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name); 889} 890 891static void ide_disk_remove(ide_drive_t *drive) 892{ 893 struct ide_disk_obj *idkp = drive->driver_data; 894 struct gendisk *g = idkp->disk; 895 896 ide_proc_unregister_driver(drive, idkp->driver); 897 898 del_gendisk(g); 899 900 ide_cacheflush_p(drive); 901 902 ide_disk_put(idkp); 903} 904 905static void ide_disk_release(struct kref *kref) 906{ 907 struct ide_disk_obj *idkp = to_ide_disk(kref); 908 ide_drive_t *drive = idkp->drive; 909 struct gendisk *g = idkp->disk; 910 911 drive->driver_data = NULL; 912 g->private_data = NULL; 913 put_disk(g); 914 kfree(idkp); 915} 916 917static int ide_disk_probe(ide_drive_t *drive); 918 919/* 920 * On HPA drives the capacity needs to be 921 * reinitilized on resume otherwise the disk 922 * can not be used and a hard reset is required 923 */ 924static void ide_disk_resume(ide_drive_t *drive) 925{ 926 if (idedisk_supports_hpa(drive->id)) 927 init_idedisk_capacity(drive); 928} 929 930static void ide_device_shutdown(ide_drive_t *drive) 931{ 932#ifdef CONFIG_ALPHA 933 /* On Alpha, halt(8) doesn't actually turn the machine off, 934 it puts you into the sort of firmware monitor. Typically, 935 it's used to boot another kernel image, so it's not much 936 different from reboot(8). Therefore, we don't need to 937 spin down the disk in this case, especially since Alpha 938 firmware doesn't handle disks in standby mode properly. 939 On the other hand, it's reasonably safe to turn the power 940 off when the shutdown process reaches the firmware prompt, 941 as the firmware initialization takes rather long time - 942 at least 10 seconds, which should be sufficient for 943 the disk to expire its write cache. */ 944 if (system_state != SYSTEM_POWER_OFF) { 945#else 946 if (system_state == SYSTEM_RESTART) { 947#endif 948 ide_cacheflush_p(drive); 949 return; 950 } 951 952 printk(KERN_INFO "Shutdown: %s\n", drive->name); 953 954 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND); 955} 956 957static ide_driver_t idedisk_driver = { 958 .gen_driver = { 959 .owner = THIS_MODULE, 960 .name = "ide-disk", 961 .bus = &ide_bus_type, 962 }, 963 .probe = ide_disk_probe, 964 .remove = ide_disk_remove, 965 .resume = ide_disk_resume, 966 .shutdown = ide_device_shutdown, 967 .version = IDEDISK_VERSION, 968 .media = ide_disk, 969 .supports_dsc_overlap = 0, 970 .do_request = ide_do_rw_disk, 971 .end_request = ide_end_request, 972 .error = __ide_error, 973 .abort = __ide_abort, 974#ifdef CONFIG_IDE_PROC_FS 975 .proc = idedisk_proc, 976#endif 977}; 978 979static int idedisk_set_doorlock(ide_drive_t *drive, int on) 980{ 981 ide_task_t task; 982 983 memset(&task, 0, sizeof(task)); 984 task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK; 985 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 986 987 return ide_no_data_taskfile(drive, &task); 988} 989 990static int idedisk_open(struct inode *inode, struct file *filp) 991{ 992 struct gendisk *disk = inode->i_bdev->bd_disk; 993 struct ide_disk_obj *idkp; 994 ide_drive_t *drive; 995 996 if (!(idkp = ide_disk_get(disk))) 997 return -ENXIO; 998 999 drive = idkp->drive; 1000 1001 idkp->openers++; 1002 1003 if (drive->removable && idkp->openers == 1) { 1004 check_disk_change(inode->i_bdev); 1005 /* 1006 * Ignore the return code from door_lock, 1007 * since the open() has already succeeded, 1008 * and the door_lock is irrelevant at this point. 1009 */ 1010 if (drive->doorlocking && idedisk_set_doorlock(drive, 1)) 1011 drive->doorlocking = 0; 1012 } 1013 return 0; 1014} 1015 1016static int idedisk_release(struct inode *inode, struct file *filp) 1017{ 1018 struct gendisk *disk = inode->i_bdev->bd_disk; 1019 struct ide_disk_obj *idkp = ide_disk_g(disk); 1020 ide_drive_t *drive = idkp->drive; 1021 1022 if (idkp->openers == 1) 1023 ide_cacheflush_p(drive); 1024 1025 if (drive->removable && idkp->openers == 1) { 1026 if (drive->doorlocking && idedisk_set_doorlock(drive, 0)) 1027 drive->doorlocking = 0; 1028 } 1029 1030 idkp->openers--; 1031 1032 ide_disk_put(idkp); 1033 1034 return 0; 1035} 1036 1037static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo) 1038{ 1039 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1040 ide_drive_t *drive = idkp->drive; 1041 1042 geo->heads = drive->bios_head; 1043 geo->sectors = drive->bios_sect; 1044 geo->cylinders = (u16)drive->bios_cyl; /* truncate */ 1045 return 0; 1046} 1047 1048static int idedisk_ioctl(struct inode *inode, struct file *file, 1049 unsigned int cmd, unsigned long arg) 1050{ 1051 unsigned long flags; 1052 struct block_device *bdev = inode->i_bdev; 1053 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1054 ide_drive_t *drive = idkp->drive; 1055 int err, (*setfunc)(ide_drive_t *, int); 1056 u8 *val; 1057 1058 switch (cmd) { 1059 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val; 1060 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val; 1061 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val; 1062 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val; 1063 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val; 1064 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val; 1065 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val; 1066 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val; 1067 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val; 1068 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val; 1069 } 1070 1071 return generic_ide_ioctl(drive, file, bdev, cmd, arg); 1072 1073read_val: 1074 mutex_lock(&ide_setting_mtx); 1075 spin_lock_irqsave(&ide_lock, flags); 1076 err = *val; 1077 spin_unlock_irqrestore(&ide_lock, flags); 1078 mutex_unlock(&ide_setting_mtx); 1079 return err >= 0 ? put_user(err, (long __user *)arg) : err; 1080 1081set_val: 1082 if (bdev != bdev->bd_contains) 1083 err = -EINVAL; 1084 else { 1085 if (!capable(CAP_SYS_ADMIN)) 1086 err = -EACCES; 1087 else { 1088 mutex_lock(&ide_setting_mtx); 1089 err = setfunc(drive, arg); 1090 mutex_unlock(&ide_setting_mtx); 1091 } 1092 } 1093 return err; 1094} 1095 1096static int idedisk_media_changed(struct gendisk *disk) 1097{ 1098 struct ide_disk_obj *idkp = ide_disk_g(disk); 1099 ide_drive_t *drive = idkp->drive; 1100 1101 /* do not scan partitions twice if this is a removable device */ 1102 if (drive->attach) { 1103 drive->attach = 0; 1104 return 0; 1105 } 1106 /* if removable, always assume it was changed */ 1107 return drive->removable; 1108} 1109 1110static int idedisk_revalidate_disk(struct gendisk *disk) 1111{ 1112 struct ide_disk_obj *idkp = ide_disk_g(disk); 1113 set_capacity(disk, idedisk_capacity(idkp->drive)); 1114 return 0; 1115} 1116 1117static struct block_device_operations idedisk_ops = { 1118 .owner = THIS_MODULE, 1119 .open = idedisk_open, 1120 .release = idedisk_release, 1121 .ioctl = idedisk_ioctl, 1122 .getgeo = idedisk_getgeo, 1123 .media_changed = idedisk_media_changed, 1124 .revalidate_disk= idedisk_revalidate_disk 1125}; 1126 1127MODULE_DESCRIPTION("ATA DISK Driver"); 1128 1129static int ide_disk_probe(ide_drive_t *drive) 1130{ 1131 struct ide_disk_obj *idkp; 1132 struct gendisk *g; 1133 1134 /* strstr("foo", "") is non-NULL */ 1135 if (!strstr("ide-disk", drive->driver_req)) 1136 goto failed; 1137 if (!drive->present) 1138 goto failed; 1139 if (drive->media != ide_disk) 1140 goto failed; 1141 1142 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); 1143 if (!idkp) 1144 goto failed; 1145 1146 g = alloc_disk_node(1 << PARTN_BITS, 1147 hwif_to_node(drive->hwif)); 1148 if (!g) 1149 goto out_free_idkp; 1150 1151 ide_init_disk(g, drive); 1152 1153 ide_proc_register_driver(drive, &idedisk_driver); 1154 1155 kref_init(&idkp->kref); 1156 1157 idkp->drive = drive; 1158 idkp->driver = &idedisk_driver; 1159 idkp->disk = g; 1160 1161 g->private_data = &idkp->driver; 1162 1163 drive->driver_data = idkp; 1164 1165 idedisk_setup(drive); 1166 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) { 1167 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", 1168 drive->name, drive->head); 1169 drive->attach = 0; 1170 } else 1171 drive->attach = 1; 1172 1173 g->minors = 1 << PARTN_BITS; 1174 g->driverfs_dev = &drive->gendev; 1175 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0; 1176 set_capacity(g, idedisk_capacity(drive)); 1177 g->fops = &idedisk_ops; 1178 add_disk(g); 1179 return 0; 1180 1181out_free_idkp: 1182 kfree(idkp); 1183failed: 1184 return -ENODEV; 1185} 1186 1187static void __exit idedisk_exit (void) 1188{ 1189 driver_unregister(&idedisk_driver.gen_driver); 1190} 1191 1192static int __init idedisk_init(void) 1193{ 1194 return driver_register(&idedisk_driver.gen_driver); 1195} 1196 1197MODULE_ALIAS("ide:*m-disk*"); 1198module_init(idedisk_init); 1199module_exit(idedisk_exit); 1200MODULE_LICENSE("GPL"); 1201