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