[deliverable/linux.git] / drivers / ide / ide-gd.c

#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/mutex.h>
#include <linux/ide.h>
#include <linux/hdreg.h>
#include <linux/dmi.h>
#include <linux/slab.h>

#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
#define IDE_DISK_MINORS		(1 << PARTN_BITS)
#else
#define IDE_DISK_MINORS		0
#endif

#include "ide-disk.h"
#include "ide-floppy.h"

#define IDE_GD_VERSION	"1.18"

/* module parameters */
static unsigned long debug_mask;
module_param(debug_mask, ulong, 0644);

static DEFINE_MUTEX(ide_disk_ref_mutex);

static void ide_disk_release(struct device *);

static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
{
	struct ide_disk_obj *idkp = NULL;

	mutex_lock(&ide_disk_ref_mutex);
	idkp = ide_drv_g(disk, ide_disk_obj);
	if (idkp) {
		if (ide_device_get(idkp->drive))
			idkp = NULL;
		else
			get_device(&idkp->dev);
	}
	mutex_unlock(&ide_disk_ref_mutex);
	return idkp;
}

static void ide_disk_put(struct ide_disk_obj *idkp)
{
	ide_drive_t *drive = idkp->drive;

	mutex_lock(&ide_disk_ref_mutex);
	put_device(&idkp->dev);
	ide_device_put(drive);
	mutex_unlock(&ide_disk_ref_mutex);
}

sector_t ide_gd_capacity(ide_drive_t *drive)
{
	return drive->capacity64;
}

static int ide_gd_probe(ide_drive_t *);

static void ide_gd_remove(ide_drive_t *drive)
{
	struct ide_disk_obj *idkp = drive->driver_data;
	struct gendisk *g = idkp->disk;

	ide_proc_unregister_driver(drive, idkp->driver);
	device_del(&idkp->dev);
	del_gendisk(g);
	drive->disk_ops->flush(drive);

	mutex_lock(&ide_disk_ref_mutex);
	put_device(&idkp->dev);
	mutex_unlock(&ide_disk_ref_mutex);
}

static void ide_disk_release(struct device *dev)
{
	struct ide_disk_obj *idkp = to_ide_drv(dev, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;
	struct gendisk *g = idkp->disk;

	drive->disk_ops = NULL;
	drive->driver_data = NULL;
	g->private_data = NULL;
	put_disk(g);
	kfree(idkp);
}

/*
 * On HPA drives the capacity needs to be
 * reinitilized on resume otherwise the disk
 * can not be used and a hard reset is required
 */
static void ide_gd_resume(ide_drive_t *drive)
{
	if (ata_id_hpa_enabled(drive->id))
		(void)drive->disk_ops->get_capacity(drive);
}

static const struct dmi_system_id ide_coldreboot_table[] = {
	{
		/* Acer TravelMate 66x cuts power during reboot */
		.ident   = "Acer TravelMate 660",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 660"),
		},
	},

	{ }	/* terminate list */
};

static void ide_gd_shutdown(ide_drive_t *drive)
{
#ifdef	CONFIG_ALPHA
	/* On Alpha, halt(8) doesn't actually turn the machine off,
	   it puts you into the sort of firmware monitor. Typically,
	   it's used to boot another kernel image, so it's not much
	   different from reboot(8). Therefore, we don't need to
	   spin down the disk in this case, especially since Alpha
	   firmware doesn't handle disks in standby mode properly.
	   On the other hand, it's reasonably safe to turn the power
	   off when the shutdown process reaches the firmware prompt,
	   as the firmware initialization takes rather long time -
	   at least 10 seconds, which should be sufficient for
	   the disk to expire its write cache. */
	if (system_state != SYSTEM_POWER_OFF) {
#else
	if (system_state == SYSTEM_RESTART &&
		!dmi_check_system(ide_coldreboot_table)) {
#endif
		drive->disk_ops->flush(drive);
		return;
	}

	printk(KERN_INFO "Shutdown: %s\n", drive->name);

	drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
}

#ifdef CONFIG_IDE_PROC_FS
static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
{
	return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
}

static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive)
{
	return (drive->media == ide_disk) ? ide_disk_settings
					  : ide_floppy_settings;
}
#endif

static ide_startstop_t ide_gd_do_request(ide_drive_t *drive,
					 struct request *rq, sector_t sector)
{
	return drive->disk_ops->do_request(drive, rq, sector);
}

static struct ide_driver ide_gd_driver = {
	.gen_driver = {
		.owner		= THIS_MODULE,
		.name		= "ide-gd",
		.bus		= &ide_bus_type,
	},
	.probe			= ide_gd_probe,
	.remove			= ide_gd_remove,
	.resume			= ide_gd_resume,
	.shutdown		= ide_gd_shutdown,
	.version		= IDE_GD_VERSION,
	.do_request		= ide_gd_do_request,
#ifdef CONFIG_IDE_PROC_FS
	.proc_entries		= ide_disk_proc_entries,
	.proc_devsets		= ide_disk_proc_devsets,
#endif
};

static int ide_gd_open(struct block_device *bdev, fmode_t mode)
{
	struct gendisk *disk = bdev->bd_disk;
	struct ide_disk_obj *idkp;
	ide_drive_t *drive;
	int ret = 0;

	idkp = ide_disk_get(disk);
	if (idkp == NULL)
		return -ENXIO;

	drive = idkp->drive;

	ide_debug_log(IDE_DBG_FUNC, "enter");

	idkp->openers++;

	if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
		drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
		/* Just in case */

		ret = drive->disk_ops->init_media(drive, disk);

		/*
		 * Allow O_NDELAY to open a drive without a disk, or with an
		 * unreadable disk, so that we can get the format capacity
		 * of the drive or begin the format - Sam
		 */
		if (ret && (mode & FMODE_NDELAY) == 0) {
			ret = -EIO;
			goto out_put_idkp;
		}

		if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) {
			ret = -EROFS;
			goto out_put_idkp;
		}

		/*
		 * Ignore the return code from door_lock,
		 * since the open() has already succeeded,
		 * and the door_lock is irrelevant at this point.
		 */
		drive->disk_ops->set_doorlock(drive, disk, 1);
		drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
		check_disk_change(bdev);
	} else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
		ret = -EBUSY;
		goto out_put_idkp;
	}
	return 0;

out_put_idkp:
	idkp->openers--;
	ide_disk_put(idkp);
	return ret;
}

static int ide_gd_release(struct gendisk *disk, fmode_t mode)
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;

	ide_debug_log(IDE_DBG_FUNC, "enter");

	if (idkp->openers == 1)
		drive->disk_ops->flush(drive);

	if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
		drive->disk_ops->set_doorlock(drive, disk, 0);
		drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
	}

	idkp->openers--;

	ide_disk_put(idkp);

	return 0;
}

static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
	struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;

	geo->heads = drive->bios_head;
	geo->sectors = drive->bios_sect;
	geo->cylinders = (u16)drive->bios_cyl; /* truncate */
	return 0;
}

static int ide_gd_media_changed(struct gendisk *disk)
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;
	int ret;

	/* do not scan partitions twice if this is a removable device */
	if (drive->dev_flags & IDE_DFLAG_ATTACH) {
		drive->dev_flags &= ~IDE_DFLAG_ATTACH;
		return 0;
	}

	ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
	drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;

	return ret;
}

static void ide_gd_unlock_native_capacity(struct gendisk *disk)
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;
	const struct ide_disk_ops *disk_ops = drive->disk_ops;

	if (disk_ops->unlock_native_capacity)
		disk_ops->unlock_native_capacity(drive);
}

static int ide_gd_revalidate_disk(struct gendisk *disk)
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;

	if (ide_gd_media_changed(disk))
		drive->disk_ops->get_capacity(drive);

	set_capacity(disk, ide_gd_capacity(drive));
	return 0;
}

static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
			     unsigned int cmd, unsigned long arg)
{
	struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;

	return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
}

static const struct block_device_operations ide_gd_ops = {
	.owner			= THIS_MODULE,
	.open			= ide_gd_open,
	.release		= ide_gd_release,
	.locked_ioctl		= ide_gd_ioctl,
	.getgeo			= ide_gd_getgeo,
	.media_changed		= ide_gd_media_changed,
	.unlock_native_capacity	= ide_gd_unlock_native_capacity,
	.revalidate_disk	= ide_gd_revalidate_disk
};

static int ide_gd_probe(ide_drive_t *drive)
{
	const struct ide_disk_ops *disk_ops = NULL;
	struct ide_disk_obj *idkp;
	struct gendisk *g;

	/* strstr("foo", "") is non-NULL */
	if (!strstr("ide-gd", drive->driver_req))
		goto failed;

#ifdef CONFIG_IDE_GD_ATA
	if (drive->media == ide_disk)
		disk_ops = &ide_ata_disk_ops;
#endif
#ifdef CONFIG_IDE_GD_ATAPI
	if (drive->media == ide_floppy)
		disk_ops = &ide_atapi_disk_ops;
#endif
	if (disk_ops == NULL)
		goto failed;

	if (disk_ops->check(drive, DRV_NAME) == 0) {
		printk(KERN_ERR PFX "%s: not supported by this driver\n",
			drive->name);
		goto failed;
	}

	idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
	if (!idkp) {
		printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
			drive->name);
		goto failed;
	}

	g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
	if (!g)
		goto out_free_idkp;

	ide_init_disk(g, drive);

	idkp->dev.parent = &drive->gendev;
	idkp->dev.release = ide_disk_release;
	dev_set_name(&idkp->dev, dev_name(&drive->gendev));

	if (device_register(&idkp->dev))
		goto out_free_disk;

	idkp->drive = drive;
	idkp->driver = &ide_gd_driver;
	idkp->disk = g;

	g->private_data = &idkp->driver;

	drive->driver_data = idkp;
	drive->debug_mask = debug_mask;
	drive->disk_ops = disk_ops;

	disk_ops->setup(drive);

	set_capacity(g, ide_gd_capacity(drive));

	g->minors = IDE_DISK_MINORS;
	g->driverfs_dev = &drive->gendev;
	g->flags |= GENHD_FL_EXT_DEVT;
	if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
		g->flags = GENHD_FL_REMOVABLE;
	g->fops = &ide_gd_ops;
	add_disk(g);
	return 0;

out_free_disk:
	put_disk(g);
out_free_idkp:
	kfree(idkp);
failed:
	return -ENODEV;
}

static int __init ide_gd_init(void)
{
	printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
	return driver_register(&ide_gd_driver.gen_driver);
}

static void __exit ide_gd_exit(void)
{
	driver_unregister(&ide_gd_driver.gen_driver);
}

MODULE_ALIAS("ide:*m-disk*");
MODULE_ALIAS("ide-disk");
MODULE_ALIAS("ide:*m-floppy*");
MODULE_ALIAS("ide-floppy");
module_init(ide_gd_init);
module_exit(ide_gd_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");
Commit	Line	Data
5fef0e5c BZ	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>
b0aedb04	10	#include <linux/dmi.h>
5a0e3ad6	11	#include <linux/slab.h>
5fef0e5c BZ	12
	13	#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
	14	#define IDE_DISK_MINORS (1 << PARTN_BITS)
	15	#else
	16	#define IDE_DISK_MINORS 0
	17	#endif
	18
	19	#include "ide-disk.h"
806f80a6	20	#include "ide-floppy.h"
5fef0e5c BZ	21
	22	#define IDE_GD_VERSION "1.18"
	23
806f80a6 BZ	24	/* module parameters */
	25	static unsigned long debug_mask;
	26	module_param(debug_mask, ulong, 0644);
	27
5fef0e5c BZ	28	static DEFINE_MUTEX(ide_disk_ref_mutex);
5fef0e5c BZ	29
8fed4368	30	static void ide_disk_release(struct device *);
5fef0e5c BZ	31
	32	static struct ide_disk_obj ide_disk_get(struct gendisk disk)
	33	{
	34	struct ide_disk_obj *idkp = NULL;
	35
	36	mutex_lock(&ide_disk_ref_mutex);
	37	idkp = ide_drv_g(disk, ide_disk_obj);
	38	if (idkp) {
	39	if (ide_device_get(idkp->drive))
	40	idkp = NULL;
	41	else
8fed4368	42	get_device(&idkp->dev);
5fef0e5c BZ	43	}
	44	mutex_unlock(&ide_disk_ref_mutex);
	45	return idkp;
	46	}
	47
	48	static void ide_disk_put(struct ide_disk_obj *idkp)
	49	{
	50	ide_drive_t *drive = idkp->drive;
	51
	52	mutex_lock(&ide_disk_ref_mutex);
8fed4368	53	put_device(&idkp->dev);
5fef0e5c BZ	54	ide_device_put(drive);
	55	mutex_unlock(&ide_disk_ref_mutex);
	56	}
	57
	58	sector_t ide_gd_capacity(ide_drive_t *drive)
	59	{
	60	return drive->capacity64;
	61	}
	62
	63	static int ide_gd_probe(ide_drive_t *);
	64
	65	static void ide_gd_remove(ide_drive_t *drive)
	66	{
	67	struct ide_disk_obj *idkp = drive->driver_data;
	68	struct gendisk *g = idkp->disk;
	69
	70	ide_proc_unregister_driver(drive, idkp->driver);
8fed4368	71	device_del(&idkp->dev);
5fef0e5c	72	del_gendisk(g);
806f80a6	73	drive->disk_ops->flush(drive);
5fef0e5c	74
8fed4368 BZ	75	mutex_lock(&ide_disk_ref_mutex);
	76	put_device(&idkp->dev);
	77	mutex_unlock(&ide_disk_ref_mutex);
5fef0e5c BZ	78	}
5fef0e5c BZ	79
8fed4368	80	static void ide_disk_release(struct device *dev)
5fef0e5c	81	{
8fed4368	82	struct ide_disk_obj *idkp = to_ide_drv(dev, ide_disk_obj);
5fef0e5c BZ	83	ide_drive_t *drive = idkp->drive;
	84	struct gendisk *g = idkp->disk;
	85
806f80a6	86	drive->disk_ops = NULL;
5fef0e5c BZ	87	drive->driver_data = NULL;
	88	g->private_data = NULL;
	89	put_disk(g);
	90	kfree(idkp);
	91	}
	92
	93	/*
	94	* On HPA drives the capacity needs to be
	95	* reinitilized on resume otherwise the disk
	96	* can not be used and a hard reset is required
	97	*/
	98	static void ide_gd_resume(ide_drive_t *drive)
	99	{
	100	if (ata_id_hpa_enabled(drive->id))
806f80a6	101	(void)drive->disk_ops->get_capacity(drive);
5fef0e5c BZ	102	}
5fef0e5c BZ	103
b0aedb04 BP	104	static const struct dmi_system_id ide_coldreboot_table[] = {
	105	{
	106	/* Acer TravelMate 66x cuts power during reboot */
	107	.ident = "Acer TravelMate 660",
	108	.matches = {
	109	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
	110	DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 660"),
	111	},
	112	},
	113
	114	{ } /* terminate list */
	115	};
	116
5fef0e5c BZ	117	static void ide_gd_shutdown(ide_drive_t *drive)
	118	{
	119	#ifdef CONFIG_ALPHA
	120	/* On Alpha, halt(8) doesn't actually turn the machine off,
	121	it puts you into the sort of firmware monitor. Typically,
	122	it's used to boot another kernel image, so it's not much
	123	different from reboot(8). Therefore, we don't need to
	124	spin down the disk in this case, especially since Alpha
	125	firmware doesn't handle disks in standby mode properly.
	126	On the other hand, it's reasonably safe to turn the power
	127	off when the shutdown process reaches the firmware prompt,
	128	as the firmware initialization takes rather long time -
	129	at least 10 seconds, which should be sufficient for
	130	the disk to expire its write cache. */
	131	if (system_state != SYSTEM_POWER_OFF) {
	132	#else
b0aedb04 BP	133	if (system_state == SYSTEM_RESTART &&
b0aedb04 BP	134	!dmi_check_system(ide_coldreboot_table)) {
5fef0e5c	135	#endif
806f80a6	136	drive->disk_ops->flush(drive);
5fef0e5c BZ	137	return;
	138	}
	139
	140	printk(KERN_INFO "Shutdown: %s\n", drive->name);
	141
	142	drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
	143	}
	144
79cb3803 BZ	145	#ifdef CONFIG_IDE_PROC_FS
	146	static ide_proc_entry_t ide_disk_proc_entries(ide_drive_t drive)
	147	{
806f80a6	148	return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
79cb3803 BZ	149	}
	150
	151	static const struct ide_proc_devset ide_disk_proc_devsets(ide_drive_t drive)
	152	{
806f80a6 BZ	153	return (drive->media == ide_disk) ? ide_disk_settings
806f80a6 BZ	154	: ide_floppy_settings;
79cb3803 BZ	155	}
	156	#endif
	157
806f80a6 BZ	158	static ide_startstop_t ide_gd_do_request(ide_drive_t *drive,
	159	struct request *rq, sector_t sector)
	160	{
	161	return drive->disk_ops->do_request(drive, rq, sector);
	162	}
	163
7f3c868b	164	static struct ide_driver ide_gd_driver = {
5fef0e5c BZ	165	.gen_driver = {
5fef0e5c BZ	166	.owner = THIS_MODULE,
806f80a6	167	.name = "ide-gd",
5fef0e5c BZ	168	.bus = &ide_bus_type,
	169	},
	170	.probe = ide_gd_probe,
	171	.remove = ide_gd_remove,
	172	.resume = ide_gd_resume,
	173	.shutdown = ide_gd_shutdown,
	174	.version = IDE_GD_VERSION,
806f80a6	175	.do_request = ide_gd_do_request,
5fef0e5c	176	#ifdef CONFIG_IDE_PROC_FS
79cb3803 BZ	177	.proc_entries = ide_disk_proc_entries,
79cb3803 BZ	178	.proc_devsets = ide_disk_proc_devsets,
5fef0e5c BZ	179	#endif
	180	};
	181
b2f21e05	182	static int ide_gd_open(struct block_device *bdev, fmode_t mode)
5fef0e5c	183	{
b2f21e05	184	struct gendisk *disk = bdev->bd_disk;
5fef0e5c BZ	185	struct ide_disk_obj *idkp;
5fef0e5c BZ	186	ide_drive_t *drive;
806f80a6	187	int ret = 0;
5fef0e5c BZ	188
	189	idkp = ide_disk_get(disk);
	190	if (idkp == NULL)
	191	return -ENXIO;
	192
	193	drive = idkp->drive;
	194
088b1b88	195	ide_debug_log(IDE_DBG_FUNC, "enter");
806f80a6	196
5fef0e5c BZ	197	idkp->openers++;
	198
	199	if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
806f80a6 BZ	200	drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
	201	/* Just in case */
	202
	203	ret = drive->disk_ops->init_media(drive, disk);
	204
	205	/*
	206	* Allow O_NDELAY to open a drive without a disk, or with an
	207	* unreadable disk, so that we can get the format capacity
	208	* of the drive or begin the format - Sam
	209	*/
b2f21e05	210	if (ret && (mode & FMODE_NDELAY) == 0) {
806f80a6 BZ	211	ret = -EIO;
	212	goto out_put_idkp;
	213	}
	214
b2f21e05	215	if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) {
806f80a6 BZ	216	ret = -EROFS;
	217	goto out_put_idkp;
	218	}
	219
5fef0e5c BZ	220	/*
	221	* Ignore the return code from door_lock,
	222	* since the open() has already succeeded,
	223	* and the door_lock is irrelevant at this point.
	224	*/
806f80a6	225	drive->disk_ops->set_doorlock(drive, disk, 1);
cedd120c	226	drive->dev_flags \|= IDE_DFLAG_MEDIA_CHANGED;
b2f21e05	227	check_disk_change(bdev);
806f80a6 BZ	228	} else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
	229	ret = -EBUSY;
	230	goto out_put_idkp;
5fef0e5c BZ	231	}
5fef0e5c BZ	232	return 0;
806f80a6 BZ	233
	234	out_put_idkp:
	235	idkp->openers--;
	236	ide_disk_put(idkp);
	237	return ret;
5fef0e5c BZ	238	}
5fef0e5c BZ	239
b2f21e05	240	static int ide_gd_release(struct gendisk *disk, fmode_t mode)
5fef0e5c	241	{
5fef0e5c BZ	242	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	243	ide_drive_t *drive = idkp->drive;
	244
088b1b88	245	ide_debug_log(IDE_DBG_FUNC, "enter");
806f80a6	246
5fef0e5c	247	if (idkp->openers == 1)
806f80a6	248	drive->disk_ops->flush(drive);
5fef0e5c	249
806f80a6 BZ	250	if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
	251	drive->disk_ops->set_doorlock(drive, disk, 0);
	252	drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
	253	}
5fef0e5c BZ	254
	255	idkp->openers--;
	256
	257	ide_disk_put(idkp);
	258
	259	return 0;
	260	}
	261
	262	static int ide_gd_getgeo(struct block_device bdev, struct hd_geometry geo)
	263	{
	264	struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
	265	ide_drive_t *drive = idkp->drive;
	266
	267	geo->heads = drive->bios_head;
	268	geo->sectors = drive->bios_sect;
	269	geo->cylinders = (u16)drive->bios_cyl; /* truncate */
	270	return 0;
	271	}
	272
	273	static int ide_gd_media_changed(struct gendisk *disk)
	274	{
	275	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	276	ide_drive_t *drive = idkp->drive;
cedd120c	277	int ret;
5fef0e5c BZ	278
	279	/* do not scan partitions twice if this is a removable device */
	280	if (drive->dev_flags & IDE_DFLAG_ATTACH) {
	281	drive->dev_flags &= ~IDE_DFLAG_ATTACH;
	282	return 0;
	283	}
	284
cedd120c BZ	285	ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
	286	drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
	287
	288	return ret;
5fef0e5c BZ	289	}
5fef0e5c BZ	290
c3e33e04	291	static void ide_gd_unlock_native_capacity(struct gendisk *disk)
e957b60d BZ	292	{
	293	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	294	ide_drive_t *drive = idkp->drive;
	295	const struct ide_disk_ops *disk_ops = drive->disk_ops;
	296
c3e33e04 TH	297	if (disk_ops->unlock_native_capacity)
c3e33e04 TH	298	disk_ops->unlock_native_capacity(drive);
e957b60d BZ	299	}
e957b60d BZ	300
5fef0e5c BZ	301	static int ide_gd_revalidate_disk(struct gendisk *disk)
	302	{
	303	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
52ebb438 BP	304	ide_drive_t *drive = idkp->drive;
	305
	306	if (ide_gd_media_changed(disk))
	307	drive->disk_ops->get_capacity(drive);
	308
	309	set_capacity(disk, ide_gd_capacity(drive));
5fef0e5c BZ	310	return 0;
	311	}
	312
b2f21e05	313	static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
806f80a6 BZ	314	unsigned int cmd, unsigned long arg)
806f80a6 BZ	315	{
806f80a6 BZ	316	struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
	317	ide_drive_t *drive = idkp->drive;
	318
b2f21e05	319	return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
806f80a6 BZ	320	}
806f80a6 BZ	321
83d5cde4	322	static const struct block_device_operations ide_gd_ops = {
5fef0e5c	323	.owner = THIS_MODULE,
b2f21e05 AV	324	.open = ide_gd_open,
	325	.release = ide_gd_release,
	326	.locked_ioctl = ide_gd_ioctl,
5fef0e5c BZ	327	.getgeo = ide_gd_getgeo,
5fef0e5c BZ	328	.media_changed = ide_gd_media_changed,
c3e33e04	329	.unlock_native_capacity = ide_gd_unlock_native_capacity,
5fef0e5c BZ	330	.revalidate_disk = ide_gd_revalidate_disk
	331	};
	332
	333	static int ide_gd_probe(ide_drive_t *drive)
	334	{
806f80a6	335	const struct ide_disk_ops *disk_ops = NULL;
5fef0e5c BZ	336	struct ide_disk_obj *idkp;
	337	struct gendisk *g;
	338
	339	/* strstr("foo", "") is non-NULL */
806f80a6 BZ	340	if (!strstr("ide-gd", drive->driver_req))
	341	goto failed;
	342
	343	#ifdef CONFIG_IDE_GD_ATA
	344	if (drive->media == ide_disk)
	345	disk_ops = &ide_ata_disk_ops;
	346	#endif
	347	#ifdef CONFIG_IDE_GD_ATAPI
	348	if (drive->media == ide_floppy)
	349	disk_ops = &ide_atapi_disk_ops;
	350	#endif
	351	if (disk_ops == NULL)
5fef0e5c BZ	352	goto failed;
5fef0e5c BZ	353
806f80a6 BZ	354	if (disk_ops->check(drive, DRV_NAME) == 0) {
	355	printk(KERN_ERR PFX "%s: not supported by this driver\n",
	356	drive->name);
5fef0e5c	357	goto failed;
806f80a6	358	}
5fef0e5c BZ	359
5fef0e5c BZ	360	idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
806f80a6 BZ	361	if (!idkp) {
	362	printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
	363	drive->name);
5fef0e5c	364	goto failed;
806f80a6	365	}
5fef0e5c BZ	366
	367	g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
	368	if (!g)
	369	goto out_free_idkp;
	370
	371	ide_init_disk(g, drive);
	372
8fed4368 BZ	373	idkp->dev.parent = &drive->gendev;
	374	idkp->dev.release = ide_disk_release;
	375	dev_set_name(&idkp->dev, dev_name(&drive->gendev));
	376
	377	if (device_register(&idkp->dev))
	378	goto out_free_disk;
5fef0e5c BZ	379
	380	idkp->drive = drive;
	381	idkp->driver = &ide_gd_driver;
	382	idkp->disk = g;
	383
	384	g->private_data = &idkp->driver;
	385
	386	drive->driver_data = idkp;
806f80a6 BZ	387	drive->debug_mask = debug_mask;
806f80a6 BZ	388	drive->disk_ops = disk_ops;
5fef0e5c	389
806f80a6	390	disk_ops->setup(drive);
5fef0e5c BZ	391
	392	set_capacity(g, ide_gd_capacity(drive));
	393
	394	g->minors = IDE_DISK_MINORS;
	395	g->driverfs_dev = &drive->gendev;
	396	g->flags \|= GENHD_FL_EXT_DEVT;
	397	if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
	398	g->flags = GENHD_FL_REMOVABLE;
	399	g->fops = &ide_gd_ops;
	400	add_disk(g);
	401	return 0;
	402
8fed4368 BZ	403	out_free_disk:
8fed4368 BZ	404	put_disk(g);
5fef0e5c BZ	405	out_free_idkp:
	406	kfree(idkp);
	407	failed:
	408	return -ENODEV;
	409	}
	410
	411	static int __init ide_gd_init(void)
	412	{
806f80a6	413	printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
5fef0e5c BZ	414	return driver_register(&ide_gd_driver.gen_driver);
	415	}
	416
	417	static void __exit ide_gd_exit(void)
	418	{
	419	driver_unregister(&ide_gd_driver.gen_driver);
	420	}
	421
	422	MODULE_ALIAS("ide:m-disk");
	423	MODULE_ALIAS("ide-disk");
806f80a6 BZ	424	MODULE_ALIAS("ide:m-floppy");
806f80a6 BZ	425	MODULE_ALIAS("ide-floppy");
5fef0e5c BZ	426	module_init(ide_gd_init);
	427	module_exit(ide_gd_exit);
	428	MODULE_LICENSE("GPL");
806f80a6	429	MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");