[PATCH] powerpc/cell spidernet fix error interrupt print
[pandora-kernel.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  * 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 #undef REALLY_SLOW_IO           /* most systems can safely undef this */
47
48 //#define DEBUG
49
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>
64
65 #define _IDE_DISK
66
67 #include <linux/ide.h>
68
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>
74
75 struct ide_disk_obj {
76         ide_drive_t     *drive;
77         ide_driver_t    *driver;
78         struct gendisk  *disk;
79         struct kref     kref;
80 };
81
82 static DEFINE_MUTEX(idedisk_ref_mutex);
83
84 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
85
86 #define ide_disk_g(disk) \
87         container_of((disk)->private_data, struct ide_disk_obj, driver)
88
89 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
90 {
91         struct ide_disk_obj *idkp = NULL;
92
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 }
100
101 static void ide_disk_release(struct kref *);
102
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 }
109
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;
122
123         /* No non-LBA info .. so valid! */
124         if (id->cyls == 0)
125                 return 1;
126
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;
139
140         lba_sects   = id->lba_capacity;
141         chs_sects   = id->cyls * id->heads * id->sectors;
142
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;
146
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         }
155
156         return 0;       /* lba_capacity value may be bad */
157 }
158
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;
170
171         nsectors.all            = (u16) rq->nr_sectors;
172
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         }
179
180         if (!dma) {
181                 ide_init_sg_cmd(drive, rq);
182                 ide_map_sg(drive, rq);
183         }
184
185         if (IDE_CONTROL_REG)
186                 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
187
188         /* FIXME: SELECT_MASK(drive, 0) ? */
189
190         if (drive->select.b.lba) {
191                 if (lba48) {
192                         task_ioreg_t tasklets[10];
193
194                         pr_debug("%s: LBA=0x%012llx\n", drive->name,
195                                         (unsigned long long)block);
196
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);
223
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;
245
246                 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
247
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         }
254
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         }
273
274         if (rq_data_dir(rq) == READ) {
275
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                 }
283
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                 }
294
295                 /* FIXME: ->OUTBSYNC ? */
296                 hwif->OUTB(command, IDE_COMMAND_REG);
297
298                 return pre_task_out_intr(drive, rq);
299         }
300 }
301
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  */
307
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);
311
312         BUG_ON(drive->blocked);
313
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         }
319
320         ledtrig_ide_activity();
321
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);
326
327         if (hwif->rw_disk)
328                 hwif->rw_disk(drive, rq);
329
330         return __ide_do_rw_disk(drive, rq, block);
331 }
332
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;
341
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);
350
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 }
361
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;
366
367         /* Create IDE/ATA command request structure */
368         memset(&args, 0, sizeof(ide_task_t));
369
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);
376
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 }
390
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;
399         
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 }
422
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;
427
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 }
458
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 }
465
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 }
475
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 }
484
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);
489
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);
495
496         if (set_max <= capacity)
497                 return;
498
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));
505
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 }
516
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);
539
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 }
557
558 static sector_t idedisk_capacity (ide_drive_t *drive)
559 {
560         return drive->capacity64 - drive->sect0;
561 }
562
563 #ifdef CONFIG_PROC_FS
564
565 static int smart_enable(ide_drive_t *drive)
566 {
567         ide_task_t args;
568
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 }
578
579 static int get_smart_values(ide_drive_t *drive, u8 *buf)
580 {
581         ide_task_t args;
582
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 }
595
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 }
611
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;
618
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 }
625
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;
631
632         len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
633         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
634 }
635
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;
641
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 }
654
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;
660
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 }
673
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 };
682
683 #else
684
685 #define idedisk_proc    NULL
686
687 #endif  /* CONFIG_PROC_FS */
688
689 static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
690 {
691         ide_drive_t *drive = q->queuedata;
692
693         memset(rq->cmd, 0, sizeof(rq->cmd));
694
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;
700
701
702         rq->cmd_type = REQ_TYPE_ATA_TASK;
703         rq->cmd_flags |= REQ_SOFTBARRIER;
704         rq->buffer = rq->cmd;
705 }
706
707 static int idedisk_issue_flush(request_queue_t *q, struct gendisk *disk,
708                                sector_t *error_sector)
709 {
710         ide_drive_t *drive = q->queuedata;
711         struct request *rq;
712         int ret;
713
714         if (!drive->wcache)
715                 return 0;
716
717         rq = blk_get_request(q, WRITE, __GFP_WAIT);
718
719         idedisk_prepare_flush(q, rq);
720
721         ret = blk_execute_rq(q, disk, rq, 0);
722
723         /*
724          * if we failed and caller wants error offset, get it
725          */
726         if (ret && error_sector)
727                 *error_sector = ide_get_error_location(drive, rq->cmd);
728
729         blk_put_request(rq);
730         return ret;
731 }
732
733 /*
734  * This is tightly woven into the driver->do_special can not touch.
735  * DON'T do it again until a total personality rewrite is committed.
736  */
737 static int set_multcount(ide_drive_t *drive, int arg)
738 {
739         struct request rq;
740
741         if (drive->special.b.set_multmode)
742                 return -EBUSY;
743         ide_init_drive_cmd (&rq);
744         rq.cmd_type = REQ_TYPE_ATA_CMD;
745         drive->mult_req = arg;
746         drive->special.b.set_multmode = 1;
747         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
748         return (drive->mult_count == arg) ? 0 : -EIO;
749 }
750
751 static int set_nowerr(ide_drive_t *drive, int arg)
752 {
753         if (ide_spin_wait_hwgroup(drive))
754                 return -EBUSY;
755         drive->nowerr = arg;
756         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
757         spin_unlock_irq(&ide_lock);
758         return 0;
759 }
760
761 static void update_ordered(ide_drive_t *drive)
762 {
763         struct hd_driveid *id = drive->id;
764         unsigned ordered = QUEUE_ORDERED_NONE;
765         prepare_flush_fn *prep_fn = NULL;
766         issue_flush_fn *issue_fn = NULL;
767
768         if (drive->wcache) {
769                 unsigned long long capacity;
770                 int barrier;
771                 /*
772                  * We must avoid issuing commands a drive does not
773                  * understand or we may crash it. We check flush cache
774                  * is supported. We also check we have the LBA48 flush
775                  * cache if the drive capacity is too large. By this
776                  * time we have trimmed the drive capacity if LBA48 is
777                  * not available so we don't need to recheck that.
778                  */
779                 capacity = idedisk_capacity(drive);
780                 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
781                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
782                          ide_id_has_flush_cache_ext(id));
783
784                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
785                        drive->name, barrier ? "" : "not ");
786
787                 if (barrier) {
788                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
789                         prep_fn = idedisk_prepare_flush;
790                         issue_fn = idedisk_issue_flush;
791                 }
792         } else
793                 ordered = QUEUE_ORDERED_DRAIN;
794
795         blk_queue_ordered(drive->queue, ordered, prep_fn);
796         blk_queue_issue_flush_fn(drive->queue, issue_fn);
797 }
798
799 static int write_cache(ide_drive_t *drive, int arg)
800 {
801         ide_task_t args;
802         int err = 1;
803
804         if (ide_id_has_flush_cache(drive->id)) {
805                 memset(&args, 0, sizeof(ide_task_t));
806                 args.tfRegister[IDE_FEATURE_OFFSET]     = (arg) ?
807                         SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
808                 args.tfRegister[IDE_COMMAND_OFFSET]     = WIN_SETFEATURES;
809                 args.command_type               = IDE_DRIVE_TASK_NO_DATA;
810                 args.handler                    = &task_no_data_intr;
811                 err = ide_raw_taskfile(drive, &args, NULL);
812                 if (err == 0)
813                         drive->wcache = arg;
814         }
815
816         update_ordered(drive);
817
818         return err;
819 }
820
821 static int do_idedisk_flushcache (ide_drive_t *drive)
822 {
823         ide_task_t args;
824
825         memset(&args, 0, sizeof(ide_task_t));
826         if (ide_id_has_flush_cache_ext(drive->id))
827                 args.tfRegister[IDE_COMMAND_OFFSET]     = WIN_FLUSH_CACHE_EXT;
828         else
829                 args.tfRegister[IDE_COMMAND_OFFSET]     = WIN_FLUSH_CACHE;
830         args.command_type                       = IDE_DRIVE_TASK_NO_DATA;
831         args.handler                            = &task_no_data_intr;
832         return ide_raw_taskfile(drive, &args, NULL);
833 }
834
835 static int set_acoustic (ide_drive_t *drive, int arg)
836 {
837         ide_task_t args;
838
839         memset(&args, 0, sizeof(ide_task_t));
840         args.tfRegister[IDE_FEATURE_OFFSET]     = (arg) ? SETFEATURES_EN_AAM :
841                                                           SETFEATURES_DIS_AAM;
842         args.tfRegister[IDE_NSECTOR_OFFSET]     = arg;
843         args.tfRegister[IDE_COMMAND_OFFSET]     = WIN_SETFEATURES;
844         args.command_type = IDE_DRIVE_TASK_NO_DATA;
845         args.handler      = &task_no_data_intr;
846         ide_raw_taskfile(drive, &args, NULL);
847         drive->acoustic = arg;
848         return 0;
849 }
850
851 /*
852  * drive->addressing:
853  *      0: 28-bit
854  *      1: 48-bit
855  *      2: 48-bit capable doing 28-bit
856  */
857 static int set_lba_addressing(ide_drive_t *drive, int arg)
858 {
859         drive->addressing =  0;
860
861         if (HWIF(drive)->no_lba48)
862                 return 0;
863
864         if (!idedisk_supports_lba48(drive->id))
865                 return -EIO;
866         drive->addressing = arg;
867         return 0;
868 }
869
870 static void idedisk_add_settings(ide_drive_t *drive)
871 {
872         struct hd_driveid *id = drive->id;
873
874         ide_add_setting(drive,  "bios_cyl",             SETTING_RW,                                     -1,                     -1,                     TYPE_INT,       0,      65535,                          1,      1,      &drive->bios_cyl,               NULL);
875         ide_add_setting(drive,  "bios_head",            SETTING_RW,                                     -1,                     -1,                     TYPE_BYTE,      0,      255,                            1,      1,      &drive->bios_head,              NULL);
876         ide_add_setting(drive,  "bios_sect",            SETTING_RW,                                     -1,                     -1,                     TYPE_BYTE,      0,      63,                             1,      1,      &drive->bios_sect,              NULL);
877         ide_add_setting(drive,  "address",              SETTING_RW,                                     HDIO_GET_ADDRESS,       HDIO_SET_ADDRESS,       TYPE_INTA,      0,      2,                              1,      1,      &drive->addressing,     set_lba_addressing);
878         ide_add_setting(drive,  "bswap",                SETTING_READ,                                   -1,                     -1,                     TYPE_BYTE,      0,      1,                              1,      1,      &drive->bswap,                  NULL);
879         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);
880         ide_add_setting(drive,  "nowerr",               SETTING_RW,                                     HDIO_GET_NOWERR,        HDIO_SET_NOWERR,        TYPE_BYTE,      0,      1,                              1,      1,      &drive->nowerr,                 set_nowerr);
881         ide_add_setting(drive,  "lun",                  SETTING_RW,                                     -1,                     -1,                     TYPE_INT,       0,      7,                              1,      1,      &drive->lun,                    NULL);
882         ide_add_setting(drive,  "wcache",               SETTING_RW,                                     HDIO_GET_WCACHE,        HDIO_SET_WCACHE,        TYPE_BYTE,      0,      1,                              1,      1,      &drive->wcache,                 write_cache);
883         ide_add_setting(drive,  "acoustic",             SETTING_RW,                                     HDIO_GET_ACOUSTIC,      HDIO_SET_ACOUSTIC,      TYPE_BYTE,      0,      254,                            1,      1,      &drive->acoustic,               set_acoustic);
884         ide_add_setting(drive,  "failures",             SETTING_RW,                                     -1,                     -1,                     TYPE_INT,       0,      65535,                          1,      1,      &drive->failures,               NULL);
885         ide_add_setting(drive,  "max_failures",         SETTING_RW,                                     -1,                     -1,                     TYPE_INT,       0,      65535,                          1,      1,      &drive->max_failures,           NULL);
886 }
887
888 static void idedisk_setup (ide_drive_t *drive)
889 {
890         struct hd_driveid *id = drive->id;
891         unsigned long long capacity;
892
893         idedisk_add_settings(drive);
894
895         if (drive->id_read == 0)
896                 return;
897
898         if (drive->removable) {
899                 /*
900                  * Removable disks (eg. SYQUEST); ignore 'WD' drives 
901                  */
902                 if (id->model[0] != 'W' || id->model[1] != 'D') {
903                         drive->doorlocking = 1;
904                 }
905         }
906
907         (void)set_lba_addressing(drive, 1);
908
909         if (drive->addressing == 1) {
910                 ide_hwif_t *hwif = HWIF(drive);
911                 int max_s = 2048;
912
913                 if (max_s > hwif->rqsize)
914                         max_s = hwif->rqsize;
915
916                 blk_queue_max_sectors(drive->queue, max_s);
917         }
918
919         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
920
921         /* calculate drive capacity, and select LBA if possible */
922         init_idedisk_capacity (drive);
923
924         /* limit drive capacity to 137GB if LBA48 cannot be used */
925         if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
926                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
927                        "%llu sectors (%llu MB)\n",
928                        drive->name, (unsigned long long)drive->capacity64,
929                        sectors_to_MB(drive->capacity64));
930                 drive->capacity64 = 1ULL << 28;
931         }
932
933         if (drive->hwif->no_lba48_dma && drive->addressing) {
934                 if (drive->capacity64 > 1ULL << 28) {
935                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
936                                          " be used for accessing sectors > %u\n",
937                                          drive->name, 1 << 28);
938                 } else
939                         drive->addressing = 0;
940         }
941
942         /*
943          * if possible, give fdisk access to more of the drive,
944          * by correcting bios_cyls:
945          */
946         capacity = idedisk_capacity (drive);
947         if (!drive->forced_geom) {
948
949                 if (idedisk_supports_lba48(drive->id)) {
950                         /* compatibility */
951                         drive->bios_sect = 63;
952                         drive->bios_head = 255;
953                 }
954
955                 if (drive->bios_sect && drive->bios_head) {
956                         unsigned int cap0 = capacity; /* truncate to 32 bits */
957                         unsigned int cylsz, cyl;
958
959                         if (cap0 != capacity)
960                                 drive->bios_cyl = 65535;
961                         else {
962                                 cylsz = drive->bios_sect * drive->bios_head;
963                                 cyl = cap0 / cylsz;
964                                 if (cyl > 65535)
965                                         cyl = 65535;
966                                 if (cyl > drive->bios_cyl)
967                                         drive->bios_cyl = cyl;
968                         }
969                 }
970         }
971         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
972                          drive->name, capacity, sectors_to_MB(capacity));
973
974         /* Only print cache size when it was specified */
975         if (id->buf_size)
976                 printk (" w/%dKiB Cache", id->buf_size/2);
977
978         printk(", CHS=%d/%d/%d", 
979                drive->bios_cyl, drive->bios_head, drive->bios_sect);
980         if (drive->using_dma)
981                 ide_dma_verbose(drive);
982         printk("\n");
983
984         /* write cache enabled? */
985         if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
986                 drive->wcache = 1;
987
988         write_cache(drive, 1);
989 }
990
991 static void ide_cacheflush_p(ide_drive_t *drive)
992 {
993         if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
994                 return;
995
996         if (do_idedisk_flushcache(drive))
997                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
998 }
999
1000 static void ide_disk_remove(ide_drive_t *drive)
1001 {
1002         struct ide_disk_obj *idkp = drive->driver_data;
1003         struct gendisk *g = idkp->disk;
1004
1005         ide_unregister_subdriver(drive, idkp->driver);
1006
1007         del_gendisk(g);
1008
1009         ide_cacheflush_p(drive);
1010
1011         ide_disk_put(idkp);
1012 }
1013
1014 static void ide_disk_release(struct kref *kref)
1015 {
1016         struct ide_disk_obj *idkp = to_ide_disk(kref);
1017         ide_drive_t *drive = idkp->drive;
1018         struct gendisk *g = idkp->disk;
1019
1020         drive->driver_data = NULL;
1021         g->private_data = NULL;
1022         put_disk(g);
1023         kfree(idkp);
1024 }
1025
1026 static int ide_disk_probe(ide_drive_t *drive);
1027
1028 static void ide_device_shutdown(ide_drive_t *drive)
1029 {
1030 #ifdef  CONFIG_ALPHA
1031         /* On Alpha, halt(8) doesn't actually turn the machine off,
1032            it puts you into the sort of firmware monitor. Typically,
1033            it's used to boot another kernel image, so it's not much
1034            different from reboot(8). Therefore, we don't need to
1035            spin down the disk in this case, especially since Alpha
1036            firmware doesn't handle disks in standby mode properly.
1037            On the other hand, it's reasonably safe to turn the power
1038            off when the shutdown process reaches the firmware prompt,
1039            as the firmware initialization takes rather long time -
1040            at least 10 seconds, which should be sufficient for
1041            the disk to expire its write cache. */
1042         if (system_state != SYSTEM_POWER_OFF) {
1043 #else
1044         if (system_state == SYSTEM_RESTART) {
1045 #endif
1046                 ide_cacheflush_p(drive);
1047                 return;
1048         }
1049
1050         printk("Shutdown: %s\n", drive->name);
1051         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
1052 }
1053
1054 static ide_driver_t idedisk_driver = {
1055         .gen_driver = {
1056                 .owner          = THIS_MODULE,
1057                 .name           = "ide-disk",
1058                 .bus            = &ide_bus_type,
1059         },
1060         .probe                  = ide_disk_probe,
1061         .remove                 = ide_disk_remove,
1062         .shutdown               = ide_device_shutdown,
1063         .version                = IDEDISK_VERSION,
1064         .media                  = ide_disk,
1065         .supports_dsc_overlap   = 0,
1066         .do_request             = ide_do_rw_disk,
1067         .end_request            = ide_end_request,
1068         .error                  = __ide_error,
1069         .abort                  = __ide_abort,
1070         .proc                   = idedisk_proc,
1071 };
1072
1073 static int idedisk_open(struct inode *inode, struct file *filp)
1074 {
1075         struct gendisk *disk = inode->i_bdev->bd_disk;
1076         struct ide_disk_obj *idkp;
1077         ide_drive_t *drive;
1078
1079         if (!(idkp = ide_disk_get(disk)))
1080                 return -ENXIO;
1081
1082         drive = idkp->drive;
1083
1084         drive->usage++;
1085         if (drive->removable && drive->usage == 1) {
1086                 ide_task_t args;
1087                 memset(&args, 0, sizeof(ide_task_t));
1088                 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
1089                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1090                 args.handler      = &task_no_data_intr;
1091                 check_disk_change(inode->i_bdev);
1092                 /*
1093                  * Ignore the return code from door_lock,
1094                  * since the open() has already succeeded,
1095                  * and the door_lock is irrelevant at this point.
1096                  */
1097                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1098                         drive->doorlocking = 0;
1099         }
1100         return 0;
1101 }
1102
1103 static int idedisk_release(struct inode *inode, struct file *filp)
1104 {
1105         struct gendisk *disk = inode->i_bdev->bd_disk;
1106         struct ide_disk_obj *idkp = ide_disk_g(disk);
1107         ide_drive_t *drive = idkp->drive;
1108
1109         if (drive->usage == 1)
1110                 ide_cacheflush_p(drive);
1111         if (drive->removable && drive->usage == 1) {
1112                 ide_task_t args;
1113                 memset(&args, 0, sizeof(ide_task_t));
1114                 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
1115                 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1116                 args.handler      = &task_no_data_intr;
1117                 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1118                         drive->doorlocking = 0;
1119         }
1120         drive->usage--;
1121
1122         ide_disk_put(idkp);
1123
1124         return 0;
1125 }
1126
1127 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1128 {
1129         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1130         ide_drive_t *drive = idkp->drive;
1131
1132         geo->heads = drive->bios_head;
1133         geo->sectors = drive->bios_sect;
1134         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1135         return 0;
1136 }
1137
1138 static int idedisk_ioctl(struct inode *inode, struct file *file,
1139                         unsigned int cmd, unsigned long arg)
1140 {
1141         struct block_device *bdev = inode->i_bdev;
1142         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1143         return generic_ide_ioctl(idkp->drive, file, bdev, cmd, arg);
1144 }
1145
1146 static int idedisk_media_changed(struct gendisk *disk)
1147 {
1148         struct ide_disk_obj *idkp = ide_disk_g(disk);
1149         ide_drive_t *drive = idkp->drive;
1150
1151         /* do not scan partitions twice if this is a removable device */
1152         if (drive->attach) {
1153                 drive->attach = 0;
1154                 return 0;
1155         }
1156         /* if removable, always assume it was changed */
1157         return drive->removable;
1158 }
1159
1160 static int idedisk_revalidate_disk(struct gendisk *disk)
1161 {
1162         struct ide_disk_obj *idkp = ide_disk_g(disk);
1163         set_capacity(disk, idedisk_capacity(idkp->drive));
1164         return 0;
1165 }
1166
1167 static struct block_device_operations idedisk_ops = {
1168         .owner          = THIS_MODULE,
1169         .open           = idedisk_open,
1170         .release        = idedisk_release,
1171         .ioctl          = idedisk_ioctl,
1172         .getgeo         = idedisk_getgeo,
1173         .media_changed  = idedisk_media_changed,
1174         .revalidate_disk= idedisk_revalidate_disk
1175 };
1176
1177 MODULE_DESCRIPTION("ATA DISK Driver");
1178
1179 static int ide_disk_probe(ide_drive_t *drive)
1180 {
1181         struct ide_disk_obj *idkp;
1182         struct gendisk *g;
1183
1184         /* strstr("foo", "") is non-NULL */
1185         if (!strstr("ide-disk", drive->driver_req))
1186                 goto failed;
1187         if (!drive->present)
1188                 goto failed;
1189         if (drive->media != ide_disk)
1190                 goto failed;
1191
1192         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1193         if (!idkp)
1194                 goto failed;
1195
1196         g = alloc_disk_node(1 << PARTN_BITS,
1197                         hwif_to_node(drive->hwif));
1198         if (!g)
1199                 goto out_free_idkp;
1200
1201         ide_init_disk(g, drive);
1202
1203         ide_register_subdriver(drive, &idedisk_driver);
1204
1205         kref_init(&idkp->kref);
1206
1207         idkp->drive = drive;
1208         idkp->driver = &idedisk_driver;
1209         idkp->disk = g;
1210
1211         g->private_data = &idkp->driver;
1212
1213         drive->driver_data = idkp;
1214
1215         idedisk_setup(drive);
1216         if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1217                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1218                         drive->name, drive->head);
1219                 drive->attach = 0;
1220         } else
1221                 drive->attach = 1;
1222
1223         g->minors = 1 << PARTN_BITS;
1224         g->driverfs_dev = &drive->gendev;
1225         g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1226         set_capacity(g, idedisk_capacity(drive));
1227         g->fops = &idedisk_ops;
1228         add_disk(g);
1229         return 0;
1230
1231 out_free_idkp:
1232         kfree(idkp);
1233 failed:
1234         return -ENODEV;
1235 }
1236
1237 static void __exit idedisk_exit (void)
1238 {
1239         driver_unregister(&idedisk_driver.gen_driver);
1240 }
1241
1242 static int __init idedisk_init(void)
1243 {
1244         return driver_register(&idedisk_driver.gen_driver);
1245 }
1246
1247 MODULE_ALIAS("ide:*m-disk*");
1248 module_init(idedisk_init);
1249 module_exit(idedisk_exit);
1250 MODULE_LICENSE("GPL");