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