ide-gd.c 9.47 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
#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>

#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"
18
#include "ide-floppy.h"
19 20 21

#define IDE_GD_VERSION	"1.18"

22 23 24 25
/* module parameters */
static unsigned long debug_mask;
module_param(debug_mask, ulong, 0644);

26 27
static DEFINE_MUTEX(ide_disk_ref_mutex);

28
static void ide_disk_release(struct device *);
29 30 31 32 33 34 35 36 37 38 39

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
40
			get_device(&idkp->dev);
41 42 43 44 45 46 47 48 49 50
	}
	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);
51
	put_device(&idkp->dev);
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
	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);
69
	device_del(&idkp->dev);
70
	del_gendisk(g);
71
	drive->disk_ops->flush(drive);
72

73 74 75
	mutex_lock(&ide_disk_ref_mutex);
	put_device(&idkp->dev);
	mutex_unlock(&ide_disk_ref_mutex);
76 77
}

78
static void ide_disk_release(struct device *dev)
79
{
80
	struct ide_disk_obj *idkp = to_ide_drv(dev, ide_disk_obj);
81 82 83
	ide_drive_t *drive = idkp->drive;
	struct gendisk *g = idkp->disk;

84
	drive->disk_ops = NULL;
85 86 87 88 89 90 91 92 93 94 95 96 97 98
	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))
99
		(void)drive->disk_ops->get_capacity(drive);
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
}

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) {
#endif
120
		drive->disk_ops->flush(drive);
121 122 123 124 125 126 127 128
		return;
	}

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

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

129 130 131
#ifdef CONFIG_IDE_PROC_FS
static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
{
132
	return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
133 134 135 136
}

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

142 143 144 145 146 147
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);
}

148
static struct ide_driver ide_gd_driver = {
149 150
	.gen_driver = {
		.owner		= THIS_MODULE,
151
		.name		= "ide-gd",
152 153 154 155 156 157 158
		.bus		= &ide_bus_type,
	},
	.probe			= ide_gd_probe,
	.remove			= ide_gd_remove,
	.resume			= ide_gd_resume,
	.shutdown		= ide_gd_shutdown,
	.version		= IDE_GD_VERSION,
159
	.do_request		= ide_gd_do_request,
160
#ifdef CONFIG_IDE_PROC_FS
161 162
	.proc_entries		= ide_disk_proc_entries,
	.proc_devsets		= ide_disk_proc_devsets,
163 164 165
#endif
};

Al Viro's avatar
Al Viro committed
166
static int ide_gd_open(struct block_device *bdev, fmode_t mode)
167
{
Al Viro's avatar
Al Viro committed
168
	struct gendisk *disk = bdev->bd_disk;
169 170
	struct ide_disk_obj *idkp;
	ide_drive_t *drive;
171
	int ret = 0;
172 173 174 175 176 177 178

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

	drive = idkp->drive;

179
	ide_debug_log(IDE_DBG_FUNC, "enter");
180

181 182 183
	idkp->openers++;

	if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
184 185 186 187 188 189 190 191 192 193
		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
		 */
Al Viro's avatar
Al Viro committed
194
		if (ret && (mode & FMODE_NDELAY) == 0) {
195 196 197 198
			ret = -EIO;
			goto out_put_idkp;
		}

Al Viro's avatar
Al Viro committed
199
		if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) {
200 201 202 203
			ret = -EROFS;
			goto out_put_idkp;
		}

204 205 206 207 208
		/*
		 * Ignore the return code from door_lock,
		 * since the open() has already succeeded,
		 * and the door_lock is irrelevant at this point.
		 */
209
		drive->disk_ops->set_doorlock(drive, disk, 1);
210
		drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
Al Viro's avatar
Al Viro committed
211
		check_disk_change(bdev);
212 213 214
	} else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
		ret = -EBUSY;
		goto out_put_idkp;
215 216
	}
	return 0;
217 218 219 220 221

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

Al Viro's avatar
Al Viro committed
224
static int ide_gd_release(struct gendisk *disk, fmode_t mode)
225 226 227 228
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;

229
	ide_debug_log(IDE_DBG_FUNC, "enter");
230

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

234 235 236 237
	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;
	}
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260

	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;
261
	int ret;
262 263 264 265 266 267 268

	/* 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;
	}

269 270 271 272
	ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
	drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;

	return ret;
273 274 275 276 277
}

static int ide_gd_revalidate_disk(struct gendisk *disk)
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
278 279 280 281 282 283
	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));
284 285 286
	return 0;
}

Al Viro's avatar
Al Viro committed
287
static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
288 289 290 291 292
			     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;

Al Viro's avatar
Al Viro committed
293
	return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
294 295
}

296 297
static struct block_device_operations ide_gd_ops = {
	.owner			= THIS_MODULE,
Al Viro's avatar
Al Viro committed
298 299 300
	.open			= ide_gd_open,
	.release		= ide_gd_release,
	.locked_ioctl		= ide_gd_ioctl,
301 302 303 304 305 306 307
	.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)
{
308
	const struct ide_disk_ops *disk_ops = NULL;
309 310 311 312
	struct ide_disk_obj *idkp;
	struct gendisk *g;

	/* strstr("foo", "") is non-NULL */
313 314 315 316 317 318 319 320 321 322 323 324
	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)
325 326
		goto failed;

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

	idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
334 335 336
	if (!idkp) {
		printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
			drive->name);
337
		goto failed;
338
	}
339 340 341 342 343 344 345

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

	ide_init_disk(g, drive);

346 347 348 349 350 351
	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;
352 353 354 355 356 357 358 359

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

	g->private_data = &idkp->driver;

	drive->driver_data = idkp;
360 361
	drive->debug_mask = debug_mask;
	drive->disk_ops = disk_ops;
362

363
	disk_ops->setup(drive);
364 365 366 367 368 369 370 371 372 373 374 375

	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;

376 377
out_free_disk:
	put_disk(g);
378 379 380 381 382 383 384 385
out_free_idkp:
	kfree(idkp);
failed:
	return -ENODEV;
}

static int __init ide_gd_init(void)
{
386
	printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
387 388 389 390 391 392 393 394 395 396
	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");
397 398
MODULE_ALIAS("ide:*m-floppy*");
MODULE_ALIAS("ide-floppy");
399 400 401
module_init(ide_gd_init);
module_exit(ide_gd_exit);
MODULE_LICENSE("GPL");
402
MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");