diff options
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/ide/Makefile | 2 | ||||
-rw-r--r-- | drivers/ide/ide-disk.c | 305 | ||||
-rw-r--r-- | drivers/ide/ide-disk.h | 8 | ||||
-rw-r--r-- | drivers/ide/ide-disk_proc.c | 2 | ||||
-rw-r--r-- | drivers/ide/ide-gd.c | 296 |
5 files changed, 314 insertions, 299 deletions
diff --git a/drivers/ide/Makefile b/drivers/ide/Makefile index ceaf779054ea..8aad9395a427 100644 --- a/drivers/ide/Makefile +++ b/drivers/ide/Makefile | |||
@@ -37,7 +37,7 @@ obj-$(CONFIG_IDE_H8300) += h8300/ | |||
37 | obj-$(CONFIG_IDE_GENERIC) += ide-generic.o | 37 | obj-$(CONFIG_IDE_GENERIC) += ide-generic.o |
38 | obj-$(CONFIG_BLK_DEV_IDEPNP) += ide-pnp.o | 38 | obj-$(CONFIG_BLK_DEV_IDEPNP) += ide-pnp.o |
39 | 39 | ||
40 | ide-disk_mod-y += ide-disk.o ide-disk_ioctl.o | 40 | ide-disk_mod-y += ide-gd.o ide-disk.o ide-disk_ioctl.o |
41 | ide-cd_mod-y += ide-cd.o ide-cd_ioctl.o ide-cd_verbose.o | 41 | ide-cd_mod-y += ide-cd.o ide-cd_ioctl.o ide-cd_verbose.o |
42 | ide-floppy_mod-y += ide-floppy.o ide-floppy_ioctl.o | 42 | ide-floppy_mod-y += ide-floppy.o ide-floppy_ioctl.o |
43 | 43 | ||
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c index 70b75f23a70e..751be7af22c2 100644 --- a/drivers/ide/ide-disk.c +++ b/drivers/ide/ide-disk.c | |||
@@ -14,9 +14,6 @@ | |||
14 | * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c. | 14 | * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c. |
15 | */ | 15 | */ |
16 | 16 | ||
17 | #define IDEDISK_VERSION "1.18" | ||
18 | |||
19 | #include <linux/module.h> | ||
20 | #include <linux/types.h> | 17 | #include <linux/types.h> |
21 | #include <linux/string.h> | 18 | #include <linux/string.h> |
22 | #include <linux/kernel.h> | 19 | #include <linux/kernel.h> |
@@ -39,44 +36,8 @@ | |||
39 | #include <asm/io.h> | 36 | #include <asm/io.h> |
40 | #include <asm/div64.h> | 37 | #include <asm/div64.h> |
41 | 38 | ||
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" | 39 | #include "ide-disk.h" |
49 | 40 | ||
50 | static DEFINE_MUTEX(idedisk_ref_mutex); | ||
51 | |||
52 | static void ide_disk_release(struct kref *); | ||
53 | |||
54 | static struct ide_disk_obj *ide_disk_get(struct gendisk *disk) | ||
55 | { | ||
56 | struct ide_disk_obj *idkp = NULL; | ||
57 | |||
58 | mutex_lock(&idedisk_ref_mutex); | ||
59 | idkp = ide_drv_g(disk, ide_disk_obj); | ||
60 | if (idkp) { | ||
61 | if (ide_device_get(idkp->drive)) | ||
62 | idkp = NULL; | ||
63 | else | ||
64 | kref_get(&idkp->kref); | ||
65 | } | ||
66 | mutex_unlock(&idedisk_ref_mutex); | ||
67 | return idkp; | ||
68 | } | ||
69 | |||
70 | static void ide_disk_put(struct ide_disk_obj *idkp) | ||
71 | { | ||
72 | ide_drive_t *drive = idkp->drive; | ||
73 | |||
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); | ||
78 | } | ||
79 | |||
80 | static const u8 ide_rw_cmds[] = { | 41 | static const u8 ide_rw_cmds[] = { |
81 | ATA_CMD_READ_MULTI, | 42 | ATA_CMD_READ_MULTI, |
82 | ATA_CMD_WRITE_MULTI, | 43 | ATA_CMD_WRITE_MULTI, |
@@ -223,8 +184,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, | |||
223 | * 1073741822 == 549756 MB or 48bit addressing fake drive | 184 | * 1073741822 == 549756 MB or 48bit addressing fake drive |
224 | */ | 185 | */ |
225 | 186 | ||
226 | static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq, | 187 | ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq, |
227 | sector_t block) | 188 | sector_t block) |
228 | { | 189 | { |
229 | ide_hwif_t *hwif = HWIF(drive); | 190 | ide_hwif_t *hwif = HWIF(drive); |
230 | 191 | ||
@@ -372,7 +333,7 @@ static void idedisk_check_hpa(ide_drive_t *drive) | |||
372 | } | 333 | } |
373 | } | 334 | } |
374 | 335 | ||
375 | static void init_idedisk_capacity(ide_drive_t *drive) | 336 | void ide_disk_init_capacity(ide_drive_t *drive) |
376 | { | 337 | { |
377 | u16 *id = drive->id; | 338 | u16 *id = drive->id; |
378 | int lba; | 339 | int lba; |
@@ -423,11 +384,6 @@ static void init_idedisk_capacity(ide_drive_t *drive) | |||
423 | } | 384 | } |
424 | } | 385 | } |
425 | 386 | ||
426 | sector_t ide_disk_capacity(ide_drive_t *drive) | ||
427 | { | ||
428 | return drive->capacity64; | ||
429 | } | ||
430 | |||
431 | static void idedisk_prepare_flush(struct request_queue *q, struct request *rq) | 387 | static void idedisk_prepare_flush(struct request_queue *q, struct request *rq) |
432 | { | 388 | { |
433 | ide_drive_t *drive = q->queuedata; | 389 | ide_drive_t *drive = q->queuedata; |
@@ -526,7 +482,7 @@ static void update_ordered(ide_drive_t *drive) | |||
526 | * time we have trimmed the drive capacity if LBA48 is | 482 | * time we have trimmed the drive capacity if LBA48 is |
527 | * not available so we don't need to recheck that. | 483 | * not available so we don't need to recheck that. |
528 | */ | 484 | */ |
529 | capacity = ide_disk_capacity(drive); | 485 | capacity = ide_gd_capacity(drive); |
530 | barrier = ata_id_flush_enabled(id) && | 486 | barrier = ata_id_flush_enabled(id) && |
531 | (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 && | 487 | (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 && |
532 | ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 || | 488 | ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 || |
@@ -634,7 +590,7 @@ ide_ext_devset_rw(wcache, wcache); | |||
634 | 590 | ||
635 | ide_ext_devset_rw_sync(nowerr, nowerr); | 591 | ide_ext_devset_rw_sync(nowerr, nowerr); |
636 | 592 | ||
637 | static void idedisk_setup(ide_drive_t *drive) | 593 | void ide_disk_setup(ide_drive_t *drive) |
638 | { | 594 | { |
639 | struct ide_disk_obj *idkp = drive->driver_data; | 595 | struct ide_disk_obj *idkp = drive->driver_data; |
640 | ide_hwif_t *hwif = drive->hwif; | 596 | ide_hwif_t *hwif = drive->hwif; |
@@ -670,13 +626,13 @@ static void idedisk_setup(ide_drive_t *drive) | |||
670 | drive->queue->max_sectors / 2); | 626 | drive->queue->max_sectors / 2); |
671 | 627 | ||
672 | /* calculate drive capacity, and select LBA if possible */ | 628 | /* calculate drive capacity, and select LBA if possible */ |
673 | init_idedisk_capacity(drive); | 629 | ide_disk_init_capacity(drive); |
674 | 630 | ||
675 | /* | 631 | /* |
676 | * if possible, give fdisk access to more of the drive, | 632 | * if possible, give fdisk access to more of the drive, |
677 | * by correcting bios_cyls: | 633 | * by correcting bios_cyls: |
678 | */ | 634 | */ |
679 | capacity = ide_disk_capacity(drive); | 635 | capacity = ide_gd_capacity(drive); |
680 | 636 | ||
681 | if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) { | 637 | if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) { |
682 | if (ata_id_lba48_enabled(drive->id)) { | 638 | if (ata_id_lba48_enabled(drive->id)) { |
@@ -726,7 +682,7 @@ static void idedisk_setup(ide_drive_t *drive) | |||
726 | drive->dev_flags |= IDE_DFLAG_ATTACH; | 682 | drive->dev_flags |= IDE_DFLAG_ATTACH; |
727 | } | 683 | } |
728 | 684 | ||
729 | static void ide_cacheflush_p(ide_drive_t *drive) | 685 | void ide_disk_flush(ide_drive_t *drive) |
730 | { | 686 | { |
731 | if (ata_id_flush_enabled(drive->id) == 0 || | 687 | if (ata_id_flush_enabled(drive->id) == 0 || |
732 | (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) | 688 | (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) |
@@ -736,93 +692,7 @@ static void ide_cacheflush_p(ide_drive_t *drive) | |||
736 | printk(KERN_INFO "%s: wcache flush failed!\n", drive->name); | 692 | printk(KERN_INFO "%s: wcache flush failed!\n", drive->name); |
737 | } | 693 | } |
738 | 694 | ||
739 | static void ide_disk_remove(ide_drive_t *drive) | 695 | int ide_disk_set_doorlock(ide_drive_t *drive, int on) |
740 | { | ||
741 | struct ide_disk_obj *idkp = drive->driver_data; | ||
742 | struct gendisk *g = idkp->disk; | ||
743 | |||
744 | ide_proc_unregister_driver(drive, idkp->driver); | ||
745 | |||
746 | del_gendisk(g); | ||
747 | |||
748 | ide_cacheflush_p(drive); | ||
749 | |||
750 | ide_disk_put(idkp); | ||
751 | } | ||
752 | |||
753 | static void ide_disk_release(struct kref *kref) | ||
754 | { | ||
755 | struct ide_disk_obj *idkp = to_ide_drv(kref, ide_disk_obj); | ||
756 | ide_drive_t *drive = idkp->drive; | ||
757 | struct gendisk *g = idkp->disk; | ||
758 | |||
759 | drive->driver_data = NULL; | ||
760 | g->private_data = NULL; | ||
761 | put_disk(g); | ||
762 | kfree(idkp); | ||
763 | } | ||
764 | |||
765 | static int ide_disk_probe(ide_drive_t *drive); | ||
766 | |||
767 | /* | ||
768 | * On HPA drives the capacity needs to be | ||
769 | * reinitilized on resume otherwise the disk | ||
770 | * can not be used and a hard reset is required | ||
771 | */ | ||
772 | static void ide_disk_resume(ide_drive_t *drive) | ||
773 | { | ||
774 | if (ata_id_hpa_enabled(drive->id)) | ||
775 | init_idedisk_capacity(drive); | ||
776 | } | ||
777 | |||
778 | static void ide_device_shutdown(ide_drive_t *drive) | ||
779 | { | ||
780 | #ifdef CONFIG_ALPHA | ||
781 | /* On Alpha, halt(8) doesn't actually turn the machine off, | ||
782 | it puts you into the sort of firmware monitor. Typically, | ||
783 | it's used to boot another kernel image, so it's not much | ||
784 | different from reboot(8). Therefore, we don't need to | ||
785 | spin down the disk in this case, especially since Alpha | ||
786 | firmware doesn't handle disks in standby mode properly. | ||
787 | On the other hand, it's reasonably safe to turn the power | ||
788 | off when the shutdown process reaches the firmware prompt, | ||
789 | as the firmware initialization takes rather long time - | ||
790 | at least 10 seconds, which should be sufficient for | ||
791 | the disk to expire its write cache. */ | ||
792 | if (system_state != SYSTEM_POWER_OFF) { | ||
793 | #else | ||
794 | if (system_state == SYSTEM_RESTART) { | ||
795 | #endif | ||
796 | ide_cacheflush_p(drive); | ||
797 | return; | ||
798 | } | ||
799 | |||
800 | printk(KERN_INFO "Shutdown: %s\n", drive->name); | ||
801 | |||
802 | drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND); | ||
803 | } | ||
804 | |||
805 | static ide_driver_t idedisk_driver = { | ||
806 | .gen_driver = { | ||
807 | .owner = THIS_MODULE, | ||
808 | .name = "ide-disk", | ||
809 | .bus = &ide_bus_type, | ||
810 | }, | ||
811 | .probe = ide_disk_probe, | ||
812 | .remove = ide_disk_remove, | ||
813 | .resume = ide_disk_resume, | ||
814 | .shutdown = ide_device_shutdown, | ||
815 | .version = IDEDISK_VERSION, | ||
816 | .do_request = ide_do_rw_disk, | ||
817 | .end_request = ide_end_request, | ||
818 | .error = __ide_error, | ||
819 | #ifdef CONFIG_IDE_PROC_FS | ||
820 | .proc = ide_disk_proc, | ||
821 | .settings = ide_disk_settings, | ||
822 | #endif | ||
823 | }; | ||
824 | |||
825 | static int idedisk_set_doorlock(ide_drive_t *drive, int on) | ||
826 | { | 696 | { |
827 | ide_task_t task; | 697 | ide_task_t task; |
828 | int ret; | 698 | int ret; |
@@ -841,160 +711,3 @@ static int idedisk_set_doorlock(ide_drive_t *drive, int on) | |||
841 | 711 | ||
842 | return ret; | 712 | return ret; |
843 | } | 713 | } |
844 | |||
845 | static int idedisk_open(struct inode *inode, struct file *filp) | ||
846 | { | ||
847 | struct gendisk *disk = inode->i_bdev->bd_disk; | ||
848 | struct ide_disk_obj *idkp; | ||
849 | ide_drive_t *drive; | ||
850 | |||
851 | idkp = ide_disk_get(disk); | ||
852 | if (idkp == NULL) | ||
853 | return -ENXIO; | ||
854 | |||
855 | drive = idkp->drive; | ||
856 | |||
857 | idkp->openers++; | ||
858 | |||
859 | if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) { | ||
860 | /* | ||
861 | * Ignore the return code from door_lock, | ||
862 | * since the open() has already succeeded, | ||
863 | * and the door_lock is irrelevant at this point. | ||
864 | */ | ||
865 | idedisk_set_doorlock(drive, 1); | ||
866 | check_disk_change(inode->i_bdev); | ||
867 | } | ||
868 | return 0; | ||
869 | } | ||
870 | |||
871 | static int idedisk_release(struct inode *inode, struct file *filp) | ||
872 | { | ||
873 | struct gendisk *disk = inode->i_bdev->bd_disk; | ||
874 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | ||
875 | ide_drive_t *drive = idkp->drive; | ||
876 | |||
877 | if (idkp->openers == 1) | ||
878 | ide_cacheflush_p(drive); | ||
879 | |||
880 | if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) | ||
881 | idedisk_set_doorlock(drive, 0); | ||
882 | |||
883 | idkp->openers--; | ||
884 | |||
885 | ide_disk_put(idkp); | ||
886 | |||
887 | return 0; | ||
888 | } | ||
889 | |||
890 | static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo) | ||
891 | { | ||
892 | struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj); | ||
893 | ide_drive_t *drive = idkp->drive; | ||
894 | |||
895 | geo->heads = drive->bios_head; | ||
896 | geo->sectors = drive->bios_sect; | ||
897 | geo->cylinders = (u16)drive->bios_cyl; /* truncate */ | ||
898 | return 0; | ||
899 | } | ||
900 | |||
901 | static int idedisk_media_changed(struct gendisk *disk) | ||
902 | { | ||
903 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | ||
904 | ide_drive_t *drive = idkp->drive; | ||
905 | |||
906 | /* do not scan partitions twice if this is a removable device */ | ||
907 | if (drive->dev_flags & IDE_DFLAG_ATTACH) { | ||
908 | drive->dev_flags &= ~IDE_DFLAG_ATTACH; | ||
909 | return 0; | ||
910 | } | ||
911 | |||
912 | /* if removable, always assume it was changed */ | ||
913 | return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE); | ||
914 | } | ||
915 | |||
916 | static int idedisk_revalidate_disk(struct gendisk *disk) | ||
917 | { | ||
918 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | ||
919 | set_capacity(disk, ide_disk_capacity(idkp->drive)); | ||
920 | return 0; | ||
921 | } | ||
922 | |||
923 | static struct block_device_operations idedisk_ops = { | ||
924 | .owner = THIS_MODULE, | ||
925 | .open = idedisk_open, | ||
926 | .release = idedisk_release, | ||
927 | .ioctl = ide_disk_ioctl, | ||
928 | .getgeo = idedisk_getgeo, | ||
929 | .media_changed = idedisk_media_changed, | ||
930 | .revalidate_disk = idedisk_revalidate_disk | ||
931 | }; | ||
932 | |||
933 | MODULE_DESCRIPTION("ATA DISK Driver"); | ||
934 | |||
935 | static int ide_disk_probe(ide_drive_t *drive) | ||
936 | { | ||
937 | struct ide_disk_obj *idkp; | ||
938 | struct gendisk *g; | ||
939 | |||
940 | /* strstr("foo", "") is non-NULL */ | ||
941 | if (!strstr("ide-disk", drive->driver_req)) | ||
942 | goto failed; | ||
943 | |||
944 | if (drive->media != ide_disk) | ||
945 | goto failed; | ||
946 | |||
947 | idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); | ||
948 | if (!idkp) | ||
949 | goto failed; | ||
950 | |||
951 | g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif)); | ||
952 | if (!g) | ||
953 | goto out_free_idkp; | ||
954 | |||
955 | ide_init_disk(g, drive); | ||
956 | |||
957 | kref_init(&idkp->kref); | ||
958 | |||
959 | idkp->drive = drive; | ||
960 | idkp->driver = &idedisk_driver; | ||
961 | idkp->disk = g; | ||
962 | |||
963 | g->private_data = &idkp->driver; | ||
964 | |||
965 | drive->driver_data = idkp; | ||
966 | |||
967 | idedisk_setup(drive); | ||
968 | |||
969 | set_capacity(g, ide_disk_capacity(drive)); | ||
970 | |||
971 | g->minors = IDE_DISK_MINORS; | ||
972 | g->driverfs_dev = &drive->gendev; | ||
973 | g->flags |= GENHD_FL_EXT_DEVT; | ||
974 | if (drive->dev_flags & IDE_DFLAG_REMOVABLE) | ||
975 | g->flags = GENHD_FL_REMOVABLE; | ||
976 | g->fops = &idedisk_ops; | ||
977 | add_disk(g); | ||
978 | return 0; | ||
979 | |||
980 | out_free_idkp: | ||
981 | kfree(idkp); | ||
982 | failed: | ||
983 | return -ENODEV; | ||
984 | } | ||
985 | |||
986 | static void __exit idedisk_exit(void) | ||
987 | { | ||
988 | driver_unregister(&idedisk_driver.gen_driver); | ||
989 | } | ||
990 | |||
991 | static int __init idedisk_init(void) | ||
992 | { | ||
993 | return driver_register(&idedisk_driver.gen_driver); | ||
994 | } | ||
995 | |||
996 | MODULE_ALIAS("ide:*m-disk*"); | ||
997 | MODULE_ALIAS("ide-disk"); | ||
998 | module_init(idedisk_init); | ||
999 | module_exit(idedisk_exit); | ||
1000 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/ide/ide-disk.h b/drivers/ide/ide-disk.h index 50d674b91c8b..104ad71288a5 100644 --- a/drivers/ide/ide-disk.h +++ b/drivers/ide/ide-disk.h | |||
@@ -9,8 +9,14 @@ struct ide_disk_obj { | |||
9 | unsigned int openers; /* protected by BKL for now */ | 9 | unsigned int openers; /* protected by BKL for now */ |
10 | }; | 10 | }; |
11 | 11 | ||
12 | sector_t ide_gd_capacity(ide_drive_t *); | ||
13 | |||
12 | /* ide-disk.c */ | 14 | /* ide-disk.c */ |
13 | sector_t ide_disk_capacity(ide_drive_t *); | 15 | void ide_disk_init_capacity(ide_drive_t *); |
16 | void ide_disk_setup(ide_drive_t *); | ||
17 | void ide_disk_flush(ide_drive_t *); | ||
18 | int ide_disk_set_doorlock(ide_drive_t *, int); | ||
19 | ide_startstop_t ide_do_rw_disk(ide_drive_t *, struct request *, sector_t); | ||
14 | ide_decl_devset(address); | 20 | ide_decl_devset(address); |
15 | ide_decl_devset(multcount); | 21 | ide_decl_devset(multcount); |
16 | ide_decl_devset(nowerr); | 22 | ide_decl_devset(nowerr); |
diff --git a/drivers/ide/ide-disk_proc.c b/drivers/ide/ide-disk_proc.c index 4724976afe71..1146f4204c6e 100644 --- a/drivers/ide/ide-disk_proc.c +++ b/drivers/ide/ide-disk_proc.c | |||
@@ -56,7 +56,7 @@ static int proc_idedisk_read_capacity | |||
56 | ide_drive_t*drive = (ide_drive_t *)data; | 56 | ide_drive_t*drive = (ide_drive_t *)data; |
57 | int len; | 57 | int len; |
58 | 58 | ||
59 | len = sprintf(page, "%llu\n", (long long)ide_disk_capacity(drive)); | 59 | len = sprintf(page, "%llu\n", (long long)ide_gd_capacity(drive)); |
60 | 60 | ||
61 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); | 61 | PROC_IDE_READ_RETURN(page, start, off, count, eof, len); |
62 | } | 62 | } |
diff --git a/drivers/ide/ide-gd.c b/drivers/ide/ide-gd.c new file mode 100644 index 000000000000..84bbcfee9233 --- /dev/null +++ b/drivers/ide/ide-gd.c | |||
@@ -0,0 +1,296 @@ | |||
1 | #include <linux/module.h> | ||
2 | #include <linux/types.h> | ||
3 | #include <linux/string.h> | ||
4 | #include <linux/kernel.h> | ||
5 | #include <linux/errno.h> | ||
6 | #include <linux/genhd.h> | ||
7 | #include <linux/mutex.h> | ||
8 | #include <linux/ide.h> | ||
9 | #include <linux/hdreg.h> | ||
10 | |||
11 | #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT) | ||
12 | #define IDE_DISK_MINORS (1 << PARTN_BITS) | ||
13 | #else | ||
14 | #define IDE_DISK_MINORS 0 | ||
15 | #endif | ||
16 | |||
17 | #include "ide-disk.h" | ||
18 | |||
19 | #define IDE_GD_VERSION "1.18" | ||
20 | |||
21 | static DEFINE_MUTEX(ide_disk_ref_mutex); | ||
22 | |||
23 | static void ide_disk_release(struct kref *); | ||
24 | |||
25 | static struct ide_disk_obj *ide_disk_get(struct gendisk *disk) | ||
26 | { | ||
27 | struct ide_disk_obj *idkp = NULL; | ||
28 | |||
29 | mutex_lock(&ide_disk_ref_mutex); | ||
30 | idkp = ide_drv_g(disk, ide_disk_obj); | ||
31 | if (idkp) { | ||
32 | if (ide_device_get(idkp->drive)) | ||
33 | idkp = NULL; | ||
34 | else | ||
35 | kref_get(&idkp->kref); | ||
36 | } | ||
37 | mutex_unlock(&ide_disk_ref_mutex); | ||
38 | return idkp; | ||
39 | } | ||
40 | |||
41 | static void ide_disk_put(struct ide_disk_obj *idkp) | ||
42 | { | ||
43 | ide_drive_t *drive = idkp->drive; | ||
44 | |||
45 | mutex_lock(&ide_disk_ref_mutex); | ||
46 | kref_put(&idkp->kref, ide_disk_release); | ||
47 | ide_device_put(drive); | ||
48 | mutex_unlock(&ide_disk_ref_mutex); | ||
49 | } | ||
50 | |||
51 | sector_t ide_gd_capacity(ide_drive_t *drive) | ||
52 | { | ||
53 | return drive->capacity64; | ||
54 | } | ||
55 | |||
56 | static int ide_gd_probe(ide_drive_t *); | ||
57 | |||
58 | static void ide_gd_remove(ide_drive_t *drive) | ||
59 | { | ||
60 | struct ide_disk_obj *idkp = drive->driver_data; | ||
61 | struct gendisk *g = idkp->disk; | ||
62 | |||
63 | ide_proc_unregister_driver(drive, idkp->driver); | ||
64 | |||
65 | del_gendisk(g); | ||
66 | |||
67 | ide_disk_flush(drive); | ||
68 | |||
69 | ide_disk_put(idkp); | ||
70 | } | ||
71 | |||
72 | static void ide_disk_release(struct kref *kref) | ||
73 | { | ||
74 | struct ide_disk_obj *idkp = to_ide_drv(kref, ide_disk_obj); | ||
75 | ide_drive_t *drive = idkp->drive; | ||
76 | struct gendisk *g = idkp->disk; | ||
77 | |||
78 | drive->driver_data = NULL; | ||
79 | g->private_data = NULL; | ||
80 | put_disk(g); | ||
81 | kfree(idkp); | ||
82 | } | ||
83 | |||
84 | /* | ||
85 | * On HPA drives the capacity needs to be | ||
86 | * reinitilized on resume otherwise the disk | ||
87 | * can not be used and a hard reset is required | ||
88 | */ | ||
89 | static void ide_gd_resume(ide_drive_t *drive) | ||
90 | { | ||
91 | if (ata_id_hpa_enabled(drive->id)) | ||
92 | ide_disk_init_capacity(drive); | ||
93 | } | ||
94 | |||
95 | static void ide_gd_shutdown(ide_drive_t *drive) | ||
96 | { | ||
97 | #ifdef CONFIG_ALPHA | ||
98 | /* On Alpha, halt(8) doesn't actually turn the machine off, | ||
99 | it puts you into the sort of firmware monitor. Typically, | ||
100 | it's used to boot another kernel image, so it's not much | ||
101 | different from reboot(8). Therefore, we don't need to | ||
102 | spin down the disk in this case, especially since Alpha | ||
103 | firmware doesn't handle disks in standby mode properly. | ||
104 | On the other hand, it's reasonably safe to turn the power | ||
105 | off when the shutdown process reaches the firmware prompt, | ||
106 | as the firmware initialization takes rather long time - | ||
107 | at least 10 seconds, which should be sufficient for | ||
108 | the disk to expire its write cache. */ | ||
109 | if (system_state != SYSTEM_POWER_OFF) { | ||
110 | #else | ||
111 | if (system_state == SYSTEM_RESTART) { | ||
112 | #endif | ||
113 | ide_disk_flush(drive); | ||
114 | return; | ||
115 | } | ||
116 | |||
117 | printk(KERN_INFO "Shutdown: %s\n", drive->name); | ||
118 | |||
119 | drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND); | ||
120 | } | ||
121 | |||
122 | static ide_driver_t ide_gd_driver = { | ||
123 | .gen_driver = { | ||
124 | .owner = THIS_MODULE, | ||
125 | .name = "ide-disk", | ||
126 | .bus = &ide_bus_type, | ||
127 | }, | ||
128 | .probe = ide_gd_probe, | ||
129 | .remove = ide_gd_remove, | ||
130 | .resume = ide_gd_resume, | ||
131 | .shutdown = ide_gd_shutdown, | ||
132 | .version = IDE_GD_VERSION, | ||
133 | .do_request = ide_do_rw_disk, | ||
134 | .end_request = ide_end_request, | ||
135 | .error = __ide_error, | ||
136 | #ifdef CONFIG_IDE_PROC_FS | ||
137 | .proc = ide_disk_proc, | ||
138 | .settings = ide_disk_settings, | ||
139 | #endif | ||
140 | }; | ||
141 | |||
142 | static int ide_gd_open(struct inode *inode, struct file *filp) | ||
143 | { | ||
144 | struct gendisk *disk = inode->i_bdev->bd_disk; | ||
145 | struct ide_disk_obj *idkp; | ||
146 | ide_drive_t *drive; | ||
147 | |||
148 | idkp = ide_disk_get(disk); | ||
149 | if (idkp == NULL) | ||
150 | return -ENXIO; | ||
151 | |||
152 | drive = idkp->drive; | ||
153 | |||
154 | idkp->openers++; | ||
155 | |||
156 | if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) { | ||
157 | /* | ||
158 | * Ignore the return code from door_lock, | ||
159 | * since the open() has already succeeded, | ||
160 | * and the door_lock is irrelevant at this point. | ||
161 | */ | ||
162 | ide_disk_set_doorlock(drive, 1); | ||
163 | check_disk_change(inode->i_bdev); | ||
164 | } | ||
165 | return 0; | ||
166 | } | ||
167 | |||
168 | static int ide_gd_release(struct inode *inode, struct file *filp) | ||
169 | { | ||
170 | struct gendisk *disk = inode->i_bdev->bd_disk; | ||
171 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | ||
172 | ide_drive_t *drive = idkp->drive; | ||
173 | |||
174 | if (idkp->openers == 1) | ||
175 | ide_disk_flush(drive); | ||
176 | |||
177 | if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) | ||
178 | ide_disk_set_doorlock(drive, 0); | ||
179 | |||
180 | idkp->openers--; | ||
181 | |||
182 | ide_disk_put(idkp); | ||
183 | |||
184 | return 0; | ||
185 | } | ||
186 | |||
187 | static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo) | ||
188 | { | ||
189 | struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj); | ||
190 | ide_drive_t *drive = idkp->drive; | ||
191 | |||
192 | geo->heads = drive->bios_head; | ||
193 | geo->sectors = drive->bios_sect; | ||
194 | geo->cylinders = (u16)drive->bios_cyl; /* truncate */ | ||
195 | return 0; | ||
196 | } | ||
197 | |||
198 | static int ide_gd_media_changed(struct gendisk *disk) | ||
199 | { | ||
200 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | ||
201 | ide_drive_t *drive = idkp->drive; | ||
202 | |||
203 | /* do not scan partitions twice if this is a removable device */ | ||
204 | if (drive->dev_flags & IDE_DFLAG_ATTACH) { | ||
205 | drive->dev_flags &= ~IDE_DFLAG_ATTACH; | ||
206 | return 0; | ||
207 | } | ||
208 | |||
209 | /* if removable, always assume it was changed */ | ||
210 | return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE); | ||
211 | } | ||
212 | |||
213 | static int ide_gd_revalidate_disk(struct gendisk *disk) | ||
214 | { | ||
215 | struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj); | ||
216 | set_capacity(disk, ide_gd_capacity(idkp->drive)); | ||
217 | return 0; | ||
218 | } | ||
219 | |||
220 | static struct block_device_operations ide_gd_ops = { | ||
221 | .owner = THIS_MODULE, | ||
222 | .open = ide_gd_open, | ||
223 | .release = ide_gd_release, | ||
224 | .ioctl = ide_disk_ioctl, | ||
225 | .getgeo = ide_gd_getgeo, | ||
226 | .media_changed = ide_gd_media_changed, | ||
227 | .revalidate_disk = ide_gd_revalidate_disk | ||
228 | }; | ||
229 | |||
230 | static int ide_gd_probe(ide_drive_t *drive) | ||
231 | { | ||
232 | struct ide_disk_obj *idkp; | ||
233 | struct gendisk *g; | ||
234 | |||
235 | /* strstr("foo", "") is non-NULL */ | ||
236 | if (!strstr("ide-disk", drive->driver_req)) | ||
237 | goto failed; | ||
238 | |||
239 | if (drive->media != ide_disk) | ||
240 | goto failed; | ||
241 | |||
242 | idkp = kzalloc(sizeof(*idkp), GFP_KERNEL); | ||
243 | if (!idkp) | ||
244 | goto failed; | ||
245 | |||
246 | g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif)); | ||
247 | if (!g) | ||
248 | goto out_free_idkp; | ||
249 | |||
250 | ide_init_disk(g, drive); | ||
251 | |||
252 | kref_init(&idkp->kref); | ||
253 | |||
254 | idkp->drive = drive; | ||
255 | idkp->driver = &ide_gd_driver; | ||
256 | idkp->disk = g; | ||
257 | |||
258 | g->private_data = &idkp->driver; | ||
259 | |||
260 | drive->driver_data = idkp; | ||
261 | |||
262 | ide_disk_setup(drive); | ||
263 | |||
264 | set_capacity(g, ide_gd_capacity(drive)); | ||
265 | |||
266 | g->minors = IDE_DISK_MINORS; | ||
267 | g->driverfs_dev = &drive->gendev; | ||
268 | g->flags |= GENHD_FL_EXT_DEVT; | ||
269 | if (drive->dev_flags & IDE_DFLAG_REMOVABLE) | ||
270 | g->flags = GENHD_FL_REMOVABLE; | ||
271 | g->fops = &ide_gd_ops; | ||
272 | add_disk(g); | ||
273 | return 0; | ||
274 | |||
275 | out_free_idkp: | ||
276 | kfree(idkp); | ||
277 | failed: | ||
278 | return -ENODEV; | ||
279 | } | ||
280 | |||
281 | static int __init ide_gd_init(void) | ||
282 | { | ||
283 | return driver_register(&ide_gd_driver.gen_driver); | ||
284 | } | ||
285 | |||
286 | static void __exit ide_gd_exit(void) | ||
287 | { | ||
288 | driver_unregister(&ide_gd_driver.gen_driver); | ||
289 | } | ||
290 | |||
291 | MODULE_ALIAS("ide:*m-disk*"); | ||
292 | MODULE_ALIAS("ide-disk"); | ||
293 | module_init(ide_gd_init); | ||
294 | module_exit(ide_gd_exit); | ||
295 | MODULE_LICENSE("GPL"); | ||
296 | MODULE_DESCRIPTION("ATA DISK Driver"); | ||