ide: add struct ide_taskfile (take 2)
[linux-2.6.git] / drivers / ide / ide-disk.c
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
47 struct 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
55 static 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
62 static 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
74 static void ide_disk_release(struct kref *);
75
76 static 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  */
92 static 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  */
136 static 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
281 static 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  */
310 static unsigned long idedisk_read_native_max_address(ide_drive_t *drive)
311 {
312         ide_task_t args;
313         struct ide_taskfile *tf = &args.tf;
314         unsigned long addr = 0;
315
316         /* Create IDE/ATA command request structure */
317         memset(&args, 0, sizeof(ide_task_t));
318         tf->device  = ATA_LBA;
319         tf->command = WIN_READ_NATIVE_MAX;
320         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
321         args.handler                            = &task_no_data_intr;
322         /* submit command request */
323         ide_raw_taskfile(drive, &args, NULL);
324
325         /* if OK, compute maximum address value */
326         if ((tf->status & 0x01) == 0) {
327                 addr = ((tf->device & 0xf) << 24) |
328                        (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
329                 addr++; /* since the return value is (maxlba - 1), we add 1 */
330         }
331         return addr;
332 }
333
334 static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
335 {
336         ide_task_t args;
337         struct ide_taskfile *tf = &args.tf;
338         unsigned long long addr = 0;
339
340         /* Create IDE/ATA command request structure */
341         memset(&args, 0, sizeof(ide_task_t));
342         tf->device  = ATA_LBA;
343         tf->command = WIN_READ_NATIVE_MAX_EXT;
344         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
345         args.handler                            = &task_no_data_intr;
346         /* submit command request */
347         ide_raw_taskfile(drive, &args, NULL);
348
349         /* if OK, compute maximum address value */
350         if ((tf->status & 0x01) == 0) {
351                 u32 high, low;
352
353                 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) | tf->hob_lbal;
354                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
355                 addr = ((__u64)high << 24) | low;
356                 addr++; /* since the return value is (maxlba - 1), we add 1 */
357         }
358         return addr;
359 }
360
361 /*
362  * Sets maximum virtual LBA address of the drive.
363  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
364  */
365 static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
366 {
367         ide_task_t args;
368         struct ide_taskfile *tf = &args.tf;
369         unsigned long addr_set = 0;
370         
371         addr_req--;
372         /* Create IDE/ATA command request structure */
373         memset(&args, 0, sizeof(ide_task_t));
374         tf->lbal    =  (addr_req >>  0) & 0xff;
375         tf->lbam    =  (addr_req >>  8) & 0xff;
376         tf->lbah    =  (addr_req >> 16) & 0xff;
377         tf->device  = ((addr_req >> 24) & 0x0f) | ATA_LBA;
378         tf->command = WIN_SET_MAX;
379         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
380         args.handler                            = &task_no_data_intr;
381         /* submit command request */
382         ide_raw_taskfile(drive, &args, NULL);
383         /* if OK, read new maximum address value */
384         if ((tf->status & 0x01) == 0) {
385                 addr_set = ((tf->device & 0xf) << 24) |
386                            (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
387                 addr_set++;
388         }
389         return addr_set;
390 }
391
392 static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
393 {
394         ide_task_t args;
395         struct ide_taskfile *tf = &args.tf;
396         unsigned long long addr_set = 0;
397
398         addr_req--;
399         /* Create IDE/ATA command request structure */
400         memset(&args, 0, sizeof(ide_task_t));
401         tf->lbal     = (addr_req >>  0) & 0xff;
402         tf->lbam     = (addr_req >>= 8) & 0xff;
403         tf->lbah     = (addr_req >>= 8) & 0xff;
404         tf->device   = ATA_LBA;
405         tf->command  = WIN_SET_MAX_EXT;
406         tf->hob_lbal = (addr_req >>= 8) & 0xff;
407         tf->hob_lbam = (addr_req >>= 8) & 0xff;
408         tf->hob_lbah = (addr_req >>= 8) & 0xff;
409         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
410         args.handler                            = &task_no_data_intr;
411         /* submit command request */
412         ide_raw_taskfile(drive, &args, NULL);
413         /* if OK, compute maximum address value */
414         if ((tf->status & 0x01) == 0) {
415                 u32 high, low;
416
417                 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) | tf->hob_lbal;
418                 low  = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
419                 addr_set = ((__u64)high << 24) | low;
420                 addr_set++;
421         }
422         return addr_set;
423 }
424
425 static unsigned long long sectors_to_MB(unsigned long long n)
426 {
427         n <<= 9;                /* make it bytes */
428         do_div(n, 1000000);     /* make it MB */
429         return n;
430 }
431
432 /*
433  * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
434  * so on non-buggy drives we need test only one.
435  * However, we should also check whether these fields are valid.
436  */
437 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
438 {
439         return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
440 }
441
442 /*
443  * The same here.
444  */
445 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
446 {
447         return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
448                && id->lba_capacity_2;
449 }
450
451 /*
452  * Some disks report total number of sectors instead of
453  * maximum sector address.  We list them here.
454  */
455 static const struct drive_list_entry hpa_list[] = {
456         { "ST340823A",  NULL },
457         { "ST320413A",  NULL },
458         { NULL,         NULL }
459 };
460
461 static void idedisk_check_hpa(ide_drive_t *drive)
462 {
463         unsigned long long capacity, set_max;
464         int lba48 = idedisk_supports_lba48(drive->id);
465
466         capacity = drive->capacity64;
467         if (lba48)
468                 set_max = idedisk_read_native_max_address_ext(drive);
469         else
470                 set_max = idedisk_read_native_max_address(drive);
471
472         if (ide_in_drive_list(drive->id, hpa_list)) {
473                 /*
474                  * Since we are inclusive wrt to firmware revisions do this
475                  * extra check and apply the workaround only when needed.
476                  */
477                 if (set_max == capacity + 1)
478                         set_max--;
479         }
480
481         if (set_max <= capacity)
482                 return;
483
484         printk(KERN_INFO "%s: Host Protected Area detected.\n"
485                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
486                          "\tnative  capacity is %llu sectors (%llu MB)\n",
487                          drive->name,
488                          capacity, sectors_to_MB(capacity),
489                          set_max, sectors_to_MB(set_max));
490
491         if (lba48)
492                 set_max = idedisk_set_max_address_ext(drive, set_max);
493         else
494                 set_max = idedisk_set_max_address(drive, set_max);
495         if (set_max) {
496                 drive->capacity64 = set_max;
497                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
498                                  drive->name);
499         }
500 }
501
502 /*
503  * Compute drive->capacity, the full capacity of the drive
504  * Called with drive->id != NULL.
505  *
506  * To compute capacity, this uses either of
507  *
508  *    1. CHS value set by user       (whatever user sets will be trusted)
509  *    2. LBA value from target drive (require new ATA feature)
510  *    3. LBA value from system BIOS  (new one is OK, old one may break)
511  *    4. CHS value from system BIOS  (traditional style)
512  *
513  * in above order (i.e., if value of higher priority is available,
514  * reset will be ignored).
515  */
516 static void init_idedisk_capacity (ide_drive_t  *drive)
517 {
518         struct hd_driveid *id = drive->id;
519         /*
520          * If this drive supports the Host Protected Area feature set,
521          * then we may need to change our opinion about the drive's capacity.
522          */
523         int hpa = idedisk_supports_hpa(id);
524
525         if (idedisk_supports_lba48(id)) {
526                 /* drive speaks 48-bit LBA */
527                 drive->select.b.lba = 1;
528                 drive->capacity64 = id->lba_capacity_2;
529                 if (hpa)
530                         idedisk_check_hpa(drive);
531         } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
532                 /* drive speaks 28-bit LBA */
533                 drive->select.b.lba = 1;
534                 drive->capacity64 = id->lba_capacity;
535                 if (hpa)
536                         idedisk_check_hpa(drive);
537         } else {
538                 /* drive speaks boring old 28-bit CHS */
539                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
540         }
541 }
542
543 static sector_t idedisk_capacity (ide_drive_t *drive)
544 {
545         return drive->capacity64 - drive->sect0;
546 }
547
548 #ifdef CONFIG_IDE_PROC_FS
549 static int smart_enable(ide_drive_t *drive)
550 {
551         ide_task_t args;
552         struct ide_taskfile *tf = &args.tf;
553
554         memset(&args, 0, sizeof(ide_task_t));
555         tf->feature = SMART_ENABLE;
556         tf->lbam    = SMART_LCYL_PASS;
557         tf->lbah    = SMART_HCYL_PASS;
558         tf->command = WIN_SMART;
559         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
560         args.handler                            = &task_no_data_intr;
561         return ide_raw_taskfile(drive, &args, NULL);
562 }
563
564 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
565 {
566         ide_task_t args;
567         struct ide_taskfile *tf = &args.tf;
568
569         memset(&args, 0, sizeof(ide_task_t));
570         tf->feature = sub_cmd;
571         tf->nsect   = 0x01;
572         tf->lbam    = SMART_LCYL_PASS;
573         tf->lbah    = SMART_HCYL_PASS;
574         tf->command = WIN_SMART;
575         args.command_type                       = IDE_DRIVE_TASK_IN;
576         args.data_phase                         = TASKFILE_IN;
577         args.handler                            = &task_in_intr;
578         (void) smart_enable(drive);
579         return ide_raw_taskfile(drive, &args, buf);
580 }
581
582 static int proc_idedisk_read_cache
583         (char *page, char **start, off_t off, int count, int *eof, void *data)
584 {
585         ide_drive_t     *drive = (ide_drive_t *) data;
586         char            *out = page;
587         int             len;
588
589         if (drive->id_read)
590                 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
591         else
592                 len = sprintf(out,"(none)\n");
593         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
594 }
595
596 static int proc_idedisk_read_capacity
597         (char *page, char **start, off_t off, int count, int *eof, void *data)
598 {
599         ide_drive_t*drive = (ide_drive_t *)data;
600         int len;
601
602         len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
603         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
604 }
605
606 static int proc_idedisk_read_smart_thresholds
607         (char *page, char **start, off_t off, int count, int *eof, void *data)
608 {
609         ide_drive_t     *drive = (ide_drive_t *)data;
610         int             len = 0, i = 0;
611
612         if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
613                 unsigned short *val = (unsigned short *) page;
614                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
615                 page = out;
616                 do {
617                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
618                         val += 1;
619                 } while (i < (SECTOR_WORDS * 2));
620                 len = out - page;
621         }
622         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
623 }
624
625 static int proc_idedisk_read_smart_values
626         (char *page, char **start, off_t off, int count, int *eof, void *data)
627 {
628         ide_drive_t     *drive = (ide_drive_t *)data;
629         int             len = 0, i = 0;
630
631         if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
632                 unsigned short *val = (unsigned short *) page;
633                 char *out = ((char *)val) + (SECTOR_WORDS * 4);
634                 page = out;
635                 do {
636                         out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
637                         val += 1;
638                 } while (i < (SECTOR_WORDS * 2));
639                 len = out - page;
640         }
641         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
642 }
643
644 static ide_proc_entry_t idedisk_proc[] = {
645         { "cache",              S_IFREG|S_IRUGO,        proc_idedisk_read_cache,                NULL },
646         { "capacity",           S_IFREG|S_IRUGO,        proc_idedisk_read_capacity,             NULL },
647         { "geometry",           S_IFREG|S_IRUGO,        proc_ide_read_geometry,                 NULL },
648         { "smart_values",       S_IFREG|S_IRUSR,        proc_idedisk_read_smart_values,         NULL },
649         { "smart_thresholds",   S_IFREG|S_IRUSR,        proc_idedisk_read_smart_thresholds,     NULL },
650         { NULL, 0, NULL, NULL }
651 };
652 #endif  /* CONFIG_IDE_PROC_FS */
653
654 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
655 {
656         ide_drive_t *drive = q->queuedata;
657
658         memset(rq->cmd, 0, sizeof(rq->cmd));
659
660         if (ide_id_has_flush_cache_ext(drive->id) &&
661             (drive->capacity64 >= (1UL << 28)))
662                 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
663         else
664                 rq->cmd[0] = WIN_FLUSH_CACHE;
665
666
667         rq->cmd_type = REQ_TYPE_ATA_TASK;
668         rq->cmd_flags |= REQ_SOFTBARRIER;
669         rq->buffer = rq->cmd;
670 }
671
672 /*
673  * This is tightly woven into the driver->do_special can not touch.
674  * DON'T do it again until a total personality rewrite is committed.
675  */
676 static int set_multcount(ide_drive_t *drive, int arg)
677 {
678         struct request rq;
679
680         if (arg < 0 || arg > drive->id->max_multsect)
681                 return -EINVAL;
682
683         if (drive->special.b.set_multmode)
684                 return -EBUSY;
685         ide_init_drive_cmd (&rq);
686         rq.cmd_type = REQ_TYPE_ATA_CMD;
687         drive->mult_req = arg;
688         drive->special.b.set_multmode = 1;
689         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
690         return (drive->mult_count == arg) ? 0 : -EIO;
691 }
692
693 static int set_nowerr(ide_drive_t *drive, int arg)
694 {
695         if (arg < 0 || arg > 1)
696                 return -EINVAL;
697
698         if (ide_spin_wait_hwgroup(drive))
699                 return -EBUSY;
700         drive->nowerr = arg;
701         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
702         spin_unlock_irq(&ide_lock);
703         return 0;
704 }
705
706 static void update_ordered(ide_drive_t *drive)
707 {
708         struct hd_driveid *id = drive->id;
709         unsigned ordered = QUEUE_ORDERED_NONE;
710         prepare_flush_fn *prep_fn = NULL;
711
712         if (drive->wcache) {
713                 unsigned long long capacity;
714                 int barrier;
715                 /*
716                  * We must avoid issuing commands a drive does not
717                  * understand or we may crash it. We check flush cache
718                  * is supported. We also check we have the LBA48 flush
719                  * cache if the drive capacity is too large. By this
720                  * time we have trimmed the drive capacity if LBA48 is
721                  * not available so we don't need to recheck that.
722                  */
723                 capacity = idedisk_capacity(drive);
724                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
725                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
726                          ide_id_has_flush_cache_ext(id));
727
728                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
729                        drive->name, barrier ? "" : "not ");
730
731                 if (barrier) {
732                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
733                         prep_fn = idedisk_prepare_flush;
734                 }
735         } else
736                 ordered = QUEUE_ORDERED_DRAIN;
737
738         blk_queue_ordered(drive->queue, ordered, prep_fn);
739 }
740
741 static int write_cache(ide_drive_t *drive, int arg)
742 {
743         ide_task_t args;
744         int err = 1;
745
746         if (arg < 0 || arg > 1)
747                 return -EINVAL;
748
749         if (ide_id_has_flush_cache(drive->id)) {
750                 memset(&args, 0, sizeof(ide_task_t));
751                 args.tf.feature = arg ?
752                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
753                 args.tf.command = WIN_SETFEATURES;
754                 args.command_type               = IDE_DRIVE_TASK_NO_DATA;
755                 args.handler                    = &task_no_data_intr;
756                 err = ide_raw_taskfile(drive, &args, NULL);
757                 if (err == 0)
758                         drive->wcache = arg;
759         }
760
761         update_ordered(drive);
762
763         return err;
764 }
765
766 static int do_idedisk_flushcache (ide_drive_t *drive)
767 {
768         ide_task_t args;
769
770         memset(&args, 0, sizeof(ide_task_t));
771         if (ide_id_has_flush_cache_ext(drive->id))
772                 args.tf.command = WIN_FLUSH_CACHE_EXT;
773         else
774                 args.tf.command = WIN_FLUSH_CACHE;
775         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
776         args.handler                            = &task_no_data_intr;
777         return ide_raw_taskfile(drive, &args, NULL);
778 }
779
780 static int set_acoustic (ide_drive_t *drive, int arg)
781 {
782         ide_task_t args;
783
784         if (arg < 0 || arg > 254)
785                 return -EINVAL;
786
787         memset(&args, 0, sizeof(ide_task_t));
788         args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
789         args.tf.nsect   = arg;
790         args.tf.command = WIN_SETFEATURES;
791         args.command_type = IDE_DRIVE_TASK_NO_DATA;
792         args.handler      = &task_no_data_intr;
793         ide_raw_taskfile(drive, &args, NULL);
794         drive->acoustic = arg;
795         return 0;
796 }
797
798 /*
799  * drive->addressing:
800  *      0: 28-bit
801  *      1: 48-bit
802  *      2: 48-bit capable doing 28-bit
803  */
804 static int set_lba_addressing(ide_drive_t *drive, int arg)
805 {
806         if (arg < 0 || arg > 2)
807                 return -EINVAL;
808
809         drive->addressing =  0;
810
811         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
812                 return 0;
813
814         if (!idedisk_supports_lba48(drive->id))
815                 return -EIO;
816         drive->addressing = arg;
817         return 0;
818 }
819
820 #ifdef CONFIG_IDE_PROC_FS
821 static void idedisk_add_settings(ide_drive_t *drive)
822 {
823         struct hd_driveid *id = drive->id;
824
825         ide_add_setting(drive,  "bios_cyl",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->bios_cyl,       NULL);
826         ide_add_setting(drive,  "bios_head",    SETTING_RW,     TYPE_BYTE,      0,      255,                    1,      1,      &drive->bios_head,      NULL);
827         ide_add_setting(drive,  "bios_sect",    SETTING_RW,     TYPE_BYTE,      0,      63,                     1,      1,      &drive->bios_sect,      NULL);
828         ide_add_setting(drive,  "address",      SETTING_RW,     TYPE_BYTE,      0,      2,                      1,      1,      &drive->addressing,     set_lba_addressing);
829         ide_add_setting(drive,  "bswap",        SETTING_READ,   TYPE_BYTE,      0,      1,                      1,      1,      &drive->bswap,          NULL);
830         ide_add_setting(drive,  "multcount",    SETTING_RW,     TYPE_BYTE,      0,      id->max_multsect,       1,      1,      &drive->mult_count,     set_multcount);
831         ide_add_setting(drive,  "nowerr",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->nowerr,         set_nowerr);
832         ide_add_setting(drive,  "lun",          SETTING_RW,     TYPE_INT,       0,      7,                      1,      1,      &drive->lun,            NULL);
833         ide_add_setting(drive,  "wcache",       SETTING_RW,     TYPE_BYTE,      0,      1,                      1,      1,      &drive->wcache,         write_cache);
834         ide_add_setting(drive,  "acoustic",     SETTING_RW,     TYPE_BYTE,      0,      254,                    1,      1,      &drive->acoustic,       set_acoustic);
835         ide_add_setting(drive,  "failures",     SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->failures,       NULL);
836         ide_add_setting(drive,  "max_failures", SETTING_RW,     TYPE_INT,       0,      65535,                  1,      1,      &drive->max_failures,   NULL);
837 }
838 #else
839 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
840 #endif
841
842 static void idedisk_setup (ide_drive_t *drive)
843 {
844         ide_hwif_t *hwif = drive->hwif;
845         struct hd_driveid *id = drive->id;
846         unsigned long long capacity;
847
848         idedisk_add_settings(drive);
849
850         if (drive->id_read == 0)
851                 return;
852
853         if (drive->removable) {
854                 /*
855                  * Removable disks (eg. SYQUEST); ignore 'WD' drives 
856                  */
857                 if (id->model[0] != 'W' || id->model[1] != 'D') {
858                         drive->doorlocking = 1;
859                 }
860         }
861
862         (void)set_lba_addressing(drive, 1);
863
864         if (drive->addressing == 1) {
865                 int max_s = 2048;
866
867                 if (max_s > hwif->rqsize)
868                         max_s = hwif->rqsize;
869
870                 blk_queue_max_sectors(drive->queue, max_s);
871         }
872
873         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
874
875         /* calculate drive capacity, and select LBA if possible */
876         init_idedisk_capacity (drive);
877
878         /* limit drive capacity to 137GB if LBA48 cannot be used */
879         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
880                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
881                        "%llu sectors (%llu MB)\n",
882                        drive->name, (unsigned long long)drive->capacity64,
883                        sectors_to_MB(drive->capacity64));
884                 drive->capacity64 = 1ULL << 28;
885         }
886
887         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
888                 if (drive->capacity64 > 1ULL << 28) {
889                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
890                                          " be used for accessing sectors > %u\n",
891                                          drive->name, 1 << 28);
892                 } else
893                         drive->addressing = 0;
894         }
895
896         /*
897          * if possible, give fdisk access to more of the drive,
898          * by correcting bios_cyls:
899          */
900         capacity = idedisk_capacity (drive);
901         if (!drive->forced_geom) {
902
903                 if (idedisk_supports_lba48(drive->id)) {
904                         /* compatibility */
905                         drive->bios_sect = 63;
906                         drive->bios_head = 255;
907                 }
908
909                 if (drive->bios_sect && drive->bios_head) {
910                         unsigned int cap0 = capacity; /* truncate to 32 bits */
911                         unsigned int cylsz, cyl;
912
913                         if (cap0 != capacity)
914                                 drive->bios_cyl = 65535;
915                         else {
916                                 cylsz = drive->bios_sect * drive->bios_head;
917                                 cyl = cap0 / cylsz;
918                                 if (cyl > 65535)
919                                         cyl = 65535;
920                                 if (cyl > drive->bios_cyl)
921                                         drive->bios_cyl = cyl;
922                         }
923                 }
924         }
925         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
926                          drive->name, capacity, sectors_to_MB(capacity));
927
928         /* Only print cache size when it was specified */
929         if (id->buf_size)
930                 printk (" w/%dKiB Cache", id->buf_size/2);
931
932         printk(KERN_CONT ", CHS=%d/%d/%d\n",
933                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
934
935         /* write cache enabled? */
936         if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
937                 drive->wcache = 1;
938
939         write_cache(drive, 1);
940 }
941
942 static void ide_cacheflush_p(ide_drive_t *drive)
943 {
944         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
945                 return;
946
947         if (do_idedisk_flushcache(drive))
948                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
949 }
950
951 static void ide_disk_remove(ide_drive_t *drive)
952 {
953         struct ide_disk_obj *idkp = drive->driver_data;
954         struct gendisk *g = idkp->disk;
955
956         ide_proc_unregister_driver(drive, idkp->driver);
957
958         del_gendisk(g);
959
960         ide_cacheflush_p(drive);
961
962         ide_disk_put(idkp);
963 }
964
965 static void ide_disk_release(struct kref *kref)
966 {
967         struct ide_disk_obj *idkp = to_ide_disk(kref);
968         ide_drive_t *drive = idkp->drive;
969         struct gendisk *g = idkp->disk;
970
971         drive->driver_data = NULL;
972         g->private_data = NULL;
973         put_disk(g);
974         kfree(idkp);
975 }
976
977 static int ide_disk_probe(ide_drive_t *drive);
978
979 /*
980  * On HPA drives the capacity needs to be
981  * reinitilized on resume otherwise the disk
982  * can not be used and a hard reset is required
983  */
984 static void ide_disk_resume(ide_drive_t *drive)
985 {
986         if (idedisk_supports_hpa(drive->id))
987                 init_idedisk_capacity(drive);
988 }
989
990 static void ide_device_shutdown(ide_drive_t *drive)
991 {
992 #ifdef  CONFIG_ALPHA
993         /* On Alpha, halt(8) doesn't actually turn the machine off,
994            it puts you into the sort of firmware monitor. Typically,
995            it's used to boot another kernel image, so it's not much
996            different from reboot(8). Therefore, we don't need to
997            spin down the disk in this case, especially since Alpha
998            firmware doesn't handle disks in standby mode properly.
999            On the other hand, it's reasonably safe to turn the power
1000            off when the shutdown process reaches the firmware prompt,
1001            as the firmware initialization takes rather long time -
1002            at least 10 seconds, which should be sufficient for
1003            the disk to expire its write cache. */
1004         if (system_state != SYSTEM_POWER_OFF) {
1005 #else
1006         if (system_state == SYSTEM_RESTART) {
1007 #endif
1008                 ide_cacheflush_p(drive);
1009                 return;
1010         }
1011
1012         printk("Shutdown: %s\n", drive->name);
1013         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
1014 }
1015
1016 static ide_driver_t idedisk_driver = {
1017         .gen_driver = {
1018                 .owner          = THIS_MODULE,
1019                 .name           = "ide-disk",
1020                 .bus            = &ide_bus_type,
1021         },
1022         .probe                  = ide_disk_probe,
1023         .remove                 = ide_disk_remove,
1024         .resume                 = ide_disk_resume,
1025         .shutdown               = ide_device_shutdown,
1026         .version                = IDEDISK_VERSION,
1027         .media                  = ide_disk,
1028         .supports_dsc_overlap   = 0,
1029         .do_request             = ide_do_rw_disk,
1030         .end_request            = ide_end_request,
1031         .error                  = __ide_error,
1032         .abort                  = __ide_abort,
1033 #ifdef CONFIG_IDE_PROC_FS
1034         .proc                   = idedisk_proc,
1035 #endif
1036 };
1037
1038 static int idedisk_open(struct inode *inode, struct file *filp)
1039 {
1040         struct gendisk *disk = inode->i_bdev->bd_disk;
1041         struct ide_disk_obj *idkp;
1042         ide_drive_t *drive;
1043
1044         if (!(idkp = ide_disk_get(disk)))
1045                 return -ENXIO;
1046
1047         drive = idkp->drive;
1048
1049         idkp->openers++;
1050
1051         if (drive->removable && idkp->openers == 1) {
1052                 ide_task_t args;
1053                 memset(&args, 0, sizeof(ide_task_t));
1054                 args.tf.command = WIN_DOORLOCK;
1055                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1056                 args.handler      = &task_no_data_intr;
1057                 check_disk_change(inode->i_bdev);
1058                 /*
1059                  * Ignore the return code from door_lock,
1060                  * since the open() has already succeeded,
1061                  * and the door_lock is irrelevant at this point.
1062                  */
1063                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1064                         drive->doorlocking = 0;
1065         }
1066         return 0;
1067 }
1068
1069 static int idedisk_release(struct inode *inode, struct file *filp)
1070 {
1071         struct gendisk *disk = inode->i_bdev->bd_disk;
1072         struct ide_disk_obj *idkp = ide_disk_g(disk);
1073         ide_drive_t *drive = idkp->drive;
1074
1075         if (idkp->openers == 1)
1076                 ide_cacheflush_p(drive);
1077
1078         if (drive->removable && idkp->openers == 1) {
1079                 ide_task_t args;
1080                 memset(&args, 0, sizeof(ide_task_t));
1081                 args.tf.command = WIN_DOORUNLOCK;
1082                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1083                 args.handler      = &task_no_data_intr;
1084                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1085                         drive->doorlocking = 0;
1086         }
1087
1088         idkp->openers--;
1089
1090         ide_disk_put(idkp);
1091
1092         return 0;
1093 }
1094
1095 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1096 {
1097         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1098         ide_drive_t *drive = idkp->drive;
1099
1100         geo->heads = drive->bios_head;
1101         geo->sectors = drive->bios_sect;
1102         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1103         return 0;
1104 }
1105
1106 static int idedisk_ioctl(struct inode *inode, struct file *file,
1107                         unsigned int cmd, unsigned long arg)
1108 {
1109         unsigned long flags;
1110         struct block_device *bdev = inode->i_bdev;
1111         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1112         ide_drive_t *drive = idkp->drive;
1113         int err, (*setfunc)(ide_drive_t *, int);
1114         u8 *val;
1115
1116         switch (cmd) {
1117         case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
1118         case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
1119         case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
1120         case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
1121         case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
1122         case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
1123         case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
1124         case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
1125         case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
1126         case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
1127         }
1128
1129         return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1130
1131 read_val:
1132         mutex_lock(&ide_setting_mtx);
1133         spin_lock_irqsave(&ide_lock, flags);
1134         err = *val;
1135         spin_unlock_irqrestore(&ide_lock, flags);
1136         mutex_unlock(&ide_setting_mtx);
1137         return err >= 0 ? put_user(err, (long __user *)arg) : err;
1138
1139 set_val:
1140         if (bdev != bdev->bd_contains)
1141                 err = -EINVAL;
1142         else {
1143                 if (!capable(CAP_SYS_ADMIN))
1144                         err = -EACCES;
1145                 else {
1146                         mutex_lock(&ide_setting_mtx);
1147                         err = setfunc(drive, arg);
1148                         mutex_unlock(&ide_setting_mtx);
1149                 }
1150         }
1151         return err;
1152 }
1153
1154 static int idedisk_media_changed(struct gendisk *disk)
1155 {
1156         struct ide_disk_obj *idkp = ide_disk_g(disk);
1157         ide_drive_t *drive = idkp->drive;
1158
1159         /* do not scan partitions twice if this is a removable device */
1160         if (drive->attach) {
1161                 drive->attach = 0;
1162                 return 0;
1163         }
1164         /* if removable, always assume it was changed */
1165         return drive->removable;
1166 }
1167
1168 static int idedisk_revalidate_disk(struct gendisk *disk)
1169 {
1170         struct ide_disk_obj *idkp = ide_disk_g(disk);
1171         set_capacity(disk, idedisk_capacity(idkp->drive));
1172         return 0;
1173 }
1174
1175 static struct block_device_operations idedisk_ops = {
1176         .owner          = THIS_MODULE,
1177         .open           = idedisk_open,
1178         .release        = idedisk_release,
1179         .ioctl          = idedisk_ioctl,
1180         .getgeo         = idedisk_getgeo,
1181         .media_changed  = idedisk_media_changed,
1182         .revalidate_disk= idedisk_revalidate_disk
1183 };
1184
1185 MODULE_DESCRIPTION("ATA DISK Driver");
1186
1187 static int ide_disk_probe(ide_drive_t *drive)
1188 {
1189         struct ide_disk_obj *idkp;
1190         struct gendisk *g;
1191
1192         /* strstr("foo", "") is non-NULL */
1193         if (!strstr("ide-disk", drive->driver_req))
1194                 goto failed;
1195         if (!drive->present)
1196                 goto failed;
1197         if (drive->media != ide_disk)
1198                 goto failed;
1199
1200         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1201         if (!idkp)
1202                 goto failed;
1203
1204         g = alloc_disk_node(1 << PARTN_BITS,
1205                         hwif_to_node(drive->hwif));
1206         if (!g)
1207                 goto out_free_idkp;
1208
1209         ide_init_disk(g, drive);
1210
1211         ide_proc_register_driver(drive, &idedisk_driver);
1212
1213         kref_init(&idkp->kref);
1214
1215         idkp->drive = drive;
1216         idkp->driver = &idedisk_driver;
1217         idkp->disk = g;
1218
1219         g->private_data = &idkp->driver;
1220
1221         drive->driver_data = idkp;
1222
1223         idedisk_setup(drive);
1224         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1225                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1226                         drive->name, drive->head);
1227                 drive->attach = 0;
1228         } else
1229                 drive->attach = 1;
1230
1231         g->minors = 1 << PARTN_BITS;
1232         g->driverfs_dev = &drive->gendev;
1233         g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1234         set_capacity(g, idedisk_capacity(drive));
1235         g->fops = &idedisk_ops;
1236         add_disk(g);
1237         return 0;
1238
1239 out_free_idkp:
1240         kfree(idkp);
1241 failed:
1242         return -ENODEV;
1243 }
1244
1245 static void __exit idedisk_exit (void)
1246 {
1247         driver_unregister(&idedisk_driver.gen_driver);
1248 }
1249
1250 static int __init idedisk_init(void)
1251 {
1252         return driver_register(&idedisk_driver.gen_driver);
1253 }
1254
1255 MODULE_ALIAS("ide:*m-disk*");
1256 module_init(idedisk_init);
1257 module_exit(idedisk_exit);
1258 MODULE_LICENSE("GPL");