LXR linux/drivers/s390/char/tape

   1/*
   2 * (C) Copyright IBM Corp. 2004
   3 * tape_class.c
   4 *
   5 * Tape class device support
   6 *
   7 * Author: Stefan Bader <shbader@de.ibm.com>
   8 * Based on simple class device code by Greg K-H
   9 */
  10
  11#define KMSG_COMPONENT "tape"
  12#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  13
  14#include <linux/slab.h>
  15
  16#include "tape_class.h"
  17
  18MODULE_AUTHOR("Stefan Bader <shbader@de.ibm.com>");
  19MODULE_DESCRIPTION(
  20        "(C) Copyright IBM Corp. 2004   All Rights Reserved.\n"
  21        "tape_class.c"
  22);
  23MODULE_LICENSE("GPL");
  24
  25static struct class *tape_class;
  26
  27/*
  28 * Register a tape device and return a pointer to the cdev structure.
  29 *
  30 * device
  31 *      The pointer to the struct device of the physical (base) device.
  32 * drivername
  33 *      The pointer to the drivers name for it's character devices.
  34 * dev
  35 *      The intended major/minor number. The major number may be 0 to
  36 *      get a dynamic major number.
  37 * fops
  38 *      The pointer to the drivers file operations for the tape device.
  39 * devname
  40 *      The pointer to the name of the character device.
  41 */
  42struct tape_class_device *register_tape_dev(
  43        struct device *         device,
  44        dev_t                   dev,
  45        const struct file_operations *fops,
  46        char *                  device_name,
  47        char *                  mode_name)
  48{
  49        struct tape_class_device *      tcd;
  50        int             rc;
  51        char *          s;
  52
  53        tcd = kzalloc(sizeof(struct tape_class_device), GFP_KERNEL);
  54        if (!tcd)
  55                return ERR_PTR(-ENOMEM);
  56
  57        strncpy(tcd->device_name, device_name, TAPECLASS_NAME_LEN);
  58        for (s = strchr(tcd->device_name, '/'); s; s = strchr(s, '/'))
  59                *s = '!';
  60        strncpy(tcd->mode_name, mode_name, TAPECLASS_NAME_LEN);
  61        for (s = strchr(tcd->mode_name, '/'); s; s = strchr(s, '/'))
  62                *s = '!';
  63
  64        tcd->char_device = cdev_alloc();
  65        if (!tcd->char_device) {
  66                rc = -ENOMEM;
  67                goto fail_with_tcd;
  68        }
  69
  70        tcd->char_device->owner = fops->owner;
  71        tcd->char_device->ops   = fops;
  72        tcd->char_device->dev   = dev;
  73
  74        rc = cdev_add(tcd->char_device, tcd->char_device->dev, 1);
  75        if (rc)
  76                goto fail_with_cdev;
  77
  78        tcd->class_device = device_create(tape_class, device,
  79                                          tcd->char_device->dev, NULL,
  80                                          "%s", tcd->device_name);
  81        rc = IS_ERR(tcd->class_device) ? PTR_ERR(tcd->class_device) : 0;
  82        if (rc)
  83                goto fail_with_cdev;
  84        rc = sysfs_create_link(
  85                &device->kobj,
  86                &tcd->class_device->kobj,
  87                tcd->mode_name
  88        );
  89        if (rc)
  90                goto fail_with_class_device;
  91
  92        return tcd;
  93
  94fail_with_class_device:
  95        device_destroy(tape_class, tcd->char_device->dev);
  96
  97fail_with_cdev:
  98        cdev_del(tcd->char_device);
  99
 100fail_with_tcd:
 101        kfree(tcd);
 102
 103        return ERR_PTR(rc);
 104}
 105EXPORT_SYMBOL(register_tape_dev);
 106
 107void unregister_tape_dev(struct device *device, struct tape_class_device *tcd)
 108{
 109        if (tcd != NULL && !IS_ERR(tcd)) {
 110                sysfs_remove_link(&device->kobj, tcd->mode_name);
 111                device_destroy(tape_class, tcd->char_device->dev);
 112                cdev_del(tcd->char_device);
 113                kfree(tcd);
 114        }
 115}
 116EXPORT_SYMBOL(unregister_tape_dev);
 117
 118
 119static int __init tape_init(void)
 120{
 121        tape_class = class_create(THIS_MODULE, "tape390");
 122
 123        return 0;
 124}
 125
 126static void __exit tape_exit(void)
 127{
 128        class_destroy(tape_class);
 129        tape_class = NULL;
 130}
 131
 132postcore_initcall(tape_init);
 133module_exit(tape_exit);
 134