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