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 static void ide_disk_release(struct kref *);
54 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
56 struct ide_disk_obj *idkp = NULL;
58 mutex_lock(&idedisk_ref_mutex);
59 idkp = ide_drv_g(disk, ide_disk_obj);
61 if (ide_device_get(idkp->drive))
64 kref_get(&idkp->kref);
66 mutex_unlock(&idedisk_ref_mutex);
70 static void ide_disk_put(struct ide_disk_obj *idkp)
72 ide_drive_t *drive = idkp->drive;
74 mutex_lock(&idedisk_ref_mutex);
75 kref_put(&idkp->kref, ide_disk_release);
76 ide_device_put(drive);
77 mutex_unlock(&idedisk_ref_mutex);
80 static const u8 ide_rw_cmds[] = {
83 ATA_CMD_READ_MULTI_EXT,
84 ATA_CMD_WRITE_MULTI_EXT,
88 ATA_CMD_PIO_WRITE_EXT,
95 static const u8 ide_data_phases[] = {
104 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
106 u8 index, lba48, write;
108 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
109 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
114 index = drive->mult_count ? 0 : 4;
116 task->tf.command = ide_rw_cmds[index + lba48 + write];
119 index = 8; /* fixup index */
121 task->data_phase = ide_data_phases[index / 2 + write];
125 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
126 * using LBA if supported, or CHS otherwise, to address sectors.
128 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
131 ide_hwif_t *hwif = HWIF(drive);
132 u16 nsectors = (u16)rq->nr_sectors;
133 u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
134 u8 dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
136 struct ide_taskfile *tf = &task.tf;
139 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
140 if (block + rq->nr_sectors > 1ULL << 28)
147 ide_init_sg_cmd(drive, rq);
148 ide_map_sg(drive, rq);
151 memset(&task, 0, sizeof(task));
152 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
154 if (drive->dev_flags & IDE_DFLAG_LBA) {
156 pr_debug("%s: LBA=0x%012llx\n", drive->name,
157 (unsigned long long)block);
159 tf->hob_nsect = (nsectors >> 8) & 0xff;
160 tf->hob_lbal = (u8)(block >> 24);
161 if (sizeof(block) != 4) {
162 tf->hob_lbam = (u8)((u64)block >> 32);
163 tf->hob_lbah = (u8)((u64)block >> 40);
166 tf->nsect = nsectors & 0xff;
167 tf->lbal = (u8) block;
168 tf->lbam = (u8)(block >> 8);
169 tf->lbah = (u8)(block >> 16);
171 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
173 tf->nsect = nsectors & 0xff;
175 tf->lbam = block >>= 8;
176 tf->lbah = block >>= 8;
177 tf->device = (block >> 8) & 0xf;
180 tf->device |= ATA_LBA;
182 unsigned int sect, head, cyl, track;
184 track = (int)block / drive->sect;
185 sect = (int)block % drive->sect + 1;
186 head = track % drive->head;
187 cyl = track / drive->head;
189 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
191 tf->nsect = nsectors & 0xff;
199 task.tf_flags |= IDE_TFLAG_WRITE;
201 ide_tf_set_cmd(drive, &task, dma);
203 hwif->data_phase = task.data_phase;
206 rc = do_rw_taskfile(drive, &task);
208 if (rc == ide_stopped && dma) {
209 /* fallback to PIO */
210 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
211 ide_tf_set_cmd(drive, &task, 0);
212 hwif->data_phase = task.data_phase;
213 ide_init_sg_cmd(drive, rq);
214 rc = do_rw_taskfile(drive, &task);
221 * 268435455 == 137439 MB or 28bit limit
222 * 320173056 == 163929 MB or 48bit addressing
223 * 1073741822 == 549756 MB or 48bit addressing fake drive
226 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
229 ide_hwif_t *hwif = HWIF(drive);
231 BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
233 if (!blk_fs_request(rq)) {
234 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
235 ide_end_request(drive, 0, 0);
239 ledtrig_ide_activity();
241 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
242 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
243 (unsigned long long)block, rq->nr_sectors,
244 (unsigned long)rq->buffer);
247 hwif->rw_disk(drive, rq);
249 return __ide_do_rw_disk(drive, rq, block);
253 * Queries for true maximum capacity of the drive.
254 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
256 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
259 struct ide_taskfile *tf = &args.tf;
262 /* Create IDE/ATA command request structure */
263 memset(&args, 0, sizeof(ide_task_t));
265 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
267 tf->command = ATA_CMD_READ_NATIVE_MAX;
268 tf->device = ATA_LBA;
269 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
271 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
272 /* submit command request */
273 ide_no_data_taskfile(drive, &args);
275 /* if OK, compute maximum address value */
276 if ((tf->status & 0x01) == 0)
277 addr = ide_get_lba_addr(tf, lba48) + 1;
283 * Sets maximum virtual LBA address of the drive.
284 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
286 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
289 struct ide_taskfile *tf = &args.tf;
293 /* Create IDE/ATA command request structure */
294 memset(&args, 0, sizeof(ide_task_t));
295 tf->lbal = (addr_req >> 0) & 0xff;
296 tf->lbam = (addr_req >>= 8) & 0xff;
297 tf->lbah = (addr_req >>= 8) & 0xff;
299 tf->hob_lbal = (addr_req >>= 8) & 0xff;
300 tf->hob_lbam = (addr_req >>= 8) & 0xff;
301 tf->hob_lbah = (addr_req >>= 8) & 0xff;
302 tf->command = ATA_CMD_SET_MAX_EXT;
304 tf->device = (addr_req >>= 8) & 0x0f;
305 tf->command = ATA_CMD_SET_MAX;
307 tf->device |= ATA_LBA;
308 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
310 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
311 /* submit command request */
312 ide_no_data_taskfile(drive, &args);
313 /* if OK, compute maximum address value */
314 if ((tf->status & 0x01) == 0)
315 addr_set = ide_get_lba_addr(tf, lba48) + 1;
320 static unsigned long long sectors_to_MB(unsigned long long n)
322 n <<= 9; /* make it bytes */
323 do_div(n, 1000000); /* make it MB */
328 * Some disks report total number of sectors instead of
329 * maximum sector address. We list them here.
331 static const struct drive_list_entry hpa_list[] = {
332 { "ST340823A", NULL },
333 { "ST320413A", NULL },
334 { "ST310211A", NULL },
338 static void idedisk_check_hpa(ide_drive_t *drive)
340 unsigned long long capacity, set_max;
341 int lba48 = ata_id_lba48_enabled(drive->id);
343 capacity = drive->capacity64;
345 set_max = idedisk_read_native_max_address(drive, lba48);
347 if (ide_in_drive_list(drive->id, hpa_list)) {
349 * Since we are inclusive wrt to firmware revisions do this
350 * extra check and apply the workaround only when needed.
352 if (set_max == capacity + 1)
356 if (set_max <= capacity)
359 printk(KERN_INFO "%s: Host Protected Area detected.\n"
360 "\tcurrent capacity is %llu sectors (%llu MB)\n"
361 "\tnative capacity is %llu sectors (%llu MB)\n",
363 capacity, sectors_to_MB(capacity),
364 set_max, sectors_to_MB(set_max));
366 set_max = idedisk_set_max_address(drive, set_max, lba48);
369 drive->capacity64 = set_max;
370 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
375 static void init_idedisk_capacity(ide_drive_t *drive)
380 if (ata_id_lba48_enabled(id)) {
381 /* drive speaks 48-bit LBA */
383 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
384 } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
385 /* drive speaks 28-bit LBA */
387 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
389 /* drive speaks boring old 28-bit CHS */
391 drive->capacity64 = drive->cyl * drive->head * drive->sect;
395 drive->dev_flags |= IDE_DFLAG_LBA;
398 * If this device supports the Host Protected Area feature set,
399 * then we may need to change our opinion about its capacity.
401 if (ata_id_hpa_enabled(id))
402 idedisk_check_hpa(drive);
405 /* limit drive capacity to 137GB if LBA48 cannot be used */
406 if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
407 drive->capacity64 > 1ULL << 28) {
408 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
409 "%llu sectors (%llu MB)\n",
410 drive->name, (unsigned long long)drive->capacity64,
411 sectors_to_MB(drive->capacity64));
412 drive->capacity64 = 1ULL << 28;
415 if ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
416 (drive->dev_flags & IDE_DFLAG_LBA48)) {
417 if (drive->capacity64 > 1ULL << 28) {
418 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
419 " will be used for accessing sectors "
420 "> %u\n", drive->name, 1 << 28);
422 drive->dev_flags &= ~IDE_DFLAG_LBA48;
426 sector_t ide_disk_capacity(ide_drive_t *drive)
428 return drive->capacity64;
431 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
433 ide_drive_t *drive = q->queuedata;
434 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
436 /* FIXME: map struct ide_taskfile on rq->cmd[] */
437 BUG_ON(task == NULL);
439 memset(task, 0, sizeof(*task));
440 if (ata_id_flush_ext_enabled(drive->id) &&
441 (drive->capacity64 >= (1UL << 28)))
442 task->tf.command = ATA_CMD_FLUSH_EXT;
444 task->tf.command = ATA_CMD_FLUSH;
445 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
447 task->data_phase = TASKFILE_NO_DATA;
449 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
450 rq->cmd_flags |= REQ_SOFTBARRIER;
454 ide_devset_get(multcount, mult_count);
457 * This is tightly woven into the driver->do_special can not touch.
458 * DON'T do it again until a total personality rewrite is committed.
460 static int set_multcount(ide_drive_t *drive, int arg)
465 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
468 if (drive->special.b.set_multmode)
471 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
472 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
474 drive->mult_req = arg;
475 drive->special.b.set_multmode = 1;
476 error = blk_execute_rq(drive->queue, NULL, rq, 0);
479 return (drive->mult_count == arg) ? 0 : -EIO;
482 ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
484 static int set_nowerr(ide_drive_t *drive, int arg)
486 if (arg < 0 || arg > 1)
490 drive->dev_flags |= IDE_DFLAG_NOWERR;
492 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
494 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
499 static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
503 memset(&task, 0, sizeof(task));
504 task.tf.feature = feature;
505 task.tf.nsect = nsect;
506 task.tf.command = ATA_CMD_SET_FEATURES;
507 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
509 return ide_no_data_taskfile(drive, &task);
512 static void update_ordered(ide_drive_t *drive)
515 unsigned ordered = QUEUE_ORDERED_NONE;
516 prepare_flush_fn *prep_fn = NULL;
518 if (drive->dev_flags & IDE_DFLAG_WCACHE) {
519 unsigned long long capacity;
522 * We must avoid issuing commands a drive does not
523 * understand or we may crash it. We check flush cache
524 * is supported. We also check we have the LBA48 flush
525 * cache if the drive capacity is too large. By this
526 * time we have trimmed the drive capacity if LBA48 is
527 * not available so we don't need to recheck that.
529 capacity = ide_disk_capacity(drive);
530 barrier = ata_id_flush_enabled(id) &&
531 (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
532 ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
533 capacity <= (1ULL << 28) ||
534 ata_id_flush_ext_enabled(id));
536 printk(KERN_INFO "%s: cache flushes %ssupported\n",
537 drive->name, barrier ? "" : "not ");
540 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
541 prep_fn = idedisk_prepare_flush;
544 ordered = QUEUE_ORDERED_DRAIN;
546 blk_queue_ordered(drive->queue, ordered, prep_fn);
549 ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
551 static int set_wcache(ide_drive_t *drive, int arg)
555 if (arg < 0 || arg > 1)
558 if (ata_id_flush_enabled(drive->id)) {
559 err = ide_do_setfeature(drive,
560 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
563 drive->dev_flags |= IDE_DFLAG_WCACHE;
565 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
569 update_ordered(drive);
574 static int do_idedisk_flushcache(ide_drive_t *drive)
578 memset(&args, 0, sizeof(ide_task_t));
579 if (ata_id_flush_ext_enabled(drive->id))
580 args.tf.command = ATA_CMD_FLUSH_EXT;
582 args.tf.command = ATA_CMD_FLUSH;
583 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
584 return ide_no_data_taskfile(drive, &args);
587 ide_devset_get(acoustic, acoustic);
589 static int set_acoustic(ide_drive_t *drive, int arg)
591 if (arg < 0 || arg > 254)
594 ide_do_setfeature(drive,
595 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
597 drive->acoustic = arg;
602 ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
608 * 2: 48-bit capable doing 28-bit
610 static int set_addressing(ide_drive_t *drive, int arg)
612 if (arg < 0 || arg > 2)
615 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
616 ata_id_lba48_enabled(drive->id) == 0))
623 drive->dev_flags |= IDE_DFLAG_LBA48;
625 drive->dev_flags &= ~IDE_DFLAG_LBA48;
630 ide_ext_devset_rw(acoustic, acoustic);
631 ide_ext_devset_rw(address, addressing);
632 ide_ext_devset_rw(multcount, multcount);
633 ide_ext_devset_rw(wcache, wcache);
635 ide_ext_devset_rw_sync(nowerr, nowerr);
637 static void idedisk_setup(ide_drive_t *drive)
639 struct ide_disk_obj *idkp = drive->driver_data;
640 ide_hwif_t *hwif = drive->hwif;
642 char *m = (char *)&id[ATA_ID_PROD];
643 unsigned long long capacity;
645 ide_proc_register_driver(drive, idkp->driver);
647 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
650 if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
652 * Removable disks (eg. SYQUEST); ignore 'WD' drives
654 if (m[0] != 'W' || m[1] != 'D')
655 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
658 (void)set_addressing(drive, 1);
660 if (drive->dev_flags & IDE_DFLAG_LBA48) {
663 if (max_s > hwif->rqsize)
664 max_s = hwif->rqsize;
666 blk_queue_max_sectors(drive->queue, max_s);
669 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
670 drive->queue->max_sectors / 2);
672 /* calculate drive capacity, and select LBA if possible */
673 init_idedisk_capacity(drive);
676 * if possible, give fdisk access to more of the drive,
677 * by correcting bios_cyls:
679 capacity = ide_disk_capacity(drive);
681 if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
682 if (ata_id_lba48_enabled(drive->id)) {
684 drive->bios_sect = 63;
685 drive->bios_head = 255;
688 if (drive->bios_sect && drive->bios_head) {
689 unsigned int cap0 = capacity; /* truncate to 32 bits */
690 unsigned int cylsz, cyl;
692 if (cap0 != capacity)
693 drive->bios_cyl = 65535;
695 cylsz = drive->bios_sect * drive->bios_head;
699 if (cyl > drive->bios_cyl)
700 drive->bios_cyl = cyl;
704 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
705 drive->name, capacity, sectors_to_MB(capacity));
707 /* Only print cache size when it was specified */
708 if (id[ATA_ID_BUF_SIZE])
709 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
711 printk(KERN_CONT ", CHS=%d/%d/%d\n",
712 drive->bios_cyl, drive->bios_head, drive->bios_sect);
714 /* write cache enabled? */
715 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
716 drive->dev_flags |= IDE_DFLAG_WCACHE;
718 set_wcache(drive, 1);
721 static void ide_cacheflush_p(ide_drive_t *drive)
723 if (ata_id_flush_enabled(drive->id) == 0 ||
724 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
727 if (do_idedisk_flushcache(drive))
728 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
731 static void ide_disk_remove(ide_drive_t *drive)
733 struct ide_disk_obj *idkp = drive->driver_data;
734 struct gendisk *g = idkp->disk;
736 ide_proc_unregister_driver(drive, idkp->driver);
740 ide_cacheflush_p(drive);
745 static void ide_disk_release(struct kref *kref)
747 struct ide_disk_obj *idkp = to_ide_drv(kref, ide_disk_obj);
748 ide_drive_t *drive = idkp->drive;
749 struct gendisk *g = idkp->disk;
751 drive->driver_data = NULL;
752 g->private_data = NULL;
757 static int ide_disk_probe(ide_drive_t *drive);
760 * On HPA drives the capacity needs to be
761 * reinitilized on resume otherwise the disk
762 * can not be used and a hard reset is required
764 static void ide_disk_resume(ide_drive_t *drive)
766 if (ata_id_hpa_enabled(drive->id))
767 init_idedisk_capacity(drive);
770 static void ide_device_shutdown(ide_drive_t *drive)
773 /* On Alpha, halt(8) doesn't actually turn the machine off,
774 it puts you into the sort of firmware monitor. Typically,
775 it's used to boot another kernel image, so it's not much
776 different from reboot(8). Therefore, we don't need to
777 spin down the disk in this case, especially since Alpha
778 firmware doesn't handle disks in standby mode properly.
779 On the other hand, it's reasonably safe to turn the power
780 off when the shutdown process reaches the firmware prompt,
781 as the firmware initialization takes rather long time -
782 at least 10 seconds, which should be sufficient for
783 the disk to expire its write cache. */
784 if (system_state != SYSTEM_POWER_OFF) {
786 if (system_state == SYSTEM_RESTART) {
788 ide_cacheflush_p(drive);
792 printk(KERN_INFO "Shutdown: %s\n", drive->name);
794 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
797 static ide_driver_t idedisk_driver = {
799 .owner = THIS_MODULE,
801 .bus = &ide_bus_type,
803 .probe = ide_disk_probe,
804 .remove = ide_disk_remove,
805 .resume = ide_disk_resume,
806 .shutdown = ide_device_shutdown,
807 .version = IDEDISK_VERSION,
808 .do_request = ide_do_rw_disk,
809 .end_request = ide_end_request,
810 .error = __ide_error,
811 #ifdef CONFIG_IDE_PROC_FS
812 .proc = ide_disk_proc,
813 .settings = ide_disk_settings,
817 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
821 memset(&task, 0, sizeof(task));
822 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
823 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
825 return ide_no_data_taskfile(drive, &task);
828 static int idedisk_open(struct inode *inode, struct file *filp)
830 struct gendisk *disk = inode->i_bdev->bd_disk;
831 struct ide_disk_obj *idkp;
834 idkp = ide_disk_get(disk);
842 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
844 * Ignore the return code from door_lock,
845 * since the open() has already succeeded,
846 * and the door_lock is irrelevant at this point.
848 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
849 idedisk_set_doorlock(drive, 1))
850 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
851 check_disk_change(inode->i_bdev);
856 static int idedisk_release(struct inode *inode, struct file *filp)
858 struct gendisk *disk = inode->i_bdev->bd_disk;
859 struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
860 ide_drive_t *drive = idkp->drive;
862 if (idkp->openers == 1)
863 ide_cacheflush_p(drive);
865 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
866 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
867 idedisk_set_doorlock(drive, 0))
868 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
878 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
880 struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
881 ide_drive_t *drive = idkp->drive;
883 geo->heads = drive->bios_head;
884 geo->sectors = drive->bios_sect;
885 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
889 static int idedisk_media_changed(struct gendisk *disk)
891 struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
892 ide_drive_t *drive = idkp->drive;
894 /* do not scan partitions twice if this is a removable device */
895 if (drive->dev_flags & IDE_DFLAG_ATTACH) {
896 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
900 /* if removable, always assume it was changed */
901 return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
904 static int idedisk_revalidate_disk(struct gendisk *disk)
906 struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
907 set_capacity(disk, ide_disk_capacity(idkp->drive));
911 static struct block_device_operations idedisk_ops = {
912 .owner = THIS_MODULE,
913 .open = idedisk_open,
914 .release = idedisk_release,
915 .ioctl = ide_disk_ioctl,
916 .getgeo = idedisk_getgeo,
917 .media_changed = idedisk_media_changed,
918 .revalidate_disk = idedisk_revalidate_disk
921 MODULE_DESCRIPTION("ATA DISK Driver");
923 static int ide_disk_probe(ide_drive_t *drive)
925 struct ide_disk_obj *idkp;
928 /* strstr("foo", "") is non-NULL */
929 if (!strstr("ide-disk", drive->driver_req))
932 if (drive->media != ide_disk)
935 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
939 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
943 ide_init_disk(g, drive);
945 kref_init(&idkp->kref);
948 idkp->driver = &idedisk_driver;
951 g->private_data = &idkp->driver;
953 drive->driver_data = idkp;
955 idedisk_setup(drive);
956 if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
957 (drive->head == 0 || drive->head > 16)) {
958 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
959 drive->name, drive->head);
960 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
962 drive->dev_flags |= IDE_DFLAG_ATTACH;
964 g->minors = IDE_DISK_MINORS;
965 g->driverfs_dev = &drive->gendev;
966 g->flags |= GENHD_FL_EXT_DEVT;
967 if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
968 g->flags = GENHD_FL_REMOVABLE;
969 set_capacity(g, ide_disk_capacity(drive));
970 g->fops = &idedisk_ops;
980 static void __exit idedisk_exit(void)
982 driver_unregister(&idedisk_driver.gen_driver);
985 static int __init idedisk_init(void)
987 return driver_register(&idedisk_driver.gen_driver);
990 MODULE_ALIAS("ide:*m-disk*");
991 MODULE_ALIAS("ide-disk");
992 module_init(idedisk_init);
993 module_exit(idedisk_exit);
994 MODULE_LICENSE("GPL");