[GitHub/mt8127/android_kernel_alcatel_ttab.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 unsigned long long ide_gd_set_capacity(struct gendisk *disk,
					      unsigned long long capacity)
{
	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->set_capacity)
		return disk_ops->set_capacity(drive, capacity);

	return drive->capacity64;
}

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,
	.set_capacity		= ide_gd_set_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
e957b60d BZ	291	static unsigned long long ide_gd_set_capacity(struct gendisk *disk,
	292	unsigned long long capacity)
	293	{
	294	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	295	ide_drive_t *drive = idkp->drive;
	296	const struct ide_disk_ops *disk_ops = drive->disk_ops;
	297
	298	if (disk_ops->set_capacity)
	299	return disk_ops->set_capacity(drive, capacity);
	300
	301	return drive->capacity64;
	302	}
	303
5fef0e5c BZ	304	static int ide_gd_revalidate_disk(struct gendisk *disk)
	305	{
	306	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
52ebb438 BP	307	ide_drive_t *drive = idkp->drive;
	308
	309	if (ide_gd_media_changed(disk))
	310	drive->disk_ops->get_capacity(drive);
	311
	312	set_capacity(disk, ide_gd_capacity(drive));
5fef0e5c BZ	313	return 0;
	314	}
	315
b2f21e05	316	static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
806f80a6 BZ	317	unsigned int cmd, unsigned long arg)
806f80a6 BZ	318	{
806f80a6 BZ	319	struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
	320	ide_drive_t *drive = idkp->drive;
	321
b2f21e05	322	return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
806f80a6 BZ	323	}
806f80a6 BZ	324
83d5cde4	325	static const struct block_device_operations ide_gd_ops = {
5fef0e5c	326	.owner = THIS_MODULE,
b2f21e05 AV	327	.open = ide_gd_open,
	328	.release = ide_gd_release,
	329	.locked_ioctl = ide_gd_ioctl,
5fef0e5c BZ	330	.getgeo = ide_gd_getgeo,
5fef0e5c BZ	331	.media_changed = ide_gd_media_changed,
e957b60d	332	.set_capacity = ide_gd_set_capacity,
5fef0e5c BZ	333	.revalidate_disk = ide_gd_revalidate_disk
	334	};
	335
	336	static int ide_gd_probe(ide_drive_t *drive)
	337	{
806f80a6	338	const struct ide_disk_ops *disk_ops = NULL;
5fef0e5c BZ	339	struct ide_disk_obj *idkp;
	340	struct gendisk *g;
	341
	342	/* strstr("foo", "") is non-NULL */
806f80a6 BZ	343	if (!strstr("ide-gd", drive->driver_req))
	344	goto failed;
	345
	346	#ifdef CONFIG_IDE_GD_ATA
	347	if (drive->media == ide_disk)
	348	disk_ops = &ide_ata_disk_ops;
	349	#endif
	350	#ifdef CONFIG_IDE_GD_ATAPI
	351	if (drive->media == ide_floppy)
	352	disk_ops = &ide_atapi_disk_ops;
	353	#endif
	354	if (disk_ops == NULL)
5fef0e5c BZ	355	goto failed;
5fef0e5c BZ	356
806f80a6 BZ	357	if (disk_ops->check(drive, DRV_NAME) == 0) {
	358	printk(KERN_ERR PFX "%s: not supported by this driver\n",
	359	drive->name);
5fef0e5c	360	goto failed;
806f80a6	361	}
5fef0e5c BZ	362
5fef0e5c BZ	363	idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
806f80a6 BZ	364	if (!idkp) {
	365	printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
	366	drive->name);
5fef0e5c	367	goto failed;
806f80a6	368	}
5fef0e5c BZ	369
	370	g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
	371	if (!g)
	372	goto out_free_idkp;
	373
	374	ide_init_disk(g, drive);
	375
8fed4368 BZ	376	idkp->dev.parent = &drive->gendev;
	377	idkp->dev.release = ide_disk_release;
	378	dev_set_name(&idkp->dev, dev_name(&drive->gendev));
	379
	380	if (device_register(&idkp->dev))
	381	goto out_free_disk;
5fef0e5c BZ	382
	383	idkp->drive = drive;
	384	idkp->driver = &ide_gd_driver;
	385	idkp->disk = g;
	386
	387	g->private_data = &idkp->driver;
	388
	389	drive->driver_data = idkp;
806f80a6 BZ	390	drive->debug_mask = debug_mask;
806f80a6 BZ	391	drive->disk_ops = disk_ops;
5fef0e5c	392
806f80a6	393	disk_ops->setup(drive);
5fef0e5c BZ	394
	395	set_capacity(g, ide_gd_capacity(drive));
	396
	397	g->minors = IDE_DISK_MINORS;
	398	g->driverfs_dev = &drive->gendev;
	399	g->flags \|= GENHD_FL_EXT_DEVT;
	400	if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
	401	g->flags = GENHD_FL_REMOVABLE;
	402	g->fops = &ide_gd_ops;
	403	add_disk(g);
	404	return 0;
	405
8fed4368 BZ	406	out_free_disk:
8fed4368 BZ	407	put_disk(g);
5fef0e5c BZ	408	out_free_idkp:
	409	kfree(idkp);
	410	failed:
	411	return -ENODEV;
	412	}
	413
	414	static int __init ide_gd_init(void)
	415	{
806f80a6	416	printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
5fef0e5c BZ	417	return driver_register(&ide_gd_driver.gen_driver);
	418	}
	419
	420	static void __exit ide_gd_exit(void)
	421	{
	422	driver_unregister(&ide_gd_driver.gen_driver);
	423	}
	424
	425	MODULE_ALIAS("ide:m-disk");
	426	MODULE_ALIAS("ide-disk");
806f80a6 BZ	427	MODULE_ALIAS("ide:m-floppy");
806f80a6 BZ	428	MODULE_ALIAS("ide-floppy");
5fef0e5c BZ	429	module_init(ide_gd_init);
	430	module_exit(ide_gd_exit);
	431	MODULE_LICENSE("GPL");
806f80a6	432	MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");