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