Pull utrace into release branch
[linux-2.6] / drivers / ide / ide-disk.c
1 /*
2  *  Copyright (C) 1994-1998        Linus Torvalds & authors (see below)
3  *  Copyright (C) 1998-2002        Linux ATA Development
4  *                                    Andre Hedrick <andre@linux-ide.org>
5  *  Copyright (C) 2003             Red Hat <alan@redhat.com>
6  *  Copyright (C) 2003-2005, 2007  Bartlomiej Zolnierkiewicz
7  */
8
9 /*
10  *  Mostly written by Mark Lord <mlord@pobox.com>
11  *                and Gadi Oxman <gadio@netvision.net.il>
12  *                and Andre Hedrick <andre@linux-ide.org>
13  *
14  * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
15  */
16
17 #define IDEDISK_VERSION "1.18"
18
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/string.h>
22 #include <linux/kernel.h>
23 #include <linux/timer.h>
24 #include <linux/mm.h>
25 #include <linux/interrupt.h>
26 #include <linux/major.h>
27 #include <linux/errno.h>
28 #include <linux/genhd.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/mutex.h>
32 #include <linux/leds.h>
33 #include <linux/ide.h>
34 #include <linux/hdreg.h>
35
36 #include <asm/byteorder.h>
37 #include <asm/irq.h>
38 #include <asm/uaccess.h>
39 #include <asm/io.h>
40 #include <asm/div64.h>
41
42 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
43 #define IDE_DISK_MINORS         (1 << PARTN_BITS)
44 #else
45 #define IDE_DISK_MINORS         0
46 #endif
47
48 #include "ide-disk.h"
49
50 static DEFINE_MUTEX(idedisk_ref_mutex);
51
52 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
53
54 static void ide_disk_release(struct kref *);
55
56 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
57 {
58         struct ide_disk_obj *idkp = NULL;
59
60         mutex_lock(&idedisk_ref_mutex);
61         idkp = ide_disk_g(disk);
62         if (idkp) {
63                 if (ide_device_get(idkp->drive))
64                         idkp = NULL;
65                 else
66                         kref_get(&idkp->kref);
67         }
68         mutex_unlock(&idedisk_ref_mutex);
69         return idkp;
70 }
71
72 static void ide_disk_put(struct ide_disk_obj *idkp)
73 {
74         ide_drive_t *drive = idkp->drive;
75
76         mutex_lock(&idedisk_ref_mutex);
77         kref_put(&idkp->kref, ide_disk_release);
78         ide_device_put(drive);
79         mutex_unlock(&idedisk_ref_mutex);
80 }
81
82 static const u8 ide_rw_cmds[] = {
83         ATA_CMD_READ_MULTI,
84         ATA_CMD_WRITE_MULTI,
85         ATA_CMD_READ_MULTI_EXT,
86         ATA_CMD_WRITE_MULTI_EXT,
87         ATA_CMD_PIO_READ,
88         ATA_CMD_PIO_WRITE,
89         ATA_CMD_PIO_READ_EXT,
90         ATA_CMD_PIO_WRITE_EXT,
91         ATA_CMD_READ,
92         ATA_CMD_WRITE,
93         ATA_CMD_READ_EXT,
94         ATA_CMD_WRITE_EXT,
95 };
96
97 static const u8 ide_data_phases[] = {
98         TASKFILE_MULTI_IN,
99         TASKFILE_MULTI_OUT,
100         TASKFILE_IN,
101         TASKFILE_OUT,
102         TASKFILE_IN_DMA,
103         TASKFILE_OUT_DMA,
104 };
105
106 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
107 {
108         u8 index, lba48, write;
109
110         lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
111         write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
112
113         if (dma)
114                 index = 8;
115         else
116                 index = drive->mult_count ? 0 : 4;
117
118         task->tf.command = ide_rw_cmds[index + lba48 + write];
119
120         if (dma)
121                 index = 8; /* fixup index */
122
123         task->data_phase = ide_data_phases[index / 2 + write];
124 }
125
126 /*
127  * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
128  * using LBA if supported, or CHS otherwise, to address sectors.
129  */
130 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
131                                         sector_t block)
132 {
133         ide_hwif_t *hwif        = HWIF(drive);
134         u16 nsectors            = (u16)rq->nr_sectors;
135         u8 lba48                = !!(drive->dev_flags & IDE_DFLAG_LBA48);
136         u8 dma                  = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
137         ide_task_t              task;
138         struct ide_taskfile     *tf = &task.tf;
139         ide_startstop_t         rc;
140
141         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
142                 if (block + rq->nr_sectors > 1ULL << 28)
143                         dma = 0;
144                 else
145                         lba48 = 0;
146         }
147
148         if (!dma) {
149                 ide_init_sg_cmd(drive, rq);
150                 ide_map_sg(drive, rq);
151         }
152
153         memset(&task, 0, sizeof(task));
154         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
155
156         if (drive->dev_flags & IDE_DFLAG_LBA) {
157                 if (lba48) {
158                         pr_debug("%s: LBA=0x%012llx\n", drive->name,
159                                         (unsigned long long)block);
160
161                         tf->hob_nsect = (nsectors >> 8) & 0xff;
162                         tf->hob_lbal  = (u8)(block >> 24);
163                         if (sizeof(block) != 4) {
164                                 tf->hob_lbam = (u8)((u64)block >> 32);
165                                 tf->hob_lbah = (u8)((u64)block >> 40);
166                         }
167
168                         tf->nsect  = nsectors & 0xff;
169                         tf->lbal   = (u8) block;
170                         tf->lbam   = (u8)(block >>  8);
171                         tf->lbah   = (u8)(block >> 16);
172
173                         task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
174                 } else {
175                         tf->nsect  = nsectors & 0xff;
176                         tf->lbal   = block;
177                         tf->lbam   = block >>= 8;
178                         tf->lbah   = block >>= 8;
179                         tf->device = (block >> 8) & 0xf;
180                 }
181
182                 tf->device |= ATA_LBA;
183         } else {
184                 unsigned int sect, head, cyl, track;
185
186                 track = (int)block / drive->sect;
187                 sect  = (int)block % drive->sect + 1;
188                 head  = track % drive->head;
189                 cyl   = track / drive->head;
190
191                 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
192
193                 tf->nsect  = nsectors & 0xff;
194                 tf->lbal   = sect;
195                 tf->lbam   = cyl;
196                 tf->lbah   = cyl >> 8;
197                 tf->device = head;
198         }
199
200         if (rq_data_dir(rq))
201                 task.tf_flags |= IDE_TFLAG_WRITE;
202
203         ide_tf_set_cmd(drive, &task, dma);
204         if (!dma)
205                 hwif->data_phase = task.data_phase;
206         task.rq = rq;
207
208         rc = do_rw_taskfile(drive, &task);
209
210         if (rc == ide_stopped && dma) {
211                 /* fallback to PIO */
212                 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
213                 ide_tf_set_cmd(drive, &task, 0);
214                 hwif->data_phase = task.data_phase;
215                 ide_init_sg_cmd(drive, rq);
216                 rc = do_rw_taskfile(drive, &task);
217         }
218
219         return rc;
220 }
221
222 /*
223  * 268435455  == 137439 MB or 28bit limit
224  * 320173056  == 163929 MB or 48bit addressing
225  * 1073741822 == 549756 MB or 48bit addressing fake drive
226  */
227
228 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
229                                       sector_t block)
230 {
231         ide_hwif_t *hwif = HWIF(drive);
232
233         BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
234
235         if (!blk_fs_request(rq)) {
236                 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
237                 ide_end_request(drive, 0, 0);
238                 return ide_stopped;
239         }
240
241         ledtrig_ide_activity();
242
243         pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
244                  drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
245                  (unsigned long long)block, rq->nr_sectors,
246                  (unsigned long)rq->buffer);
247
248         if (hwif->rw_disk)
249                 hwif->rw_disk(drive, rq);
250
251         return __ide_do_rw_disk(drive, rq, block);
252 }
253
254 /*
255  * Queries for true maximum capacity of the drive.
256  * Returns maximum LBA address (> 0) of the drive, 0 if failed.
257  */
258 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
259 {
260         ide_task_t args;
261         struct ide_taskfile *tf = &args.tf;
262         u64 addr = 0;
263
264         /* Create IDE/ATA command request structure */
265         memset(&args, 0, sizeof(ide_task_t));
266         if (lba48)
267                 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
268         else
269                 tf->command = ATA_CMD_READ_NATIVE_MAX;
270         tf->device  = ATA_LBA;
271         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
272         if (lba48)
273                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
274         /* submit command request */
275         ide_no_data_taskfile(drive, &args);
276
277         /* if OK, compute maximum address value */
278         if ((tf->status & 0x01) == 0)
279                 addr = ide_get_lba_addr(tf, lba48) + 1;
280
281         return addr;
282 }
283
284 /*
285  * Sets maximum virtual LBA address of the drive.
286  * Returns new maximum virtual LBA address (> 0) or 0 on failure.
287  */
288 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
289 {
290         ide_task_t args;
291         struct ide_taskfile *tf = &args.tf;
292         u64 addr_set = 0;
293
294         addr_req--;
295         /* Create IDE/ATA command request structure */
296         memset(&args, 0, sizeof(ide_task_t));
297         tf->lbal     = (addr_req >>  0) & 0xff;
298         tf->lbam     = (addr_req >>= 8) & 0xff;
299         tf->lbah     = (addr_req >>= 8) & 0xff;
300         if (lba48) {
301                 tf->hob_lbal = (addr_req >>= 8) & 0xff;
302                 tf->hob_lbam = (addr_req >>= 8) & 0xff;
303                 tf->hob_lbah = (addr_req >>= 8) & 0xff;
304                 tf->command  = ATA_CMD_SET_MAX_EXT;
305         } else {
306                 tf->device   = (addr_req >>= 8) & 0x0f;
307                 tf->command  = ATA_CMD_SET_MAX;
308         }
309         tf->device |= ATA_LBA;
310         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
311         if (lba48)
312                 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
313         /* submit command request */
314         ide_no_data_taskfile(drive, &args);
315         /* if OK, compute maximum address value */
316         if ((tf->status & 0x01) == 0)
317                 addr_set = ide_get_lba_addr(tf, lba48) + 1;
318
319         return addr_set;
320 }
321
322 static unsigned long long sectors_to_MB(unsigned long long n)
323 {
324         n <<= 9;                /* make it bytes */
325         do_div(n, 1000000);     /* make it MB */
326         return n;
327 }
328
329 /*
330  * Some disks report total number of sectors instead of
331  * maximum sector address.  We list them here.
332  */
333 static const struct drive_list_entry hpa_list[] = {
334         { "ST340823A",  NULL },
335         { "ST320413A",  NULL },
336         { "ST310211A",  NULL },
337         { NULL,         NULL }
338 };
339
340 static void idedisk_check_hpa(ide_drive_t *drive)
341 {
342         unsigned long long capacity, set_max;
343         int lba48 = ata_id_lba48_enabled(drive->id);
344
345         capacity = drive->capacity64;
346
347         set_max = idedisk_read_native_max_address(drive, lba48);
348
349         if (ide_in_drive_list(drive->id, hpa_list)) {
350                 /*
351                  * Since we are inclusive wrt to firmware revisions do this
352                  * extra check and apply the workaround only when needed.
353                  */
354                 if (set_max == capacity + 1)
355                         set_max--;
356         }
357
358         if (set_max <= capacity)
359                 return;
360
361         printk(KERN_INFO "%s: Host Protected Area detected.\n"
362                          "\tcurrent capacity is %llu sectors (%llu MB)\n"
363                          "\tnative  capacity is %llu sectors (%llu MB)\n",
364                          drive->name,
365                          capacity, sectors_to_MB(capacity),
366                          set_max, sectors_to_MB(set_max));
367
368         set_max = idedisk_set_max_address(drive, set_max, lba48);
369
370         if (set_max) {
371                 drive->capacity64 = set_max;
372                 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
373                                  drive->name);
374         }
375 }
376
377 static void init_idedisk_capacity(ide_drive_t *drive)
378 {
379         u16 *id = drive->id;
380         int lba;
381
382         if (ata_id_lba48_enabled(id)) {
383                 /* drive speaks 48-bit LBA */
384                 lba = 1;
385                 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
386         } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
387                 /* drive speaks 28-bit LBA */
388                 lba = 1;
389                 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
390         } else {
391                 /* drive speaks boring old 28-bit CHS */
392                 lba = 0;
393                 drive->capacity64 = drive->cyl * drive->head * drive->sect;
394         }
395
396         if (lba) {
397                 drive->dev_flags |= IDE_DFLAG_LBA;
398
399                 /*
400                 * If this device supports the Host Protected Area feature set,
401                 * then we may need to change our opinion about its capacity.
402                 */
403                 if (ata_id_hpa_enabled(id))
404                         idedisk_check_hpa(drive);
405         }
406 }
407
408 sector_t ide_disk_capacity(ide_drive_t *drive)
409 {
410         return drive->capacity64;
411 }
412
413 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
414 {
415         ide_drive_t *drive = q->queuedata;
416         ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
417
418         /* FIXME: map struct ide_taskfile on rq->cmd[] */
419         BUG_ON(task == NULL);
420
421         memset(task, 0, sizeof(*task));
422         if (ata_id_flush_ext_enabled(drive->id) &&
423             (drive->capacity64 >= (1UL << 28)))
424                 task->tf.command = ATA_CMD_FLUSH_EXT;
425         else
426                 task->tf.command = ATA_CMD_FLUSH;
427         task->tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
428                            IDE_TFLAG_DYN;
429         task->data_phase = TASKFILE_NO_DATA;
430
431         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
432         rq->cmd_flags |= REQ_SOFTBARRIER;
433         rq->special = task;
434 }
435
436 ide_devset_get(multcount, mult_count);
437
438 /*
439  * This is tightly woven into the driver->do_special can not touch.
440  * DON'T do it again until a total personality rewrite is committed.
441  */
442 static int set_multcount(ide_drive_t *drive, int arg)
443 {
444         struct request *rq;
445         int error;
446
447         if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
448                 return -EINVAL;
449
450         if (drive->special.b.set_multmode)
451                 return -EBUSY;
452
453         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
454         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
455
456         drive->mult_req = arg;
457         drive->special.b.set_multmode = 1;
458         error = blk_execute_rq(drive->queue, NULL, rq, 0);
459         blk_put_request(rq);
460
461         return (drive->mult_count == arg) ? 0 : -EIO;
462 }
463
464 ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
465
466 static int set_nowerr(ide_drive_t *drive, int arg)
467 {
468         if (arg < 0 || arg > 1)
469                 return -EINVAL;
470
471         if (arg)
472                 drive->dev_flags |= IDE_DFLAG_NOWERR;
473         else
474                 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
475
476         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
477
478         return 0;
479 }
480
481 static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
482 {
483         ide_task_t task;
484
485         memset(&task, 0, sizeof(task));
486         task.tf.feature = feature;
487         task.tf.nsect   = nsect;
488         task.tf.command = ATA_CMD_SET_FEATURES;
489         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
490
491         return ide_no_data_taskfile(drive, &task);
492 }
493
494 static void update_ordered(ide_drive_t *drive)
495 {
496         u16 *id = drive->id;
497         unsigned ordered = QUEUE_ORDERED_NONE;
498         prepare_flush_fn *prep_fn = NULL;
499
500         if (drive->dev_flags & IDE_DFLAG_WCACHE) {
501                 unsigned long long capacity;
502                 int barrier;
503                 /*
504                  * We must avoid issuing commands a drive does not
505                  * understand or we may crash it. We check flush cache
506                  * is supported. We also check we have the LBA48 flush
507                  * cache if the drive capacity is too large. By this
508                  * time we have trimmed the drive capacity if LBA48 is
509                  * not available so we don't need to recheck that.
510                  */
511                 capacity = ide_disk_capacity(drive);
512                 barrier = ata_id_flush_enabled(id) &&
513                         (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
514                         ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
515                          capacity <= (1ULL << 28) ||
516                          ata_id_flush_ext_enabled(id));
517
518                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
519                        drive->name, barrier ? "" : "not ");
520
521                 if (barrier) {
522                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
523                         prep_fn = idedisk_prepare_flush;
524                 }
525         } else
526                 ordered = QUEUE_ORDERED_DRAIN;
527
528         blk_queue_ordered(drive->queue, ordered, prep_fn);
529 }
530
531 ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
532
533 static int set_wcache(ide_drive_t *drive, int arg)
534 {
535         int err = 1;
536
537         if (arg < 0 || arg > 1)
538                 return -EINVAL;
539
540         if (ata_id_flush_enabled(drive->id)) {
541                 err = ide_do_setfeature(drive,
542                         arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
543                 if (err == 0) {
544                         if (arg)
545                                 drive->dev_flags |= IDE_DFLAG_WCACHE;
546                         else
547                                 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
548                 }
549         }
550
551         update_ordered(drive);
552
553         return err;
554 }
555
556 static int do_idedisk_flushcache(ide_drive_t *drive)
557 {
558         ide_task_t args;
559
560         memset(&args, 0, sizeof(ide_task_t));
561         if (ata_id_flush_ext_enabled(drive->id))
562                 args.tf.command = ATA_CMD_FLUSH_EXT;
563         else
564                 args.tf.command = ATA_CMD_FLUSH;
565         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
566         return ide_no_data_taskfile(drive, &args);
567 }
568
569 ide_devset_get(acoustic, acoustic);
570
571 static int set_acoustic(ide_drive_t *drive, int arg)
572 {
573         if (arg < 0 || arg > 254)
574                 return -EINVAL;
575
576         ide_do_setfeature(drive,
577                 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
578
579         drive->acoustic = arg;
580
581         return 0;
582 }
583
584 ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
585
586 /*
587  * drive->addressing:
588  *      0: 28-bit
589  *      1: 48-bit
590  *      2: 48-bit capable doing 28-bit
591  */
592 static int set_addressing(ide_drive_t *drive, int arg)
593 {
594         if (arg < 0 || arg > 2)
595                 return -EINVAL;
596
597         if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
598             ata_id_lba48_enabled(drive->id) == 0))
599                 return -EIO;
600
601         if (arg == 2)
602                 arg = 0;
603
604         if (arg)
605                 drive->dev_flags |= IDE_DFLAG_LBA48;
606         else
607                 drive->dev_flags &= ~IDE_DFLAG_LBA48;
608
609         return 0;
610 }
611
612 ide_ext_devset_rw(acoustic, acoustic);
613 ide_ext_devset_rw(address, addressing);
614 ide_ext_devset_rw(multcount, multcount);
615 ide_ext_devset_rw(wcache, wcache);
616
617 ide_ext_devset_rw_sync(nowerr, nowerr);
618
619 static void idedisk_setup(ide_drive_t *drive)
620 {
621         struct ide_disk_obj *idkp = drive->driver_data;
622         ide_hwif_t *hwif = drive->hwif;
623         u16 *id = drive->id;
624         char *m = (char *)&id[ATA_ID_PROD];
625         unsigned long long capacity;
626
627         ide_proc_register_driver(drive, idkp->driver);
628
629         if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
630                 return;
631
632         if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
633                 /*
634                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
635                  */
636                 if (m[0] != 'W' || m[1] != 'D')
637                         drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
638         }
639
640         (void)set_addressing(drive, 1);
641
642         if (drive->dev_flags & IDE_DFLAG_LBA48) {
643                 int max_s = 2048;
644
645                 if (max_s > hwif->rqsize)
646                         max_s = hwif->rqsize;
647
648                 blk_queue_max_sectors(drive->queue, max_s);
649         }
650
651         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
652                          drive->queue->max_sectors / 2);
653
654         /* calculate drive capacity, and select LBA if possible */
655         init_idedisk_capacity(drive);
656
657         /* limit drive capacity to 137GB if LBA48 cannot be used */
658         if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
659             drive->capacity64 > 1ULL << 28) {
660                 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
661                        "%llu sectors (%llu MB)\n",
662                        drive->name, (unsigned long long)drive->capacity64,
663                        sectors_to_MB(drive->capacity64));
664                 drive->capacity64 = 1ULL << 28;
665         }
666
667         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
668             (drive->dev_flags & IDE_DFLAG_LBA48)) {
669                 if (drive->capacity64 > 1ULL << 28) {
670                         printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
671                                          " will be used for accessing sectors "
672                                          "> %u\n", drive->name, 1 << 28);
673                 } else
674                         drive->dev_flags &= ~IDE_DFLAG_LBA48;
675         }
676
677         /*
678          * if possible, give fdisk access to more of the drive,
679          * by correcting bios_cyls:
680          */
681         capacity = ide_disk_capacity(drive);
682
683         if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
684                 if (ata_id_lba48_enabled(drive->id)) {
685                         /* compatibility */
686                         drive->bios_sect = 63;
687                         drive->bios_head = 255;
688                 }
689
690                 if (drive->bios_sect && drive->bios_head) {
691                         unsigned int cap0 = capacity; /* truncate to 32 bits */
692                         unsigned int cylsz, cyl;
693
694                         if (cap0 != capacity)
695                                 drive->bios_cyl = 65535;
696                         else {
697                                 cylsz = drive->bios_sect * drive->bios_head;
698                                 cyl = cap0 / cylsz;
699                                 if (cyl > 65535)
700                                         cyl = 65535;
701                                 if (cyl > drive->bios_cyl)
702                                         drive->bios_cyl = cyl;
703                         }
704                 }
705         }
706         printk(KERN_INFO "%s: %llu sectors (%llu MB)",
707                          drive->name, capacity, sectors_to_MB(capacity));
708
709         /* Only print cache size when it was specified */
710         if (id[ATA_ID_BUF_SIZE])
711                 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
712
713         printk(KERN_CONT ", CHS=%d/%d/%d\n",
714                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
715
716         /* write cache enabled? */
717         if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
718                 drive->dev_flags |= IDE_DFLAG_WCACHE;
719
720         set_wcache(drive, 1);
721 }
722
723 static void ide_cacheflush_p(ide_drive_t *drive)
724 {
725         if (ata_id_flush_enabled(drive->id) == 0 ||
726             (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
727                 return;
728
729         if (do_idedisk_flushcache(drive))
730                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
731 }
732
733 static void ide_disk_remove(ide_drive_t *drive)
734 {
735         struct ide_disk_obj *idkp = drive->driver_data;
736         struct gendisk *g = idkp->disk;
737
738         ide_proc_unregister_driver(drive, idkp->driver);
739
740         del_gendisk(g);
741
742         ide_cacheflush_p(drive);
743
744         ide_disk_put(idkp);
745 }
746
747 static void ide_disk_release(struct kref *kref)
748 {
749         struct ide_disk_obj *idkp = to_ide_disk(kref);
750         ide_drive_t *drive = idkp->drive;
751         struct gendisk *g = idkp->disk;
752
753         drive->driver_data = NULL;
754         g->private_data = NULL;
755         put_disk(g);
756         kfree(idkp);
757 }
758
759 static int ide_disk_probe(ide_drive_t *drive);
760
761 /*
762  * On HPA drives the capacity needs to be
763  * reinitilized on resume otherwise the disk
764  * can not be used and a hard reset is required
765  */
766 static void ide_disk_resume(ide_drive_t *drive)
767 {
768         if (ata_id_hpa_enabled(drive->id))
769                 init_idedisk_capacity(drive);
770 }
771
772 static void ide_device_shutdown(ide_drive_t *drive)
773 {
774 #ifdef  CONFIG_ALPHA
775         /* On Alpha, halt(8) doesn't actually turn the machine off,
776            it puts you into the sort of firmware monitor. Typically,
777            it's used to boot another kernel image, so it's not much
778            different from reboot(8). Therefore, we don't need to
779            spin down the disk in this case, especially since Alpha
780            firmware doesn't handle disks in standby mode properly.
781            On the other hand, it's reasonably safe to turn the power
782            off when the shutdown process reaches the firmware prompt,
783            as the firmware initialization takes rather long time -
784            at least 10 seconds, which should be sufficient for
785            the disk to expire its write cache. */
786         if (system_state != SYSTEM_POWER_OFF) {
787 #else
788         if (system_state == SYSTEM_RESTART) {
789 #endif
790                 ide_cacheflush_p(drive);
791                 return;
792         }
793
794         printk(KERN_INFO "Shutdown: %s\n", drive->name);
795
796         drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
797 }
798
799 static ide_driver_t idedisk_driver = {
800         .gen_driver = {
801                 .owner          = THIS_MODULE,
802                 .name           = "ide-disk",
803                 .bus            = &ide_bus_type,
804         },
805         .probe                  = ide_disk_probe,
806         .remove                 = ide_disk_remove,
807         .resume                 = ide_disk_resume,
808         .shutdown               = ide_device_shutdown,
809         .version                = IDEDISK_VERSION,
810         .do_request             = ide_do_rw_disk,
811         .end_request            = ide_end_request,
812         .error                  = __ide_error,
813 #ifdef CONFIG_IDE_PROC_FS
814         .proc                   = ide_disk_proc,
815         .settings               = ide_disk_settings,
816 #endif
817 };
818
819 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
820 {
821         ide_task_t task;
822
823         memset(&task, 0, sizeof(task));
824         task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
825         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
826
827         return ide_no_data_taskfile(drive, &task);
828 }
829
830 static int idedisk_open(struct inode *inode, struct file *filp)
831 {
832         struct gendisk *disk = inode->i_bdev->bd_disk;
833         struct ide_disk_obj *idkp;
834         ide_drive_t *drive;
835
836         idkp = ide_disk_get(disk);
837         if (idkp == NULL)
838                 return -ENXIO;
839
840         drive = idkp->drive;
841
842         idkp->openers++;
843
844         if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
845                 check_disk_change(inode->i_bdev);
846                 /*
847                  * Ignore the return code from door_lock,
848                  * since the open() has already succeeded,
849                  * and the door_lock is irrelevant at this point.
850                  */
851                 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
852                     idedisk_set_doorlock(drive, 1))
853                         drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
854         }
855         return 0;
856 }
857
858 static int idedisk_release(struct inode *inode, struct file *filp)
859 {
860         struct gendisk *disk = inode->i_bdev->bd_disk;
861         struct ide_disk_obj *idkp = ide_disk_g(disk);
862         ide_drive_t *drive = idkp->drive;
863
864         if (idkp->openers == 1)
865                 ide_cacheflush_p(drive);
866
867         if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
868                 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
869                     idedisk_set_doorlock(drive, 0))
870                         drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
871         }
872
873         idkp->openers--;
874
875         ide_disk_put(idkp);
876
877         return 0;
878 }
879
880 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
881 {
882         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
883         ide_drive_t *drive = idkp->drive;
884
885         geo->heads = drive->bios_head;
886         geo->sectors = drive->bios_sect;
887         geo->cylinders = (u16)drive->bios_cyl; /* truncate */
888         return 0;
889 }
890
891 static int idedisk_media_changed(struct gendisk *disk)
892 {
893         struct ide_disk_obj *idkp = ide_disk_g(disk);
894         ide_drive_t *drive = idkp->drive;
895
896         /* do not scan partitions twice if this is a removable device */
897         if (drive->dev_flags & IDE_DFLAG_ATTACH) {
898                 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
899                 return 0;
900         }
901
902         /* if removable, always assume it was changed */
903         return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
904 }
905
906 static int idedisk_revalidate_disk(struct gendisk *disk)
907 {
908         struct ide_disk_obj *idkp = ide_disk_g(disk);
909         set_capacity(disk, ide_disk_capacity(idkp->drive));
910         return 0;
911 }
912
913 static struct block_device_operations idedisk_ops = {
914         .owner                  = THIS_MODULE,
915         .open                   = idedisk_open,
916         .release                = idedisk_release,
917         .ioctl                  = ide_disk_ioctl,
918         .getgeo                 = idedisk_getgeo,
919         .media_changed          = idedisk_media_changed,
920         .revalidate_disk        = idedisk_revalidate_disk
921 };
922
923 MODULE_DESCRIPTION("ATA DISK Driver");
924
925 static int ide_disk_probe(ide_drive_t *drive)
926 {
927         struct ide_disk_obj *idkp;
928         struct gendisk *g;
929
930         /* strstr("foo", "") is non-NULL */
931         if (!strstr("ide-disk", drive->driver_req))
932                 goto failed;
933
934         if (drive->media != ide_disk)
935                 goto failed;
936
937         idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
938         if (!idkp)
939                 goto failed;
940
941         g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
942         if (!g)
943                 goto out_free_idkp;
944
945         ide_init_disk(g, drive);
946
947         kref_init(&idkp->kref);
948
949         idkp->drive = drive;
950         idkp->driver = &idedisk_driver;
951         idkp->disk = g;
952
953         g->private_data = &idkp->driver;
954
955         drive->driver_data = idkp;
956
957         idedisk_setup(drive);
958         if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
959             (drive->head == 0 || drive->head > 16)) {
960                 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
961                         drive->name, drive->head);
962                 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
963         } else
964                 drive->dev_flags |= IDE_DFLAG_ATTACH;
965
966         g->minors = IDE_DISK_MINORS;
967         g->driverfs_dev = &drive->gendev;
968         g->flags |= GENHD_FL_EXT_DEVT;
969         if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
970                 g->flags = GENHD_FL_REMOVABLE;
971         set_capacity(g, ide_disk_capacity(drive));
972         g->fops = &idedisk_ops;
973         add_disk(g);
974         return 0;
975
976 out_free_idkp:
977         kfree(idkp);
978 failed:
979         return -ENODEV;
980 }
981
982 static void __exit idedisk_exit(void)
983 {
984         driver_unregister(&idedisk_driver.gen_driver);
985 }
986
987 static int __init idedisk_init(void)
988 {
989         return driver_register(&idedisk_driver.gen_driver);
990 }
991
992 MODULE_ALIAS("ide:*m-disk*");
993 MODULE_ALIAS("ide-disk");
994 module_init(idedisk_init);
995 module_exit(idedisk_exit);
996 MODULE_LICENSE("GPL");