ide-disk.c revision 238e4f142c33bb34440cc64029dde7b9fbc4e65f
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->host_flags & IDE_HFLAG_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 484/* 485 * Some disks report total number of sectors instead of 486 * maximum sector address. We list them here. 487 */ 488static const struct drive_list_entry hpa_list[] = { 489 { "ST340823A", NULL }, 490 { "ST320413A", NULL }, 491 { NULL, NULL } 492}; 493 494static void idedisk_check_hpa(ide_drive_t *drive) 495{ 496 unsigned long long capacity, set_max; 497 int lba48 = idedisk_supports_lba48(drive->id); 498 499 capacity = drive->capacity64; 500 if (lba48) 501 set_max = idedisk_read_native_max_address_ext(drive); 502 else 503 set_max = idedisk_read_native_max_address(drive); 504 505 if (ide_in_drive_list(drive->id, hpa_list)) { 506 /* 507 * Since we are inclusive wrt to firmware revisions do this 508 * extra check and apply the workaround only when needed. 509 */ 510 if (set_max == capacity + 1) 511 set_max--; 512 } 513 514 if (set_max <= capacity) 515 return; 516 517 printk(KERN_INFO "%s: Host Protected Area detected.\n" 518 "\tcurrent capacity is %llu sectors (%llu MB)\n" 519 "\tnative capacity is %llu sectors (%llu MB)\n", 520 drive->name, 521 capacity, sectors_to_MB(capacity), 522 set_max, sectors_to_MB(set_max)); 523 524 if (lba48) 525 set_max = idedisk_set_max_address_ext(drive, set_max); 526 else 527 set_max = idedisk_set_max_address(drive, set_max); 528 if (set_max) { 529 drive->capacity64 = set_max; 530 printk(KERN_INFO "%s: Host Protected Area disabled.\n", 531 drive->name); 532 } 533} 534 535/* 536 * Compute drive->capacity, the full capacity of the drive 537 * Called with drive->id != NULL. 538 * 539 * To compute capacity, this uses either of 540 * 541 * 1. CHS value set by user (whatever user sets will be trusted) 542 * 2. LBA value from target drive (require new ATA feature) 543 * 3. LBA value from system BIOS (new one is OK, old one may break) 544 * 4. CHS value from system BIOS (traditional style) 545 * 546 * in above order (i.e., if value of higher priority is available, 547 * reset will be ignored). 548 */ 549static void init_idedisk_capacity (ide_drive_t *drive) 550{ 551 struct hd_driveid *id = drive->id; 552 /* 553 * If this drive supports the Host Protected Area feature set, 554 * then we may need to change our opinion about the drive's capacity. 555 */ 556 int hpa = idedisk_supports_hpa(id); 557 558 if (idedisk_supports_lba48(id)) { 559 /* drive speaks 48-bit LBA */ 560 drive->select.b.lba = 1; 561 drive->capacity64 = id->lba_capacity_2; 562 if (hpa) 563 idedisk_check_hpa(drive); 564 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) { 565 /* drive speaks 28-bit LBA */ 566 drive->select.b.lba = 1; 567 drive->capacity64 = id->lba_capacity; 568 if (hpa) 569 idedisk_check_hpa(drive); 570 } else { 571 /* drive speaks boring old 28-bit CHS */ 572 drive->capacity64 = drive->cyl * drive->head * drive->sect; 573 } 574} 575 576static sector_t idedisk_capacity (ide_drive_t *drive) 577{ 578 return drive->capacity64 - drive->sect0; 579} 580 581#ifdef CONFIG_IDE_PROC_FS 582static int smart_enable(ide_drive_t *drive) 583{ 584 ide_task_t args; 585 586 memset(&args, 0, sizeof(ide_task_t)); 587 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE; 588 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS; 589 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS; 590 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART; 591 args.command_type = IDE_DRIVE_TASK_NO_DATA; 592 args.handler = &task_no_data_intr; 593 return ide_raw_taskfile(drive, &args, NULL); 594} 595 596static int get_smart_values(ide_drive_t *drive, u8 *buf) 597{ 598 ide_task_t args; 599 600 memset(&args, 0, sizeof(ide_task_t)); 601 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES; 602 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01; 603 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS; 604 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS; 605 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART; 606 args.command_type = IDE_DRIVE_TASK_IN; 607 args.data_phase = TASKFILE_IN; 608 args.handler = &task_in_intr; 609 (void) smart_enable(drive); 610 return ide_raw_taskfile(drive, &args, buf); 611} 612 613static int get_smart_thresholds(ide_drive_t *drive, u8 *buf) 614{ 615 ide_task_t args; 616 memset(&args, 0, sizeof(ide_task_t)); 617 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS; 618 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01; 619 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS; 620 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS; 621 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART; 622 args.command_type = IDE_DRIVE_TASK_IN; 623 args.data_phase = TASKFILE_IN; 624 args.handler = &task_in_intr; 625 (void) smart_enable(drive); 626 return ide_raw_taskfile(drive, &args, buf); 627} 628 629static int proc_idedisk_read_cache 630 (char *page, char **start, off_t off, int count, int *eof, void *data) 631{ 632 ide_drive_t *drive = (ide_drive_t *) data; 633 char *out = page; 634 int len; 635 636 if (drive->id_read) 637 len = sprintf(out,"%i\n", drive->id->buf_size / 2); 638 else 639 len = sprintf(out,"(none)\n"); 640 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 641} 642 643static int proc_idedisk_read_capacity 644 (char *page, char **start, off_t off, int count, int *eof, void *data) 645{ 646 ide_drive_t*drive = (ide_drive_t *)data; 647 int len; 648 649 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive)); 650 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 651} 652 653static int proc_idedisk_read_smart_thresholds 654 (char *page, char **start, off_t off, int count, int *eof, void *data) 655{ 656 ide_drive_t *drive = (ide_drive_t *)data; 657 int len = 0, i = 0; 658 659 if (!get_smart_thresholds(drive, page)) { 660 unsigned short *val = (unsigned short *) page; 661 char *out = ((char *)val) + (SECTOR_WORDS * 4); 662 page = out; 663 do { 664 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n'); 665 val += 1; 666 } while (i < (SECTOR_WORDS * 2)); 667 len = out - page; 668 } 669 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 670} 671 672static int proc_idedisk_read_smart_values 673 (char *page, char **start, off_t off, int count, int *eof, void *data) 674{ 675 ide_drive_t *drive = (ide_drive_t *)data; 676 int len = 0, i = 0; 677 678 if (!get_smart_values(drive, page)) { 679 unsigned short *val = (unsigned short *) page; 680 char *out = ((char *)val) + (SECTOR_WORDS * 4); 681 page = out; 682 do { 683 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n'); 684 val += 1; 685 } while (i < (SECTOR_WORDS * 2)); 686 len = out - page; 687 } 688 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 689} 690 691static ide_proc_entry_t idedisk_proc[] = { 692 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL }, 693 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL }, 694 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL }, 695 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL }, 696 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL }, 697 { NULL, 0, NULL, NULL } 698}; 699#endif /* CONFIG_IDE_PROC_FS */ 700 701static void idedisk_prepare_flush(struct request_queue *q, struct request *rq) 702{ 703 ide_drive_t *drive = q->queuedata; 704 705 memset(rq->cmd, 0, sizeof(rq->cmd)); 706 707 if (ide_id_has_flush_cache_ext(drive->id) && 708 (drive->capacity64 >= (1UL << 28))) 709 rq->cmd[0] = WIN_FLUSH_CACHE_EXT; 710 else 711 rq->cmd[0] = WIN_FLUSH_CACHE; 712 713 714 rq->cmd_type = REQ_TYPE_ATA_TASK; 715 rq->cmd_flags |= REQ_SOFTBARRIER; 716 rq->buffer = rq->cmd; 717} 718 719/* 720 * This is tightly woven into the driver->do_special can not touch. 721 * DON'T do it again until a total personality rewrite is committed. 722 */ 723static int set_multcount(ide_drive_t *drive, int arg) 724{ 725 struct request rq; 726 727 if (arg < 0 || arg > drive->id->max_multsect) 728 return -EINVAL; 729 730 if (drive->special.b.set_multmode) 731 return -EBUSY; 732 ide_init_drive_cmd (&rq); 733 rq.cmd_type = REQ_TYPE_ATA_CMD; 734 drive->mult_req = arg; 735 drive->special.b.set_multmode = 1; 736 (void) ide_do_drive_cmd (drive, &rq, ide_wait); 737 return (drive->mult_count == arg) ? 0 : -EIO; 738} 739 740static int set_nowerr(ide_drive_t *drive, int arg) 741{ 742 if (arg < 0 || arg > 1) 743 return -EINVAL; 744 745 if (ide_spin_wait_hwgroup(drive)) 746 return -EBUSY; 747 drive->nowerr = arg; 748 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT; 749 spin_unlock_irq(&ide_lock); 750 return 0; 751} 752 753static void update_ordered(ide_drive_t *drive) 754{ 755 struct hd_driveid *id = drive->id; 756 unsigned ordered = QUEUE_ORDERED_NONE; 757 prepare_flush_fn *prep_fn = NULL; 758 759 if (drive->wcache) { 760 unsigned long long capacity; 761 int barrier; 762 /* 763 * We must avoid issuing commands a drive does not 764 * understand or we may crash it. We check flush cache 765 * is supported. We also check we have the LBA48 flush 766 * cache if the drive capacity is too large. By this 767 * time we have trimmed the drive capacity if LBA48 is 768 * not available so we don't need to recheck that. 769 */ 770 capacity = idedisk_capacity(drive); 771 barrier = ide_id_has_flush_cache(id) && !drive->noflush && 772 (drive->addressing == 0 || capacity <= (1ULL << 28) || 773 ide_id_has_flush_cache_ext(id)); 774 775 printk(KERN_INFO "%s: cache flushes %ssupported\n", 776 drive->name, barrier ? "" : "not "); 777 778 if (barrier) { 779 ordered = QUEUE_ORDERED_DRAIN_FLUSH; 780 prep_fn = idedisk_prepare_flush; 781 } 782 } else 783 ordered = QUEUE_ORDERED_DRAIN; 784 785 blk_queue_ordered(drive->queue, ordered, prep_fn); 786} 787 788static int write_cache(ide_drive_t *drive, int arg) 789{ 790 ide_task_t args; 791 int err = 1; 792 793 if (arg < 0 || arg > 1) 794 return -EINVAL; 795 796 if (ide_id_has_flush_cache(drive->id)) { 797 memset(&args, 0, sizeof(ide_task_t)); 798 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ? 799 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE; 800 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES; 801 args.command_type = IDE_DRIVE_TASK_NO_DATA; 802 args.handler = &task_no_data_intr; 803 err = ide_raw_taskfile(drive, &args, NULL); 804 if (err == 0) 805 drive->wcache = arg; 806 } 807 808 update_ordered(drive); 809 810 return err; 811} 812 813static int do_idedisk_flushcache (ide_drive_t *drive) 814{ 815 ide_task_t args; 816 817 memset(&args, 0, sizeof(ide_task_t)); 818 if (ide_id_has_flush_cache_ext(drive->id)) 819 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT; 820 else 821 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE; 822 args.command_type = IDE_DRIVE_TASK_NO_DATA; 823 args.handler = &task_no_data_intr; 824 return ide_raw_taskfile(drive, &args, NULL); 825} 826 827static int set_acoustic (ide_drive_t *drive, int arg) 828{ 829 ide_task_t args; 830 831 if (arg < 0 || arg > 254) 832 return -EINVAL; 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 if (arg < 0 || arg > 2) 855 return -EINVAL; 856 857 drive->addressing = 0; 858 859 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) 860 return 0; 861 862 if (!idedisk_supports_lba48(drive->id)) 863 return -EIO; 864 drive->addressing = arg; 865 return 0; 866} 867 868#ifdef CONFIG_IDE_PROC_FS 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, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL); 874 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL); 875 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL); 876 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing); 877 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL); 878 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount); 879 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr); 880 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL); 881 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache); 882 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic); 883 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL); 884 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL); 885} 886#else 887static inline void idedisk_add_settings(ide_drive_t *drive) { ; } 888#endif 889 890static void idedisk_setup (ide_drive_t *drive) 891{ 892 ide_hwif_t *hwif = drive->hwif; 893 struct hd_driveid *id = drive->id; 894 unsigned long long capacity; 895 896 idedisk_add_settings(drive); 897 898 if (drive->id_read == 0) 899 return; 900 901 if (drive->removable) { 902 /* 903 * Removable disks (eg. SYQUEST); ignore 'WD' drives 904 */ 905 if (id->model[0] != 'W' || id->model[1] != 'D') { 906 drive->doorlocking = 1; 907 } 908 } 909 910 (void)set_lba_addressing(drive, 1); 911 912 if (drive->addressing == 1) { 913 int max_s = 2048; 914 915 if (max_s > hwif->rqsize) 916 max_s = hwif->rqsize; 917 918 blk_queue_max_sectors(drive->queue, max_s); 919 } 920 921 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2); 922 923 /* calculate drive capacity, and select LBA if possible */ 924 init_idedisk_capacity (drive); 925 926 /* limit drive capacity to 137GB if LBA48 cannot be used */ 927 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) { 928 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity " 929 "%llu sectors (%llu MB)\n", 930 drive->name, (unsigned long long)drive->capacity64, 931 sectors_to_MB(drive->capacity64)); 932 drive->capacity64 = 1ULL << 28; 933 } 934 935 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) { 936 if (drive->capacity64 > 1ULL << 28) { 937 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will" 938 " be used for accessing sectors > %u\n", 939 drive->name, 1 << 28); 940 } else 941 drive->addressing = 0; 942 } 943 944 /* 945 * if possible, give fdisk access to more of the drive, 946 * by correcting bios_cyls: 947 */ 948 capacity = idedisk_capacity (drive); 949 if (!drive->forced_geom) { 950 951 if (idedisk_supports_lba48(drive->id)) { 952 /* compatibility */ 953 drive->bios_sect = 63; 954 drive->bios_head = 255; 955 } 956 957 if (drive->bios_sect && drive->bios_head) { 958 unsigned int cap0 = capacity; /* truncate to 32 bits */ 959 unsigned int cylsz, cyl; 960 961 if (cap0 != capacity) 962 drive->bios_cyl = 65535; 963 else { 964 cylsz = drive->bios_sect * drive->bios_head; 965 cyl = cap0 / cylsz; 966 if (cyl > 65535) 967 cyl = 65535; 968 if (cyl > drive->bios_cyl) 969 drive->bios_cyl = cyl; 970 } 971 } 972 } 973 printk(KERN_INFO "%s: %llu sectors (%llu MB)", 974 drive->name, capacity, sectors_to_MB(capacity)); 975 976 /* Only print cache size when it was specified */ 977 if (id->buf_size) 978 printk (" w/%dKiB Cache", id->buf_size/2); 979 980 printk(", CHS=%d/%d/%d", 981 drive->bios_cyl, drive->bios_head, drive->bios_sect); 982 if (drive->using_dma) 983 ide_dma_verbose(drive); 984 printk("\n"); 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 993static void ide_cacheflush_p(ide_drive_t *drive) 994{ 995 if (!drive->wcache || !ide_id_has_flush_cache(drive->id)) 996 return; 997 998 if (do_idedisk_flushcache(drive)) 999 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name); 1000} 1001 1002static void ide_disk_remove(ide_drive_t *drive) 1003{ 1004 struct ide_disk_obj *idkp = drive->driver_data; 1005 struct gendisk *g = idkp->disk; 1006 1007 ide_proc_unregister_driver(drive, idkp->driver); 1008 1009 del_gendisk(g); 1010 1011 ide_cacheflush_p(drive); 1012 1013 ide_disk_put(idkp); 1014} 1015 1016static void ide_disk_release(struct kref *kref) 1017{ 1018 struct ide_disk_obj *idkp = to_ide_disk(kref); 1019 ide_drive_t *drive = idkp->drive; 1020 struct gendisk *g = idkp->disk; 1021 1022 drive->driver_data = NULL; 1023 g->private_data = NULL; 1024 put_disk(g); 1025 kfree(idkp); 1026} 1027 1028static int ide_disk_probe(ide_drive_t *drive); 1029 1030/* 1031 * On HPA drives the capacity needs to be 1032 * reinitilized on resume otherwise the disk 1033 * can not be used and a hard reset is required 1034 */ 1035static void ide_disk_resume(ide_drive_t *drive) 1036{ 1037 if (idedisk_supports_hpa(drive->id)) 1038 init_idedisk_capacity(drive); 1039} 1040 1041static void ide_device_shutdown(ide_drive_t *drive) 1042{ 1043#ifdef CONFIG_ALPHA 1044 /* On Alpha, halt(8) doesn't actually turn the machine off, 1045 it puts you into the sort of firmware monitor. Typically, 1046 it's used to boot another kernel image, so it's not much 1047 different from reboot(8). Therefore, we don't need to 1048 spin down the disk in this case, especially since Alpha 1049 firmware doesn't handle disks in standby mode properly. 1050 On the other hand, it's reasonably safe to turn the power 1051 off when the shutdown process reaches the firmware prompt, 1052 as the firmware initialization takes rather long time - 1053 at least 10 seconds, which should be sufficient for 1054 the disk to expire its write cache. */ 1055 if (system_state != SYSTEM_POWER_OFF) { 1056#else 1057 if (system_state == SYSTEM_RESTART) { 1058#endif 1059 ide_cacheflush_p(drive); 1060 return; 1061 } 1062 1063 printk("Shutdown: %s\n", drive->name); 1064 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND); 1065} 1066 1067static ide_driver_t idedisk_driver = { 1068 .gen_driver = { 1069 .owner = THIS_MODULE, 1070 .name = "ide-disk", 1071 .bus = &ide_bus_type, 1072 }, 1073 .probe = ide_disk_probe, 1074 .remove = ide_disk_remove, 1075 .resume = ide_disk_resume, 1076 .shutdown = ide_device_shutdown, 1077 .version = IDEDISK_VERSION, 1078 .media = ide_disk, 1079 .supports_dsc_overlap = 0, 1080 .do_request = ide_do_rw_disk, 1081 .end_request = ide_end_request, 1082 .error = __ide_error, 1083 .abort = __ide_abort, 1084#ifdef CONFIG_IDE_PROC_FS 1085 .proc = idedisk_proc, 1086#endif 1087}; 1088 1089static int idedisk_open(struct inode *inode, struct file *filp) 1090{ 1091 struct gendisk *disk = inode->i_bdev->bd_disk; 1092 struct ide_disk_obj *idkp; 1093 ide_drive_t *drive; 1094 1095 if (!(idkp = ide_disk_get(disk))) 1096 return -ENXIO; 1097 1098 drive = idkp->drive; 1099 1100 idkp->openers++; 1101 1102 if (drive->removable && idkp->openers == 1) { 1103 ide_task_t args; 1104 memset(&args, 0, sizeof(ide_task_t)); 1105 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK; 1106 args.command_type = IDE_DRIVE_TASK_NO_DATA; 1107 args.handler = &task_no_data_intr; 1108 check_disk_change(inode->i_bdev); 1109 /* 1110 * Ignore the return code from door_lock, 1111 * since the open() has already succeeded, 1112 * and the door_lock is irrelevant at this point. 1113 */ 1114 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL)) 1115 drive->doorlocking = 0; 1116 } 1117 return 0; 1118} 1119 1120static int idedisk_release(struct inode *inode, struct file *filp) 1121{ 1122 struct gendisk *disk = inode->i_bdev->bd_disk; 1123 struct ide_disk_obj *idkp = ide_disk_g(disk); 1124 ide_drive_t *drive = idkp->drive; 1125 1126 if (idkp->openers == 1) 1127 ide_cacheflush_p(drive); 1128 1129 if (drive->removable && idkp->openers == 1) { 1130 ide_task_t args; 1131 memset(&args, 0, sizeof(ide_task_t)); 1132 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK; 1133 args.command_type = IDE_DRIVE_TASK_NO_DATA; 1134 args.handler = &task_no_data_intr; 1135 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL)) 1136 drive->doorlocking = 0; 1137 } 1138 1139 idkp->openers--; 1140 1141 ide_disk_put(idkp); 1142 1143 return 0; 1144} 1145 1146static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo) 1147{ 1148 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1149 ide_drive_t *drive = idkp->drive; 1150 1151 geo->heads = drive->bios_head; 1152 geo->sectors = drive->bios_sect; 1153 geo->cylinders = (u16)drive->bios_cyl; /* truncate */ 1154 return 0; 1155} 1156 1157static int idedisk_ioctl(struct inode *inode, struct file *file, 1158 unsigned int cmd, unsigned long arg) 1159{ 1160 unsigned long flags; 1161 struct block_device *bdev = inode->i_bdev; 1162 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk); 1163 ide_drive_t *drive = idkp->drive; 1164 int err, (*setfunc)(ide_drive_t *, int); 1165 u8 *val; 1166 1167 switch (cmd) { 1168 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val; 1169 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val; 1170 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val; 1171 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val; 1172 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val; 1173 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val; 1174 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val; 1175 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val; 1176 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val; 1177 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val; 1178 } 1179 1180 return generic_ide_ioctl(drive, file, bdev, cmd, arg); 1181 1182read_val: 1183 mutex_lock(&ide_setting_mtx); 1184 spin_lock_irqsave(&ide_lock, flags); 1185 err = *val; 1186 spin_unlock_irqrestore(&ide_lock, flags); 1187 mutex_unlock(&ide_setting_mtx); 1188 return err >= 0 ? put_user(err, (long __user *)arg) : err; 1189 1190set_val: 1191 if (bdev != bdev->bd_contains) 1192 err = -EINVAL; 1193 else { 1194 if (!capable(CAP_SYS_ADMIN)) 1195 err = -EACCES; 1196 else { 1197 mutex_lock(&ide_setting_mtx); 1198 err = setfunc(drive, arg); 1199 mutex_unlock(&ide_setting_mtx); 1200 } 1201 } 1202 return err; 1203} 1204 1205static int idedisk_media_changed(struct gendisk *disk) 1206{ 1207 struct ide_disk_obj *idkp = ide_disk_g(disk); 1208 ide_drive_t *drive = idkp->drive; 1209 1210 /* do not scan partitions twice if this is a removable device */ 1211 if (drive->attach) { 1212 drive->attach = 0; 1213 return 0; 1214 } 1215 /* if removable, always assume it was changed */ 1216 return drive->removable; 1217} 1218 1219static int idedisk_revalidate_disk(struct gendisk *disk) 1220{ 1221 struct ide_disk_obj *idkp = ide_disk_g(disk); 1222 set_capacity(disk, idedisk_capacity(idkp->drive)); 1223 return 0; 1224} 1225 1226static struct block_device_operations idedisk_ops = { 1227 .owner = THIS_MODULE, 1228 .open = idedisk_open, 1229 .release = idedisk_release, 1230 .ioctl = idedisk_ioctl, 1231 .getgeo = idedisk_getgeo, 1232 .media_changed = idedisk_media_changed, 1233 .revalidate_disk= idedisk_revalidate_disk 1234}; 1235 1236MODULE_DESCRIPTION("ATA DISK Driver"); 1237 1238static int ide_disk_probe(ide_drive_t *drive) 1239{ 1240 struct ide_disk_obj *idkp; 1241 struct gendisk *g; 1242 1243 /* strstr("foo", "") is non-NULL */ 1244 if (!strstr("ide-disk", drive->driver_req)) 1245 goto failed; 1246 if (!drive->present) 1247 goto failed; 1248 if (drive->media != ide_disk) 1249 goto failed; 1250 1251 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); 1252 if (!idkp) 1253 goto failed; 1254 1255 g = alloc_disk_node(1 << PARTN_BITS, 1256 hwif_to_node(drive->hwif)); 1257 if (!g) 1258 goto out_free_idkp; 1259 1260 ide_init_disk(g, drive); 1261 1262 ide_proc_register_driver(drive, &idedisk_driver); 1263 1264 kref_init(&idkp->kref); 1265 1266 idkp->drive = drive; 1267 idkp->driver = &idedisk_driver; 1268 idkp->disk = g; 1269 1270 g->private_data = &idkp->driver; 1271 1272 drive->driver_data = idkp; 1273 1274 idedisk_setup(drive); 1275 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) { 1276 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", 1277 drive->name, drive->head); 1278 drive->attach = 0; 1279 } else 1280 drive->attach = 1; 1281 1282 g->minors = 1 << PARTN_BITS; 1283 g->driverfs_dev = &drive->gendev; 1284 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0; 1285 set_capacity(g, idedisk_capacity(drive)); 1286 g->fops = &idedisk_ops; 1287 add_disk(g); 1288 return 0; 1289 1290out_free_idkp: 1291 kfree(idkp); 1292failed: 1293 return -ENODEV; 1294} 1295 1296static void __exit idedisk_exit (void) 1297{ 1298 driver_unregister(&idedisk_driver.gen_driver); 1299} 1300 1301static int __init idedisk_init(void) 1302{ 1303 return driver_register(&idedisk_driver.gen_driver); 1304} 1305 1306MODULE_ALIAS("ide:*m-disk*"); 1307module_init(idedisk_init); 1308module_exit(idedisk_exit); 1309MODULE_LICENSE("GPL"); 1310