[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>

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