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