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