ia64/linux-2.6.18-xen.hg

view drivers/ide/ide-disk.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
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 */
44 #define IDEDISK_VERSION "1.18"
46 #undef REALLY_SLOW_IO /* most systems can safely undef this */
48 //#define DEBUG
50 #include <linux/module.h>
51 #include <linux/types.h>
52 #include <linux/string.h>
53 #include <linux/kernel.h>
54 #include <linux/timer.h>
55 #include <linux/mm.h>
56 #include <linux/interrupt.h>
57 #include <linux/major.h>
58 #include <linux/errno.h>
59 #include <linux/genhd.h>
60 #include <linux/slab.h>
61 #include <linux/delay.h>
62 #include <linux/mutex.h>
63 #include <linux/leds.h>
65 #define _IDE_DISK
67 #include <linux/ide.h>
69 #include <asm/byteorder.h>
70 #include <asm/irq.h>
71 #include <asm/uaccess.h>
72 #include <asm/io.h>
73 #include <asm/div64.h>
75 struct ide_disk_obj {
76 ide_drive_t *drive;
77 ide_driver_t *driver;
78 struct gendisk *disk;
79 struct kref kref;
80 };
82 static DEFINE_MUTEX(idedisk_ref_mutex);
84 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
86 #define ide_disk_g(disk) \
87 container_of((disk)->private_data, struct ide_disk_obj, driver)
89 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
90 {
91 struct ide_disk_obj *idkp = NULL;
93 mutex_lock(&idedisk_ref_mutex);
94 idkp = ide_disk_g(disk);
95 if (idkp)
96 kref_get(&idkp->kref);
97 mutex_unlock(&idedisk_ref_mutex);
98 return idkp;
99 }
101 static void ide_disk_release(struct kref *);
103 static void ide_disk_put(struct ide_disk_obj *idkp)
104 {
105 mutex_lock(&idedisk_ref_mutex);
106 kref_put(&idkp->kref, ide_disk_release);
107 mutex_unlock(&idedisk_ref_mutex);
108 }
110 /*
111 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
112 * value for this drive (from its reported identification information).
113 *
114 * Returns: 1 if lba_capacity looks sensible
115 * 0 otherwise
116 *
117 * It is called only once for each drive.
118 */
119 static int lba_capacity_is_ok (struct hd_driveid *id)
120 {
121 unsigned long lba_sects, chs_sects, head, tail;
123 /* No non-LBA info .. so valid! */
124 if (id->cyls == 0)
125 return 1;
127 /*
128 * The ATA spec tells large drives to return
129 * C/H/S = 16383/16/63 independent of their size.
130 * Some drives can be jumpered to use 15 heads instead of 16.
131 * Some drives can be jumpered to use 4092 cyls instead of 16383.
132 */
133 if ((id->cyls == 16383
134 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
135 id->sectors == 63 &&
136 (id->heads == 15 || id->heads == 16) &&
137 (id->lba_capacity >= 16383*63*id->heads))
138 return 1;
140 lba_sects = id->lba_capacity;
141 chs_sects = id->cyls * id->heads * id->sectors;
143 /* perform a rough sanity check on lba_sects: within 10% is OK */
144 if ((lba_sects - chs_sects) < chs_sects/10)
145 return 1;
147 /* some drives have the word order reversed */
148 head = ((lba_sects >> 16) & 0xffff);
149 tail = (lba_sects & 0xffff);
150 lba_sects = (head | (tail << 16));
151 if ((lba_sects - chs_sects) < chs_sects/10) {
152 id->lba_capacity = lba_sects;
153 return 1; /* lba_capacity is (now) good */
154 }
156 return 0; /* lba_capacity value may be bad */
157 }
159 /*
160 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
161 * using LBA if supported, or CHS otherwise, to address sectors.
162 */
163 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
164 {
165 ide_hwif_t *hwif = HWIF(drive);
166 unsigned int dma = drive->using_dma;
167 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
168 task_ioreg_t command = WIN_NOP;
169 ata_nsector_t nsectors;
171 nsectors.all = (u16) rq->nr_sectors;
173 if (hwif->no_lba48_dma && lba48 && dma) {
174 if (block + rq->nr_sectors > 1ULL << 28)
175 dma = 0;
176 else
177 lba48 = 0;
178 }
180 if (!dma) {
181 ide_init_sg_cmd(drive, rq);
182 ide_map_sg(drive, rq);
183 }
185 if (IDE_CONTROL_REG)
186 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
188 /* FIXME: SELECT_MASK(drive, 0) ? */
190 if (drive->select.b.lba) {
191 if (lba48) {
192 task_ioreg_t tasklets[10];
194 pr_debug("%s: LBA=0x%012llx\n", drive->name,
195 (unsigned long long)block);
197 tasklets[0] = 0;
198 tasklets[1] = 0;
199 tasklets[2] = nsectors.b.low;
200 tasklets[3] = nsectors.b.high;
201 tasklets[4] = (task_ioreg_t) block;
202 tasklets[5] = (task_ioreg_t) (block>>8);
203 tasklets[6] = (task_ioreg_t) (block>>16);
204 tasklets[7] = (task_ioreg_t) (block>>24);
205 if (sizeof(block) == 4) {
206 tasklets[8] = (task_ioreg_t) 0;
207 tasklets[9] = (task_ioreg_t) 0;
208 } else {
209 tasklets[8] = (task_ioreg_t)((u64)block >> 32);
210 tasklets[9] = (task_ioreg_t)((u64)block >> 40);
211 }
212 #ifdef DEBUG
213 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
214 drive->name, tasklets[3], tasklets[2],
215 tasklets[9], tasklets[8], tasklets[7],
216 tasklets[6], tasklets[5], tasklets[4]);
217 #endif
218 hwif->OUTB(tasklets[1], IDE_FEATURE_REG);
219 hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);
220 hwif->OUTB(tasklets[7], IDE_SECTOR_REG);
221 hwif->OUTB(tasklets[8], IDE_LCYL_REG);
222 hwif->OUTB(tasklets[9], IDE_HCYL_REG);
224 hwif->OUTB(tasklets[0], IDE_FEATURE_REG);
225 hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);
226 hwif->OUTB(tasklets[4], IDE_SECTOR_REG);
227 hwif->OUTB(tasklets[5], IDE_LCYL_REG);
228 hwif->OUTB(tasklets[6], IDE_HCYL_REG);
229 hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
230 } else {
231 hwif->OUTB(0x00, IDE_FEATURE_REG);
232 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
233 hwif->OUTB(block, IDE_SECTOR_REG);
234 hwif->OUTB(block>>=8, IDE_LCYL_REG);
235 hwif->OUTB(block>>=8, IDE_HCYL_REG);
236 hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
237 }
238 } else {
239 unsigned int sect,head,cyl,track;
240 track = (int)block / drive->sect;
241 sect = (int)block % drive->sect + 1;
242 hwif->OUTB(sect, IDE_SECTOR_REG);
243 head = track % drive->head;
244 cyl = track / drive->head;
246 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
248 hwif->OUTB(0x00, IDE_FEATURE_REG);
249 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
250 hwif->OUTB(cyl, IDE_LCYL_REG);
251 hwif->OUTB(cyl>>8, IDE_HCYL_REG);
252 hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
253 }
255 if (dma) {
256 if (!hwif->dma_setup(drive)) {
257 if (rq_data_dir(rq)) {
258 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
259 if (drive->vdma)
260 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
261 } else {
262 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
263 if (drive->vdma)
264 command = lba48 ? WIN_READ_EXT: WIN_READ;
265 }
266 hwif->dma_exec_cmd(drive, command);
267 hwif->dma_start(drive);
268 return ide_started;
269 }
270 /* fallback to PIO */
271 ide_init_sg_cmd(drive, rq);
272 }
274 if (rq_data_dir(rq) == READ) {
276 if (drive->mult_count) {
277 hwif->data_phase = TASKFILE_MULTI_IN;
278 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
279 } else {
280 hwif->data_phase = TASKFILE_IN;
281 command = lba48 ? WIN_READ_EXT : WIN_READ;
282 }
284 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
285 return ide_started;
286 } else {
287 if (drive->mult_count) {
288 hwif->data_phase = TASKFILE_MULTI_OUT;
289 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
290 } else {
291 hwif->data_phase = TASKFILE_OUT;
292 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
293 }
295 /* FIXME: ->OUTBSYNC ? */
296 hwif->OUTB(command, IDE_COMMAND_REG);
298 return pre_task_out_intr(drive, rq);
299 }
300 }
302 /*
303 * 268435455 == 137439 MB or 28bit limit
304 * 320173056 == 163929 MB or 48bit addressing
305 * 1073741822 == 549756 MB or 48bit addressing fake drive
306 */
308 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
309 {
310 ide_hwif_t *hwif = HWIF(drive);
312 BUG_ON(drive->blocked);
314 if (!blk_fs_request(rq)) {
315 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
316 ide_end_request(drive, 0, 0);
317 return ide_stopped;
318 }
320 ledtrig_ide_activity();
322 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
323 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
324 (unsigned long long)block, rq->nr_sectors,
325 (unsigned long)rq->buffer);
327 if (hwif->rw_disk)
328 hwif->rw_disk(drive, rq);
330 return __ide_do_rw_disk(drive, rq, block);
331 }
333 /*
334 * Queries for true maximum capacity of the drive.
335 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
336 */
337 static unsigned long idedisk_read_native_max_address(ide_drive_t *drive)
338 {
339 ide_task_t args;
340 unsigned long addr = 0;
342 /* Create IDE/ATA command request structure */
343 memset(&args, 0, sizeof(ide_task_t));
344 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
345 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX;
346 args.command_type = IDE_DRIVE_TASK_NO_DATA;
347 args.handler = &task_no_data_intr;
348 /* submit command request */
349 ide_raw_taskfile(drive, &args, NULL);
351 /* if OK, compute maximum address value */
352 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
353 addr = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
354 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
355 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
356 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
357 addr++; /* since the return value is (maxlba - 1), we add 1 */
358 }
359 return addr;
360 }
362 static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
363 {
364 ide_task_t args;
365 unsigned long long addr = 0;
367 /* Create IDE/ATA command request structure */
368 memset(&args, 0, sizeof(ide_task_t));
370 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
371 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX_EXT;
372 args.command_type = IDE_DRIVE_TASK_NO_DATA;
373 args.handler = &task_no_data_intr;
374 /* submit command request */
375 ide_raw_taskfile(drive, &args, NULL);
377 /* if OK, compute maximum address value */
378 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
379 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
380 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
381 args.hobRegister[IDE_SECTOR_OFFSET];
382 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
383 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
384 (args.tfRegister[IDE_SECTOR_OFFSET]);
385 addr = ((__u64)high << 24) | low;
386 addr++; /* since the return value is (maxlba - 1), we add 1 */
387 }
388 return addr;
389 }
391 /*
392 * Sets maximum virtual LBA address of the drive.
393 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
394 */
395 static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
396 {
397 ide_task_t args;
398 unsigned long addr_set = 0;
400 addr_req--;
401 /* Create IDE/ATA command request structure */
402 memset(&args, 0, sizeof(ide_task_t));
403 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
404 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >> 8) & 0xff);
405 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >> 16) & 0xff);
406 args.tfRegister[IDE_SELECT_OFFSET] = ((addr_req >> 24) & 0x0f) | 0x40;
407 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX;
408 args.command_type = IDE_DRIVE_TASK_NO_DATA;
409 args.handler = &task_no_data_intr;
410 /* submit command request */
411 ide_raw_taskfile(drive, &args, NULL);
412 /* if OK, read new maximum address value */
413 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
414 addr_set = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
415 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
416 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
417 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
418 addr_set++;
419 }
420 return addr_set;
421 }
423 static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
424 {
425 ide_task_t args;
426 unsigned long long addr_set = 0;
428 addr_req--;
429 /* Create IDE/ATA command request structure */
430 memset(&args, 0, sizeof(ide_task_t));
431 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
432 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
433 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
434 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
435 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX_EXT;
436 args.hobRegister[IDE_SECTOR_OFFSET] = (addr_req >>= 8) & 0xff;
437 args.hobRegister[IDE_LCYL_OFFSET] = (addr_req >>= 8) & 0xff;
438 args.hobRegister[IDE_HCYL_OFFSET] = (addr_req >>= 8) & 0xff;
439 args.hobRegister[IDE_SELECT_OFFSET] = 0x40;
440 args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
441 args.command_type = IDE_DRIVE_TASK_NO_DATA;
442 args.handler = &task_no_data_intr;
443 /* submit command request */
444 ide_raw_taskfile(drive, &args, NULL);
445 /* if OK, compute maximum address value */
446 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
447 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
448 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
449 args.hobRegister[IDE_SECTOR_OFFSET];
450 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
451 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
452 (args.tfRegister[IDE_SECTOR_OFFSET]);
453 addr_set = ((__u64)high << 24) | low;
454 addr_set++;
455 }
456 return addr_set;
457 }
459 static unsigned long long sectors_to_MB(unsigned long long n)
460 {
461 n <<= 9; /* make it bytes */
462 do_div(n, 1000000); /* make it MB */
463 return n;
464 }
466 /*
467 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
468 * so on non-buggy drives we need test only one.
469 * However, we should also check whether these fields are valid.
470 */
471 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
472 {
473 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
474 }
476 /*
477 * The same here.
478 */
479 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
480 {
481 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
482 && id->lba_capacity_2;
483 }
485 static void idedisk_check_hpa(ide_drive_t *drive)
486 {
487 unsigned long long capacity, set_max;
488 int lba48 = idedisk_supports_lba48(drive->id);
490 capacity = drive->capacity64;
491 if (lba48)
492 set_max = idedisk_read_native_max_address_ext(drive);
493 else
494 set_max = idedisk_read_native_max_address(drive);
496 if (set_max <= capacity)
497 return;
499 printk(KERN_INFO "%s: Host Protected Area detected.\n"
500 "\tcurrent capacity is %llu sectors (%llu MB)\n"
501 "\tnative capacity is %llu sectors (%llu MB)\n",
502 drive->name,
503 capacity, sectors_to_MB(capacity),
504 set_max, sectors_to_MB(set_max));
506 if (lba48)
507 set_max = idedisk_set_max_address_ext(drive, set_max);
508 else
509 set_max = idedisk_set_max_address(drive, set_max);
510 if (set_max) {
511 drive->capacity64 = set_max;
512 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
513 drive->name);
514 }
515 }
517 /*
518 * Compute drive->capacity, the full capacity of the drive
519 * Called with drive->id != NULL.
520 *
521 * To compute capacity, this uses either of
522 *
523 * 1. CHS value set by user (whatever user sets will be trusted)
524 * 2. LBA value from target drive (require new ATA feature)
525 * 3. LBA value from system BIOS (new one is OK, old one may break)
526 * 4. CHS value from system BIOS (traditional style)
527 *
528 * in above order (i.e., if value of higher priority is available,
529 * reset will be ignored).
530 */
531 static void init_idedisk_capacity (ide_drive_t *drive)
532 {
533 struct hd_driveid *id = drive->id;
534 /*
535 * If this drive supports the Host Protected Area feature set,
536 * then we may need to change our opinion about the drive's capacity.
537 */
538 int hpa = idedisk_supports_hpa(id);
540 if (idedisk_supports_lba48(id)) {
541 /* drive speaks 48-bit LBA */
542 drive->select.b.lba = 1;
543 drive->capacity64 = id->lba_capacity_2;
544 if (hpa)
545 idedisk_check_hpa(drive);
546 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
547 /* drive speaks 28-bit LBA */
548 drive->select.b.lba = 1;
549 drive->capacity64 = id->lba_capacity;
550 if (hpa)
551 idedisk_check_hpa(drive);
552 } else {
553 /* drive speaks boring old 28-bit CHS */
554 drive->capacity64 = drive->cyl * drive->head * drive->sect;
555 }
556 }
558 static sector_t idedisk_capacity (ide_drive_t *drive)
559 {
560 return drive->capacity64 - drive->sect0;
561 }
563 #ifdef CONFIG_PROC_FS
565 static int smart_enable(ide_drive_t *drive)
566 {
567 ide_task_t args;
569 memset(&args, 0, sizeof(ide_task_t));
570 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE;
571 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
572 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
573 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
574 args.command_type = IDE_DRIVE_TASK_NO_DATA;
575 args.handler = &task_no_data_intr;
576 return ide_raw_taskfile(drive, &args, NULL);
577 }
579 static int get_smart_values(ide_drive_t *drive, u8 *buf)
580 {
581 ide_task_t args;
583 memset(&args, 0, sizeof(ide_task_t));
584 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES;
585 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
586 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
587 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
588 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
589 args.command_type = IDE_DRIVE_TASK_IN;
590 args.data_phase = TASKFILE_IN;
591 args.handler = &task_in_intr;
592 (void) smart_enable(drive);
593 return ide_raw_taskfile(drive, &args, buf);
594 }
596 static int get_smart_thresholds(ide_drive_t *drive, u8 *buf)
597 {
598 ide_task_t args;
599 memset(&args, 0, sizeof(ide_task_t));
600 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS;
601 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
602 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
603 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
604 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
605 args.command_type = IDE_DRIVE_TASK_IN;
606 args.data_phase = TASKFILE_IN;
607 args.handler = &task_in_intr;
608 (void) smart_enable(drive);
609 return ide_raw_taskfile(drive, &args, buf);
610 }
612 static int proc_idedisk_read_cache
613 (char *page, char **start, off_t off, int count, int *eof, void *data)
614 {
615 ide_drive_t *drive = (ide_drive_t *) data;
616 char *out = page;
617 int len;
619 if (drive->id_read)
620 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
621 else
622 len = sprintf(out,"(none)\n");
623 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
624 }
626 static int proc_idedisk_read_capacity
627 (char *page, char **start, off_t off, int count, int *eof, void *data)
628 {
629 ide_drive_t*drive = (ide_drive_t *)data;
630 int len;
632 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
633 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
634 }
636 static int proc_idedisk_read_smart_thresholds
637 (char *page, char **start, off_t off, int count, int *eof, void *data)
638 {
639 ide_drive_t *drive = (ide_drive_t *)data;
640 int len = 0, i = 0;
642 if (!get_smart_thresholds(drive, page)) {
643 unsigned short *val = (unsigned short *) page;
644 char *out = ((char *)val) + (SECTOR_WORDS * 4);
645 page = out;
646 do {
647 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
648 val += 1;
649 } while (i < (SECTOR_WORDS * 2));
650 len = out - page;
651 }
652 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
653 }
655 static int proc_idedisk_read_smart_values
656 (char *page, char **start, off_t off, int count, int *eof, void *data)
657 {
658 ide_drive_t *drive = (ide_drive_t *)data;
659 int len = 0, i = 0;
661 if (!get_smart_values(drive, page)) {
662 unsigned short *val = (unsigned short *) page;
663 char *out = ((char *)val) + (SECTOR_WORDS * 4);
664 page = out;
665 do {
666 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
667 val += 1;
668 } while (i < (SECTOR_WORDS * 2));
669 len = out - page;
670 }
671 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
672 }
674 static ide_proc_entry_t idedisk_proc[] = {
675 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
676 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
677 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
678 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
679 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
680 { NULL, 0, NULL, NULL }
681 };
683 #else
685 #define idedisk_proc NULL
687 #endif /* CONFIG_PROC_FS */
689 static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
690 {
691 ide_drive_t *drive = q->queuedata;
693 memset(rq->cmd, 0, sizeof(rq->cmd));
695 if (ide_id_has_flush_cache_ext(drive->id) &&
696 (drive->capacity64 >= (1UL << 28)))
697 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
698 else
699 rq->cmd[0] = WIN_FLUSH_CACHE;
702 rq->flags |= REQ_DRIVE_TASK;
703 rq->buffer = rq->cmd;
704 }
706 static 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;
713 if (!drive->wcache)
714 return 0;
716 rq = blk_get_request(q, WRITE, __GFP_WAIT);
718 idedisk_prepare_flush(q, rq);
720 ret = blk_execute_rq(q, disk, rq, 0);
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);
728 blk_put_request(rq);
729 return ret;
730 }
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 */
736 static int set_multcount(ide_drive_t *drive, int arg)
737 {
738 struct request rq;
740 if (drive->special.b.set_multmode)
741 return -EBUSY;
742 ide_init_drive_cmd (&rq);
743 rq.flags = REQ_DRIVE_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 }
750 static 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 }
760 static 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;
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));
783 printk(KERN_INFO "%s: cache flushes %ssupported\n",
784 drive->name, barrier ? "" : "not ");
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;
794 blk_queue_ordered(drive->queue, ordered, prep_fn);
795 blk_queue_issue_flush_fn(drive->queue, issue_fn);
796 }
798 static int write_cache(ide_drive_t *drive, int arg)
799 {
800 ide_task_t args;
801 int err = 1;
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 }
815 update_ordered(drive);
817 return err;
818 }
820 static int do_idedisk_flushcache (ide_drive_t *drive)
821 {
822 ide_task_t args;
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 }
834 static int set_acoustic (ide_drive_t *drive, int arg)
835 {
836 ide_task_t args;
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 }
850 /*
851 * drive->addressing:
852 * 0: 28-bit
853 * 1: 48-bit
854 * 2: 48-bit capable doing 28-bit
855 */
856 static int set_lba_addressing(ide_drive_t *drive, int arg)
857 {
858 drive->addressing = 0;
860 if (HWIF(drive)->no_lba48)
861 return 0;
863 if (!idedisk_supports_lba48(drive->id))
864 return -EIO;
865 drive->addressing = arg;
866 return 0;
867 }
869 static void idedisk_add_settings(ide_drive_t *drive)
870 {
871 struct hd_driveid *id = drive->id;
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 }
887 static void idedisk_setup (ide_drive_t *drive)
888 {
889 struct hd_driveid *id = drive->id;
890 unsigned long long capacity;
892 idedisk_add_settings(drive);
894 if (drive->id_read == 0)
895 return;
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 }
906 (void)set_lba_addressing(drive, 1);
908 if (drive->addressing == 1) {
909 ide_hwif_t *hwif = HWIF(drive);
910 int max_s = 2048;
912 if (max_s > hwif->rqsize)
913 max_s = hwif->rqsize;
915 blk_queue_max_sectors(drive->queue, max_s);
916 }
918 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
920 /* calculate drive capacity, and select LBA if possible */
921 init_idedisk_capacity (drive);
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 }
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 }
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) {
948 if (idedisk_supports_lba48(drive->id)) {
949 /* compatibility */
950 drive->bios_sect = 63;
951 drive->bios_head = 255;
952 }
954 if (drive->bios_sect && drive->bios_head) {
955 unsigned int cap0 = capacity; /* truncate to 32 bits */
956 unsigned int cylsz, cyl;
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));
973 /* Only print cache size when it was specified */
974 if (id->buf_size)
975 printk (" w/%dKiB Cache", id->buf_size/2);
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");
983 /* write cache enabled? */
984 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
985 drive->wcache = 1;
987 write_cache(drive, 1);
988 }
990 static void ide_cacheflush_p(ide_drive_t *drive)
991 {
992 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
993 return;
995 if (do_idedisk_flushcache(drive))
996 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
997 }
999 static void ide_disk_remove(ide_drive_t *drive)
1001 struct ide_disk_obj *idkp = drive->driver_data;
1002 struct gendisk *g = idkp->disk;
1004 ide_unregister_subdriver(drive, idkp->driver);
1006 del_gendisk(g);
1008 ide_cacheflush_p(drive);
1010 ide_disk_put(idkp);
1013 static void ide_disk_release(struct kref *kref)
1015 struct ide_disk_obj *idkp = to_ide_disk(kref);
1016 ide_drive_t *drive = idkp->drive;
1017 struct gendisk *g = idkp->disk;
1019 drive->driver_data = NULL;
1020 g->private_data = NULL;
1021 put_disk(g);
1022 kfree(idkp);
1025 static int ide_disk_probe(ide_drive_t *drive);
1027 static void ide_device_shutdown(ide_drive_t *drive)
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;
1049 printk("Shutdown: %s\n", drive->name);
1050 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
1053 static 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 };
1072 static int idedisk_open(struct inode *inode, struct file *filp)
1074 struct gendisk *disk = inode->i_bdev->bd_disk;
1075 struct ide_disk_obj *idkp;
1076 ide_drive_t *drive;
1078 if (!(idkp = ide_disk_get(disk)))
1079 return -ENXIO;
1081 drive = idkp->drive;
1083 drive->usage++;
1084 if (drive->removable && drive->usage == 1) {
1085 ide_task_t args;
1086 memset(&args, 0, sizeof(ide_task_t));
1087 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
1088 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1089 args.handler = &task_no_data_intr;
1090 check_disk_change(inode->i_bdev);
1091 /*
1092 * Ignore the return code from door_lock,
1093 * since the open() has already succeeded,
1094 * and the door_lock is irrelevant at this point.
1095 */
1096 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1097 drive->doorlocking = 0;
1099 return 0;
1102 static int idedisk_release(struct inode *inode, struct file *filp)
1104 struct gendisk *disk = inode->i_bdev->bd_disk;
1105 struct ide_disk_obj *idkp = ide_disk_g(disk);
1106 ide_drive_t *drive = idkp->drive;
1108 if (drive->usage == 1)
1109 ide_cacheflush_p(drive);
1110 if (drive->removable && drive->usage == 1) {
1111 ide_task_t args;
1112 memset(&args, 0, sizeof(ide_task_t));
1113 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
1114 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1115 args.handler = &task_no_data_intr;
1116 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1117 drive->doorlocking = 0;
1119 drive->usage--;
1121 ide_disk_put(idkp);
1123 return 0;
1126 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1128 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1129 ide_drive_t *drive = idkp->drive;
1131 geo->heads = drive->bios_head;
1132 geo->sectors = drive->bios_sect;
1133 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1134 return 0;
1137 static int idedisk_ioctl(struct inode *inode, struct file *file,
1138 unsigned int cmd, unsigned long arg)
1140 struct block_device *bdev = inode->i_bdev;
1141 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1142 return generic_ide_ioctl(idkp->drive, file, bdev, cmd, arg);
1145 static int idedisk_media_changed(struct gendisk *disk)
1147 struct ide_disk_obj *idkp = ide_disk_g(disk);
1148 ide_drive_t *drive = idkp->drive;
1150 /* do not scan partitions twice if this is a removable device */
1151 if (drive->attach) {
1152 drive->attach = 0;
1153 return 0;
1155 /* if removable, always assume it was changed */
1156 return drive->removable;
1159 static int idedisk_revalidate_disk(struct gendisk *disk)
1161 struct ide_disk_obj *idkp = ide_disk_g(disk);
1162 set_capacity(disk, idedisk_capacity(idkp->drive));
1163 return 0;
1166 static struct block_device_operations idedisk_ops = {
1167 .owner = THIS_MODULE,
1168 .open = idedisk_open,
1169 .release = idedisk_release,
1170 .ioctl = idedisk_ioctl,
1171 .getgeo = idedisk_getgeo,
1172 .media_changed = idedisk_media_changed,
1173 .revalidate_disk= idedisk_revalidate_disk
1174 };
1176 MODULE_DESCRIPTION("ATA DISK Driver");
1178 static int ide_disk_probe(ide_drive_t *drive)
1180 struct ide_disk_obj *idkp;
1181 struct gendisk *g;
1183 /* strstr("foo", "") is non-NULL */
1184 if (!strstr("ide-disk", drive->driver_req))
1185 goto failed;
1186 if (!drive->present)
1187 goto failed;
1188 if (drive->media != ide_disk)
1189 goto failed;
1191 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1192 if (!idkp)
1193 goto failed;
1195 g = alloc_disk_node(1 << PARTN_BITS,
1196 hwif_to_node(drive->hwif));
1197 if (!g)
1198 goto out_free_idkp;
1200 ide_init_disk(g, drive);
1202 ide_register_subdriver(drive, &idedisk_driver);
1204 kref_init(&idkp->kref);
1206 idkp->drive = drive;
1207 idkp->driver = &idedisk_driver;
1208 idkp->disk = g;
1210 g->private_data = &idkp->driver;
1212 drive->driver_data = idkp;
1214 idedisk_setup(drive);
1215 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1216 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1217 drive->name, drive->head);
1218 drive->attach = 0;
1219 } else
1220 drive->attach = 1;
1222 g->minors = 1 << PARTN_BITS;
1223 g->driverfs_dev = &drive->gendev;
1224 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1225 set_capacity(g, idedisk_capacity(drive));
1226 g->fops = &idedisk_ops;
1227 add_disk(g);
1228 return 0;
1230 out_free_idkp:
1231 kfree(idkp);
1232 failed:
1233 return -ENODEV;
1236 static void __exit idedisk_exit (void)
1238 driver_unregister(&idedisk_driver.gen_driver);
1241 static int __init idedisk_init(void)
1243 return driver_register(&idedisk_driver.gen_driver);
1246 MODULE_ALIAS("ide:*m-disk*");
1247 module_init(idedisk_init);
1248 module_exit(idedisk_exit);
1249 MODULE_LICENSE("GPL");