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