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
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>
14 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
17 #define IDEDISK_VERSION "1.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>
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>
36 #include <asm/byteorder.h>
38 #include <asm/uaccess.h>
40 #include <asm/div64.h>
42 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
43 #define IDE_DISK_MINORS (1 << PARTN_BITS)
45 #define IDE_DISK_MINORS 0
50 static DEFINE_MUTEX(idedisk_ref_mutex);
52 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
54 static void ide_disk_release(struct kref *);
56 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
58 struct ide_disk_obj *idkp = NULL;
60 mutex_lock(&idedisk_ref_mutex);
61 idkp = ide_disk_g(disk);
63 if (ide_device_get(idkp->drive))
66 kref_get(&idkp->kref);
68 mutex_unlock(&idedisk_ref_mutex);
72 static void ide_disk_put(struct ide_disk_obj *idkp)
74 ide_drive_t *drive = idkp->drive;
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);
82 static const u8 ide_rw_cmds[] = {
85 ATA_CMD_READ_MULTI_EXT,
86 ATA_CMD_WRITE_MULTI_EXT,
90 ATA_CMD_PIO_WRITE_EXT,
97 static const u8 ide_data_phases[] = {
106 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
108 u8 index, lba48, write;
110 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
111 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
116 index = drive->mult_count ? 0 : 4;
118 task->tf.command = ide_rw_cmds[index + lba48 + write];
121 index = 8; /* fixup index */
123 task->data_phase = ide_data_phases[index / 2 + write];
127 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
128 * using LBA if supported, or CHS otherwise, to address sectors.
130 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
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);
138 struct ide_taskfile *tf = &task.tf;
141 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
142 if (block + rq->nr_sectors > 1ULL << 28)
149 ide_init_sg_cmd(drive, rq);
150 ide_map_sg(drive, rq);
153 memset(&task, 0, sizeof(task));
154 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
156 if (drive->dev_flags & IDE_DFLAG_LBA) {
158 pr_debug("%s: LBA=0x%012llx\n", drive->name,
159 (unsigned long long)block);
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);
168 tf->nsect = nsectors & 0xff;
169 tf->lbal = (u8) block;
170 tf->lbam = (u8)(block >> 8);
171 tf->lbah = (u8)(block >> 16);
173 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
175 tf->nsect = nsectors & 0xff;
177 tf->lbam = block >>= 8;
178 tf->lbah = block >>= 8;
179 tf->device = (block >> 8) & 0xf;
182 tf->device |= ATA_LBA;
184 unsigned int sect, head, cyl, track;
186 track = (int)block / drive->sect;
187 sect = (int)block % drive->sect + 1;
188 head = track % drive->head;
189 cyl = track / drive->head;
191 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
193 tf->nsect = nsectors & 0xff;
201 task.tf_flags |= IDE_TFLAG_WRITE;
203 ide_tf_set_cmd(drive, &task, dma);
205 hwif->data_phase = task.data_phase;
208 rc = do_rw_taskfile(drive, &task);
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);
223 * 268435455 == 137439 MB or 28bit limit
224 * 320173056 == 163929 MB or 48bit addressing
225 * 1073741822 == 549756 MB or 48bit addressing fake drive
228 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
231 ide_hwif_t *hwif = HWIF(drive);
233 BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
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);
241 ledtrig_ide_activity();
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);
249 hwif->rw_disk(drive, rq);
251 return __ide_do_rw_disk(drive, rq, block);
255 * Queries for true maximum capacity of the drive.
256 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
258 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
261 struct ide_taskfile *tf = &args.tf;
264 /* Create IDE/ATA command request structure */
265 memset(&args, 0, sizeof(ide_task_t));
267 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
269 tf->command = ATA_CMD_READ_NATIVE_MAX;
270 tf->device = ATA_LBA;
271 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
273 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
274 /* submit command request */
275 ide_no_data_taskfile(drive, &args);
277 /* if OK, compute maximum address value */
278 if ((tf->status & 0x01) == 0)
279 addr = ide_get_lba_addr(tf, lba48) + 1;
285 * Sets maximum virtual LBA address of the drive.
286 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
288 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
291 struct ide_taskfile *tf = &args.tf;
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;
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;
306 tf->device = (addr_req >>= 8) & 0x0f;
307 tf->command = ATA_CMD_SET_MAX;
309 tf->device |= ATA_LBA;
310 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
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;
322 static unsigned long long sectors_to_MB(unsigned long long n)
324 n <<= 9; /* make it bytes */
325 do_div(n, 1000000); /* make it MB */
330 * Some disks report total number of sectors instead of
331 * maximum sector address. We list them here.
333 static const struct drive_list_entry hpa_list[] = {
334 { "ST340823A", NULL },
335 { "ST320413A", NULL },
336 { "ST310211A", NULL },
340 static void idedisk_check_hpa(ide_drive_t *drive)
342 unsigned long long capacity, set_max;
343 int lba48 = ata_id_lba48_enabled(drive->id);
345 capacity = drive->capacity64;
347 set_max = idedisk_read_native_max_address(drive, lba48);
349 if (ide_in_drive_list(drive->id, hpa_list)) {
351 * Since we are inclusive wrt to firmware revisions do this
352 * extra check and apply the workaround only when needed.
354 if (set_max == capacity + 1)
358 if (set_max <= capacity)
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",
365 capacity, sectors_to_MB(capacity),
366 set_max, sectors_to_MB(set_max));
368 set_max = idedisk_set_max_address(drive, set_max, lba48);
371 drive->capacity64 = set_max;
372 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
377 static void init_idedisk_capacity(ide_drive_t *drive)
382 if (ata_id_lba48_enabled(id)) {
383 /* drive speaks 48-bit LBA */
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 */
389 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
391 /* drive speaks boring old 28-bit CHS */
393 drive->capacity64 = drive->cyl * drive->head * drive->sect;
397 drive->dev_flags |= IDE_DFLAG_LBA;
400 * If this device supports the Host Protected Area feature set,
401 * then we may need to change our opinion about its capacity.
403 if (ata_id_hpa_enabled(id))
404 idedisk_check_hpa(drive);
407 /* limit drive capacity to 137GB if LBA48 cannot be used */
408 if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
409 drive->capacity64 > 1ULL << 28) {
410 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
411 "%llu sectors (%llu MB)\n",
412 drive->name, (unsigned long long)drive->capacity64,
413 sectors_to_MB(drive->capacity64));
414 drive->capacity64 = 1ULL << 28;
417 if ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
418 (drive->dev_flags & IDE_DFLAG_LBA48)) {
419 if (drive->capacity64 > 1ULL << 28) {
420 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
421 " will be used for accessing sectors "
422 "> %u\n", drive->name, 1 << 28);
424 drive->dev_flags &= ~IDE_DFLAG_LBA48;
428 sector_t ide_disk_capacity(ide_drive_t *drive)
430 return drive->capacity64;
433 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
435 ide_drive_t *drive = q->queuedata;
436 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
438 /* FIXME: map struct ide_taskfile on rq->cmd[] */
439 BUG_ON(task == NULL);
441 memset(task, 0, sizeof(*task));
442 if (ata_id_flush_ext_enabled(drive->id) &&
443 (drive->capacity64 >= (1UL << 28)))
444 task->tf.command = ATA_CMD_FLUSH_EXT;
446 task->tf.command = ATA_CMD_FLUSH;
447 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
449 task->data_phase = TASKFILE_NO_DATA;
451 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
452 rq->cmd_flags |= REQ_SOFTBARRIER;
456 ide_devset_get(multcount, mult_count);
459 * This is tightly woven into the driver->do_special can not touch.
460 * DON'T do it again until a total personality rewrite is committed.
462 static int set_multcount(ide_drive_t *drive, int arg)
467 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
470 if (drive->special.b.set_multmode)
473 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
474 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
476 drive->mult_req = arg;
477 drive->special.b.set_multmode = 1;
478 error = blk_execute_rq(drive->queue, NULL, rq, 0);
481 return (drive->mult_count == arg) ? 0 : -EIO;
484 ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
486 static int set_nowerr(ide_drive_t *drive, int arg)
488 if (arg < 0 || arg > 1)
492 drive->dev_flags |= IDE_DFLAG_NOWERR;
494 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
496 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
501 static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
505 memset(&task, 0, sizeof(task));
506 task.tf.feature = feature;
507 task.tf.nsect = nsect;
508 task.tf.command = ATA_CMD_SET_FEATURES;
509 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
511 return ide_no_data_taskfile(drive, &task);
514 static void update_ordered(ide_drive_t *drive)
517 unsigned ordered = QUEUE_ORDERED_NONE;
518 prepare_flush_fn *prep_fn = NULL;
520 if (drive->dev_flags & IDE_DFLAG_WCACHE) {
521 unsigned long long capacity;
524 * We must avoid issuing commands a drive does not
525 * understand or we may crash it. We check flush cache
526 * is supported. We also check we have the LBA48 flush
527 * cache if the drive capacity is too large. By this
528 * time we have trimmed the drive capacity if LBA48 is
529 * not available so we don't need to recheck that.
531 capacity = ide_disk_capacity(drive);
532 barrier = ata_id_flush_enabled(id) &&
533 (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
534 ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
535 capacity <= (1ULL << 28) ||
536 ata_id_flush_ext_enabled(id));
538 printk(KERN_INFO "%s: cache flushes %ssupported\n",
539 drive->name, barrier ? "" : "not ");
542 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
543 prep_fn = idedisk_prepare_flush;
546 ordered = QUEUE_ORDERED_DRAIN;
548 blk_queue_ordered(drive->queue, ordered, prep_fn);
551 ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
553 static int set_wcache(ide_drive_t *drive, int arg)
557 if (arg < 0 || arg > 1)
560 if (ata_id_flush_enabled(drive->id)) {
561 err = ide_do_setfeature(drive,
562 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
565 drive->dev_flags |= IDE_DFLAG_WCACHE;
567 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
571 update_ordered(drive);
576 static int do_idedisk_flushcache(ide_drive_t *drive)
580 memset(&args, 0, sizeof(ide_task_t));
581 if (ata_id_flush_ext_enabled(drive->id))
582 args.tf.command = ATA_CMD_FLUSH_EXT;
584 args.tf.command = ATA_CMD_FLUSH;
585 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
586 return ide_no_data_taskfile(drive, &args);
589 ide_devset_get(acoustic, acoustic);
591 static int set_acoustic(ide_drive_t *drive, int arg)
593 if (arg < 0 || arg > 254)
596 ide_do_setfeature(drive,
597 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
599 drive->acoustic = arg;
604 ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
610 * 2: 48-bit capable doing 28-bit
612 static int set_addressing(ide_drive_t *drive, int arg)
614 if (arg < 0 || arg > 2)
617 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
618 ata_id_lba48_enabled(drive->id) == 0))
625 drive->dev_flags |= IDE_DFLAG_LBA48;
627 drive->dev_flags &= ~IDE_DFLAG_LBA48;
632 ide_ext_devset_rw(acoustic, acoustic);
633 ide_ext_devset_rw(address, addressing);
634 ide_ext_devset_rw(multcount, multcount);
635 ide_ext_devset_rw(wcache, wcache);
637 ide_ext_devset_rw_sync(nowerr, nowerr);
639 static void idedisk_setup(ide_drive_t *drive)
641 struct ide_disk_obj *idkp = drive->driver_data;
642 ide_hwif_t *hwif = drive->hwif;
644 char *m = (char *)&id[ATA_ID_PROD];
645 unsigned long long capacity;
647 ide_proc_register_driver(drive, idkp->driver);
649 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
652 if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
654 * Removable disks (eg. SYQUEST); ignore 'WD' drives
656 if (m[0] != 'W' || m[1] != 'D')
657 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
660 (void)set_addressing(drive, 1);
662 if (drive->dev_flags & IDE_DFLAG_LBA48) {
665 if (max_s > hwif->rqsize)
666 max_s = hwif->rqsize;
668 blk_queue_max_sectors(drive->queue, max_s);
671 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
672 drive->queue->max_sectors / 2);
674 /* calculate drive capacity, and select LBA if possible */
675 init_idedisk_capacity(drive);
678 * if possible, give fdisk access to more of the drive,
679 * by correcting bios_cyls:
681 capacity = ide_disk_capacity(drive);
683 if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
684 if (ata_id_lba48_enabled(drive->id)) {
686 drive->bios_sect = 63;
687 drive->bios_head = 255;
690 if (drive->bios_sect && drive->bios_head) {
691 unsigned int cap0 = capacity; /* truncate to 32 bits */
692 unsigned int cylsz, cyl;
694 if (cap0 != capacity)
695 drive->bios_cyl = 65535;
697 cylsz = drive->bios_sect * drive->bios_head;
701 if (cyl > drive->bios_cyl)
702 drive->bios_cyl = cyl;
706 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
707 drive->name, capacity, sectors_to_MB(capacity));
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);
713 printk(KERN_CONT ", CHS=%d/%d/%d\n",
714 drive->bios_cyl, drive->bios_head, drive->bios_sect);
716 /* write cache enabled? */
717 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
718 drive->dev_flags |= IDE_DFLAG_WCACHE;
720 set_wcache(drive, 1);
723 static void ide_cacheflush_p(ide_drive_t *drive)
725 if (ata_id_flush_enabled(drive->id) == 0 ||
726 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
729 if (do_idedisk_flushcache(drive))
730 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
733 static void ide_disk_remove(ide_drive_t *drive)
735 struct ide_disk_obj *idkp = drive->driver_data;
736 struct gendisk *g = idkp->disk;
738 ide_proc_unregister_driver(drive, idkp->driver);
742 ide_cacheflush_p(drive);
747 static void ide_disk_release(struct kref *kref)
749 struct ide_disk_obj *idkp = to_ide_disk(kref);
750 ide_drive_t *drive = idkp->drive;
751 struct gendisk *g = idkp->disk;
753 drive->driver_data = NULL;
754 g->private_data = NULL;
759 static int ide_disk_probe(ide_drive_t *drive);
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
766 static void ide_disk_resume(ide_drive_t *drive)
768 if (ata_id_hpa_enabled(drive->id))
769 init_idedisk_capacity(drive);
772 static void ide_device_shutdown(ide_drive_t *drive)
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) {
788 if (system_state == SYSTEM_RESTART) {
790 ide_cacheflush_p(drive);
794 printk(KERN_INFO "Shutdown: %s\n", drive->name);
796 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
799 static ide_driver_t idedisk_driver = {
801 .owner = THIS_MODULE,
803 .bus = &ide_bus_type,
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,
819 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
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;
827 return ide_no_data_taskfile(drive, &task);
830 static int idedisk_open(struct inode *inode, struct file *filp)
832 struct gendisk *disk = inode->i_bdev->bd_disk;
833 struct ide_disk_obj *idkp;
836 idkp = ide_disk_get(disk);
844 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
846 * Ignore the return code from door_lock,
847 * since the open() has already succeeded,
848 * and the door_lock is irrelevant at this point.
850 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
851 idedisk_set_doorlock(drive, 1))
852 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
853 check_disk_change(inode->i_bdev);
858 static int idedisk_release(struct inode *inode, struct file *filp)
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;
864 if (idkp->openers == 1)
865 ide_cacheflush_p(drive);
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;
880 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
882 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
883 ide_drive_t *drive = idkp->drive;
885 geo->heads = drive->bios_head;
886 geo->sectors = drive->bios_sect;
887 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
891 static int idedisk_media_changed(struct gendisk *disk)
893 struct ide_disk_obj *idkp = ide_disk_g(disk);
894 ide_drive_t *drive = idkp->drive;
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;
902 /* if removable, always assume it was changed */
903 return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
906 static int idedisk_revalidate_disk(struct gendisk *disk)
908 struct ide_disk_obj *idkp = ide_disk_g(disk);
909 set_capacity(disk, ide_disk_capacity(idkp->drive));
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
923 MODULE_DESCRIPTION("ATA DISK Driver");
925 static int ide_disk_probe(ide_drive_t *drive)
927 struct ide_disk_obj *idkp;
930 /* strstr("foo", "") is non-NULL */
931 if (!strstr("ide-disk", drive->driver_req))
934 if (drive->media != ide_disk)
937 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
941 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
945 ide_init_disk(g, drive);
947 kref_init(&idkp->kref);
950 idkp->driver = &idedisk_driver;
953 g->private_data = &idkp->driver;
955 drive->driver_data = idkp;
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;
964 drive->dev_flags |= IDE_DFLAG_ATTACH;
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;
982 static void __exit idedisk_exit(void)
984 driver_unregister(&idedisk_driver.gen_driver);
987 static int __init idedisk_init(void)
989 return driver_register(&idedisk_driver.gen_driver);
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");