c84d9bbe7c
While at it: - idefloppy_do_request() -> ide_floppy_do_request() - idefloppy_end_request() -> ide_floppy_end_request() - idefloppy_setup() -> ide_floppy_setup() There should be no functional changes caused by this patch. Acked-by: Borislav Petkov <petkovbb@gmail.com> Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
299 lines
6.8 KiB
C
299 lines
6.8 KiB
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 "ide-floppy.h"
|
|
|
|
#define IDEFLOPPY_VERSION "1.00"
|
|
|
|
/* module parameters */
|
|
static unsigned long debug_mask;
|
|
module_param(debug_mask, ulong, 0644);
|
|
|
|
static DEFINE_MUTEX(idefloppy_ref_mutex);
|
|
|
|
static void idefloppy_cleanup_obj(struct kref *);
|
|
|
|
static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk)
|
|
{
|
|
struct ide_floppy_obj *floppy = NULL;
|
|
|
|
mutex_lock(&idefloppy_ref_mutex);
|
|
floppy = ide_drv_g(disk, ide_floppy_obj);
|
|
if (floppy) {
|
|
if (ide_device_get(floppy->drive))
|
|
floppy = NULL;
|
|
else
|
|
kref_get(&floppy->kref);
|
|
}
|
|
mutex_unlock(&idefloppy_ref_mutex);
|
|
return floppy;
|
|
}
|
|
|
|
static void ide_floppy_put(struct ide_floppy_obj *floppy)
|
|
{
|
|
ide_drive_t *drive = floppy->drive;
|
|
|
|
mutex_lock(&idefloppy_ref_mutex);
|
|
kref_put(&floppy->kref, idefloppy_cleanup_obj);
|
|
ide_device_put(drive);
|
|
mutex_unlock(&idefloppy_ref_mutex);
|
|
}
|
|
|
|
sector_t ide_floppy_capacity(ide_drive_t *drive)
|
|
{
|
|
return drive->capacity64;
|
|
}
|
|
|
|
static void ide_floppy_remove(ide_drive_t *drive)
|
|
{
|
|
idefloppy_floppy_t *floppy = drive->driver_data;
|
|
struct gendisk *g = floppy->disk;
|
|
|
|
ide_proc_unregister_driver(drive, floppy->driver);
|
|
|
|
del_gendisk(g);
|
|
|
|
ide_floppy_put(floppy);
|
|
}
|
|
|
|
static void idefloppy_cleanup_obj(struct kref *kref)
|
|
{
|
|
struct ide_floppy_obj *floppy = to_ide_drv(kref, ide_floppy_obj);
|
|
ide_drive_t *drive = floppy->drive;
|
|
struct gendisk *g = floppy->disk;
|
|
|
|
drive->driver_data = NULL;
|
|
g->private_data = NULL;
|
|
put_disk(g);
|
|
kfree(floppy);
|
|
}
|
|
|
|
static int ide_floppy_probe(ide_drive_t *);
|
|
|
|
static ide_driver_t idefloppy_driver = {
|
|
.gen_driver = {
|
|
.owner = THIS_MODULE,
|
|
.name = "ide-floppy",
|
|
.bus = &ide_bus_type,
|
|
},
|
|
.probe = ide_floppy_probe,
|
|
.remove = ide_floppy_remove,
|
|
.version = IDEFLOPPY_VERSION,
|
|
.do_request = ide_floppy_do_request,
|
|
.end_request = ide_floppy_end_request,
|
|
.error = __ide_error,
|
|
#ifdef CONFIG_IDE_PROC_FS
|
|
.proc = ide_floppy_proc,
|
|
.settings = ide_floppy_settings,
|
|
#endif
|
|
};
|
|
|
|
static int idefloppy_open(struct inode *inode, struct file *filp)
|
|
{
|
|
struct gendisk *disk = inode->i_bdev->bd_disk;
|
|
struct ide_floppy_obj *floppy;
|
|
ide_drive_t *drive;
|
|
int ret = 0;
|
|
|
|
floppy = ide_floppy_get(disk);
|
|
if (!floppy)
|
|
return -ENXIO;
|
|
|
|
drive = floppy->drive;
|
|
|
|
ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
|
|
|
|
floppy->openers++;
|
|
|
|
if (floppy->openers == 1) {
|
|
drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
|
|
/* Just in case */
|
|
|
|
if (ide_do_test_unit_ready(drive, disk))
|
|
ide_do_start_stop(drive, disk, 1);
|
|
|
|
ret = ide_floppy_get_capacity(drive);
|
|
|
|
set_capacity(disk, ide_floppy_capacity(drive));
|
|
|
|
if (ret && (filp->f_flags & O_NDELAY) == 0) {
|
|
/*
|
|
* 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
|
|
*/
|
|
ret = -EIO;
|
|
goto out_put_floppy;
|
|
}
|
|
|
|
if ((drive->dev_flags & IDE_DFLAG_WP) && (filp->f_mode & 2)) {
|
|
ret = -EROFS;
|
|
goto out_put_floppy;
|
|
}
|
|
|
|
ide_set_media_lock(drive, disk, 1);
|
|
drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
|
|
check_disk_change(inode->i_bdev);
|
|
} else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
|
|
ret = -EBUSY;
|
|
goto out_put_floppy;
|
|
}
|
|
return 0;
|
|
|
|
out_put_floppy:
|
|
floppy->openers--;
|
|
ide_floppy_put(floppy);
|
|
return ret;
|
|
}
|
|
|
|
static int idefloppy_release(struct inode *inode, struct file *filp)
|
|
{
|
|
struct gendisk *disk = inode->i_bdev->bd_disk;
|
|
struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
|
|
ide_drive_t *drive = floppy->drive;
|
|
|
|
ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
|
|
|
|
if (floppy->openers == 1) {
|
|
ide_set_media_lock(drive, disk, 0);
|
|
drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
|
|
}
|
|
|
|
floppy->openers--;
|
|
|
|
ide_floppy_put(floppy);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
|
{
|
|
struct ide_floppy_obj *floppy = ide_drv_g(bdev->bd_disk,
|
|
ide_floppy_obj);
|
|
ide_drive_t *drive = floppy->drive;
|
|
|
|
geo->heads = drive->bios_head;
|
|
geo->sectors = drive->bios_sect;
|
|
geo->cylinders = (u16)drive->bios_cyl; /* truncate */
|
|
return 0;
|
|
}
|
|
|
|
static int idefloppy_media_changed(struct gendisk *disk)
|
|
{
|
|
struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
|
|
ide_drive_t *drive = floppy->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 idefloppy_revalidate_disk(struct gendisk *disk)
|
|
{
|
|
struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
|
|
set_capacity(disk, ide_floppy_capacity(floppy->drive));
|
|
return 0;
|
|
}
|
|
|
|
static struct block_device_operations idefloppy_ops = {
|
|
.owner = THIS_MODULE,
|
|
.open = idefloppy_open,
|
|
.release = idefloppy_release,
|
|
.ioctl = ide_floppy_ioctl,
|
|
.getgeo = idefloppy_getgeo,
|
|
.media_changed = idefloppy_media_changed,
|
|
.revalidate_disk = idefloppy_revalidate_disk
|
|
};
|
|
|
|
static int ide_floppy_probe(ide_drive_t *drive)
|
|
{
|
|
idefloppy_floppy_t *floppy;
|
|
struct gendisk *g;
|
|
|
|
if (!strstr("ide-floppy", drive->driver_req))
|
|
goto failed;
|
|
|
|
if (drive->media != ide_floppy)
|
|
goto failed;
|
|
|
|
if (!ide_check_atapi_device(drive, DRV_NAME)) {
|
|
printk(KERN_ERR PFX "%s: not supported by this version of "
|
|
DRV_NAME "\n", drive->name);
|
|
goto failed;
|
|
}
|
|
floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL);
|
|
if (!floppy) {
|
|
printk(KERN_ERR PFX "%s: Can't allocate a floppy structure\n",
|
|
drive->name);
|
|
goto failed;
|
|
}
|
|
|
|
g = alloc_disk_node(1 << PARTN_BITS, hwif_to_node(drive->hwif));
|
|
if (!g)
|
|
goto out_free_floppy;
|
|
|
|
ide_init_disk(g, drive);
|
|
|
|
kref_init(&floppy->kref);
|
|
|
|
floppy->drive = drive;
|
|
floppy->driver = &idefloppy_driver;
|
|
floppy->disk = g;
|
|
|
|
g->private_data = &floppy->driver;
|
|
|
|
drive->driver_data = floppy;
|
|
|
|
drive->debug_mask = debug_mask;
|
|
|
|
ide_floppy_setup(drive);
|
|
|
|
set_capacity(g, ide_floppy_capacity(drive));
|
|
|
|
g->minors = 1 << PARTN_BITS;
|
|
g->driverfs_dev = &drive->gendev;
|
|
if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
|
|
g->flags = GENHD_FL_REMOVABLE;
|
|
g->fops = &idefloppy_ops;
|
|
add_disk(g);
|
|
return 0;
|
|
|
|
out_free_floppy:
|
|
kfree(floppy);
|
|
failed:
|
|
return -ENODEV;
|
|
}
|
|
|
|
static int __init idefloppy_init(void)
|
|
{
|
|
printk(KERN_INFO DRV_NAME " driver " IDEFLOPPY_VERSION "\n");
|
|
return driver_register(&idefloppy_driver.gen_driver);
|
|
}
|
|
|
|
static void __exit idefloppy_exit(void)
|
|
{
|
|
driver_unregister(&idefloppy_driver.gen_driver);
|
|
}
|
|
|
|
MODULE_ALIAS("ide:*m-floppy*");
|
|
MODULE_ALIAS("ide-floppy");
|
|
module_init(idefloppy_init);
|
|
module_exit(idefloppy_exit);
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
|