ide-gd.c 10.3 KB
Newer Older
1 2 3 4 5 6 7 8 9
#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>
10
#include <linux/dmi.h>
11
#include <linux/slab.h>
12 13 14 15 16 17 18 19

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

#define IDE_GD_VERSION	"1.18"

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

28 29
static DEFINE_MUTEX(ide_disk_ref_mutex);

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

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

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

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

86
	drive->disk_ops = NULL;
87 88 89 90 91 92 93 94 95 96 97 98 99 100
	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))
101
		(void)drive->disk_ops->get_capacity(drive);
102 103
}

104 105 106 107 108 109 110 111 112 113 114 115 116
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 */
};

117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
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
133 134
	if (system_state == SYSTEM_RESTART &&
		!dmi_check_system(ide_coldreboot_table)) {
135
#endif
136
		drive->disk_ops->flush(drive);
137 138 139 140 141 142 143 144
		return;
	}

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

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

145 146 147
#ifdef CONFIG_IDE_PROC_FS
static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
{
148
	return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
149 150 151 152
}

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

158 159 160 161 162 163
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);
}

164
static struct ide_driver ide_gd_driver = {
165 166
	.gen_driver = {
		.owner		= THIS_MODULE,
167
		.name		= "ide-gd",
168 169 170 171 172 173 174
		.bus		= &ide_bus_type,
	},
	.probe			= ide_gd_probe,
	.remove			= ide_gd_remove,
	.resume			= ide_gd_resume,
	.shutdown		= ide_gd_shutdown,
	.version		= IDE_GD_VERSION,
175
	.do_request		= ide_gd_do_request,
176
#ifdef CONFIG_IDE_PROC_FS
177 178
	.proc_entries		= ide_disk_proc_entries,
	.proc_devsets		= ide_disk_proc_devsets,
179 180 181
#endif
};

Al Viro's avatar
Al Viro committed
182
static int ide_gd_open(struct block_device *bdev, fmode_t mode)
183
{
Al Viro's avatar
Al Viro committed
184
	struct gendisk *disk = bdev->bd_disk;
185 186
	struct ide_disk_obj *idkp;
	ide_drive_t *drive;
187
	int ret = 0;
188 189 190 191 192 193 194

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

	drive = idkp->drive;

195
	ide_debug_log(IDE_DBG_FUNC, "enter");
196

197 198 199
	idkp->openers++;

	if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
200 201 202 203 204 205 206 207 208 209
		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
210
		if (ret && (mode & FMODE_NDELAY) == 0) {
211 212 213 214
			ret = -EIO;
			goto out_put_idkp;
		}

Al Viro's avatar
Al Viro committed
215
		if ((drive->dev_flags & IDE_DFLAG_WP) && (mode & FMODE_WRITE)) {
216 217 218 219
			ret = -EROFS;
			goto out_put_idkp;
		}

220 221 222 223 224
		/*
		 * Ignore the return code from door_lock,
		 * since the open() has already succeeded,
		 * and the door_lock is irrelevant at this point.
		 */
225
		drive->disk_ops->set_doorlock(drive, disk, 1);
226
		drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
Al Viro's avatar
Al Viro committed
227
		check_disk_change(bdev);
228 229 230
	} else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
		ret = -EBUSY;
		goto out_put_idkp;
231 232
	}
	return 0;
233 234 235 236 237

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

Al Viro's avatar
Al Viro committed
240
static int ide_gd_release(struct gendisk *disk, fmode_t mode)
241 242 243 244
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
	ide_drive_t *drive = idkp->drive;

245
	ide_debug_log(IDE_DBG_FUNC, "enter");
246

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

250 251 252 253
	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;
	}
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276

	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;
277
	int ret;
278 279 280 281 282 283 284

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

285 286 287 288
	ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
	drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;

	return ret;
289 290
}

291 292 293 294 295 296 297 298 299 300 301 302 303
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;
}

304 305 306
static int ide_gd_revalidate_disk(struct gendisk *disk)
{
	struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
307 308 309 310 311 312
	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));
313 314 315
	return 0;
}

Al Viro's avatar
Al Viro committed
316
static int ide_gd_ioctl(struct block_device *bdev, fmode_t mode,
317 318 319 320 321
			     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
322
	return drive->disk_ops->ioctl(drive, bdev, mode, cmd, arg);
323 324
}

325
static const struct block_device_operations ide_gd_ops = {
326
	.owner			= THIS_MODULE,
Al Viro's avatar
Al Viro committed
327 328 329
	.open			= ide_gd_open,
	.release		= ide_gd_release,
	.locked_ioctl		= ide_gd_ioctl,
330 331
	.getgeo			= ide_gd_getgeo,
	.media_changed		= ide_gd_media_changed,
332
	.set_capacity		= ide_gd_set_capacity,
333 334 335 336 337
	.revalidate_disk	= ide_gd_revalidate_disk
};

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

	/* strstr("foo", "") is non-NULL */
343 344 345 346 347 348 349 350 351 352 353 354
	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)
355 356
		goto failed;

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

	idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
364 365 366
	if (!idkp) {
		printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
			drive->name);
367
		goto failed;
368
	}
369 370 371 372 373 374 375

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

	ide_init_disk(g, drive);

376 377 378 379 380 381
	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;
382 383 384 385 386 387 388 389

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

	g->private_data = &idkp->driver;

	drive->driver_data = idkp;
390 391
	drive->debug_mask = debug_mask;
	drive->disk_ops = disk_ops;
392

393
	disk_ops->setup(drive);
394 395 396 397 398 399 400 401 402 403 404 405

	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;

406 407
out_free_disk:
	put_disk(g);
408 409 410 411 412 413 414 415
out_free_idkp:
	kfree(idkp);
failed:
	return -ENODEV;
}

static int __init ide_gd_init(void)
{
416
	printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
417 418 419 420 421 422 423 424 425 426
	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");
427 428
MODULE_ALIAS("ide:*m-floppy*");
MODULE_ALIAS("ide-floppy");
429 430 431
module_init(ide_gd_init);
module_exit(ide_gd_exit);
MODULE_LICENSE("GPL");
432
MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");