[linux.git] / fs / char_dev.c

/*
 *  linux/fs/char_dev.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/slab.h>
#include <linux/string.h>

#include <linux/major.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/smp_lock.h>
#include <linux/seq_file.h>

#include <linux/kobject.h>
#include <linux/kobj_map.h>
#include <linux/cdev.h>
#include <linux/mutex.h>
#include <linux/backing-dev.h>

#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif
#include "internal.h"

/*
 * capabilities for /dev/mem, /dev/kmem and similar directly mappable character
 * devices
 * - permits shared-mmap for read, write and/or exec
 * - does not permit private mmap in NOMMU mode (can't do COW)
 * - no readahead or I/O queue unplugging required
 */
struct backing_dev_info directly_mappable_cdev_bdi = {
	.capabilities	= (
#ifdef CONFIG_MMU
		/* permit private copies of the data to be taken */
		BDI_CAP_MAP_COPY |
#endif
		/* permit direct mmap, for read, write or exec */
		BDI_CAP_MAP_DIRECT |
		BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP),
};

static struct kobj_map *cdev_map;

static DEFINE_MUTEX(chrdevs_lock);

static struct char_device_struct {
	struct char_device_struct *next;
	unsigned int major;
	unsigned int baseminor;
	int minorct;
	char name[64];
	struct file_operations *fops;
	struct cdev *cdev;		/* will die */
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

/* index in the above */
static inline int major_to_index(int major)
{
	return major % CHRDEV_MAJOR_HASH_SIZE;
}

#ifdef CONFIG_PROC_FS

void chrdev_show(struct seq_file *f, off_t offset)
{
	struct char_device_struct *cd;

	if (offset < CHRDEV_MAJOR_HASH_SIZE) {
		mutex_lock(&chrdevs_lock);
		for (cd = chrdevs[offset]; cd; cd = cd->next)
			seq_printf(f, "%3d %s\n", cd->major, cd->name);
		mutex_unlock(&chrdevs_lock);
	}
}

#endif /* CONFIG_PROC_FS */

/*
 * Register a single major with a specified minor range.
 *
 * If major == 0 this functions will dynamically allocate a major and return
 * its number.
 *
 * If major > 0 this function will attempt to reserve the passed range of
 * minors and will return zero on success.
 *
 * Returns a -ve errno on failure.
 */
static struct char_device_struct *
__register_chrdev_region(unsigned int major, unsigned int baseminor,
			   int minorct, const char *name)
{
	struct char_device_struct *cd, **cp;
	int ret = 0;
	int i;

	cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
	if (cd == NULL)
		return ERR_PTR(-ENOMEM);

	mutex_lock(&chrdevs_lock);

	/* temporary */
	if (major == 0) {
		for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
			if (chrdevs[i] == NULL)
				break;
		}

		if (i == 0) {
			ret = -EBUSY;
			goto out;
		}
		major = i;
		ret = major;
	}

	cd->major = major;
	cd->baseminor = baseminor;
	cd->minorct = minorct;
	strncpy(cd->name,name, 64);

	i = major_to_index(major);

	for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
		if ((*cp)->major > major ||
		    ((*cp)->major == major &&
		     (((*cp)->baseminor >= baseminor) ||
		      ((*cp)->baseminor + (*cp)->minorct > baseminor))))
			break;

	/* Check for overlapping minor ranges.  */
	if (*cp && (*cp)->major == major) {
		int old_min = (*cp)->baseminor;
		int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
		int new_min = baseminor;
		int new_max = baseminor + minorct - 1;

		/* New driver overlaps from the left.  */
		if (new_max >= old_min && new_max <= old_max) {
			ret = -EBUSY;
			goto out;
		}

		/* New driver overlaps from the right.  */
		if (new_min <= old_max && new_min >= old_min) {
			ret = -EBUSY;
			goto out;
		}
	}

	cd->next = *cp;
	*cp = cd;
	mutex_unlock(&chrdevs_lock);
	return cd;
out:
	mutex_unlock(&chrdevs_lock);
	kfree(cd);
	return ERR_PTR(ret);
}

static struct char_device_struct *
__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
{
	struct char_device_struct *cd = NULL, **cp;
	int i = major_to_index(major);

	mutex_lock(&chrdevs_lock);
	for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
		if ((*cp)->major == major &&
		    (*cp)->baseminor == baseminor &&
		    (*cp)->minorct == minorct)
			break;
	if (*cp) {
		cd = *cp;
		*cp = cd->next;
	}
	mutex_unlock(&chrdevs_lock);
	return cd;
}

/**
 * register_chrdev_region() - register a range of device numbers
 * @from: the first in the desired range of device numbers; must include
 *        the major number.
 * @count: the number of consecutive device numbers required
 * @name: the name of the device or driver.
 *
 * Return value is zero on success, a negative error code on failure.
 */
int register_chrdev_region(dev_t from, unsigned count, const char *name)
{
	struct char_device_struct *cd;
	dev_t to = from + count;
	dev_t n, next;

	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);
		if (next > to)
			next = to;
		cd = __register_chrdev_region(MAJOR(n), MINOR(n),
			       next - n, name);
		if (IS_ERR(cd))
			goto fail;
	}
	return 0;
fail:
	to = n;
	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);
		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	}
	return PTR_ERR(cd);
}

/**
 * alloc_chrdev_region() - register a range of char device numbers
 * @dev: output parameter for first assigned number
 * @baseminor: first of the requested range of minor numbers
 * @count: the number of minor numbers required
 * @name: the name of the associated device or driver
 *
 * Allocates a range of char device numbers.  The major number will be
 * chosen dynamically, and returned (along with the first minor number)
 * in @dev.  Returns zero or a negative error code.
 */
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
			const char *name)
{
	struct char_device_struct *cd;
	cd = __register_chrdev_region(0, baseminor, count, name);
	if (IS_ERR(cd))
		return PTR_ERR(cd);
	*dev = MKDEV(cd->major, cd->baseminor);
	return 0;
}

/**
 * register_chrdev() - Register a major number for character devices.
 * @major: major device number or 0 for dynamic allocation
 * @name: name of this range of devices
 * @fops: file operations associated with this devices
 *
 * If @major == 0 this functions will dynamically allocate a major and return
 * its number.
 *
 * If @major > 0 this function will attempt to reserve a device with the given
 * major number and will return zero on success.
 *
 * Returns a -ve errno on failure.
 *
 * The name of this device has nothing to do with the name of the device in
 * /dev. It only helps to keep track of the different owners of devices. If
 * your module name has only one type of devices it's ok to use e.g. the name
 * of the module here.
 *
 * This function registers a range of 256 minor numbers. The first minor number
 * is 0.
 */
int register_chrdev(unsigned int major, const char *name,
		    const struct file_operations *fops)
{
	struct char_device_struct *cd;
	struct cdev *cdev;
	char *s;
	int err = -ENOMEM;

	cd = __register_chrdev_region(major, 0, 256, name);
	if (IS_ERR(cd))
		return PTR_ERR(cd);
	
	cdev = cdev_alloc();
	if (!cdev)
		goto out2;

	cdev->owner = fops->owner;
	cdev->ops = fops;
	kobject_set_name(&cdev->kobj, "%s", name);
	for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))
		*s = '!';
		
	err = cdev_add(cdev, MKDEV(cd->major, 0), 256);
	if (err)
		goto out;

	cd->cdev = cdev;

	return major ? 0 : cd->major;
out:
	kobject_put(&cdev->kobj);
out2:
	kfree(__unregister_chrdev_region(cd->major, 0, 256));
	return err;
}

/**
 * unregister_chrdev_region() - return a range of device numbers
 * @from: the first in the range of numbers to unregister
 * @count: the number of device numbers to unregister
 *
 * This function will unregister a range of @count device numbers,
 * starting with @from.  The caller should normally be the one who
 * allocated those numbers in the first place...
 */
void unregister_chrdev_region(dev_t from, unsigned count)
{
	dev_t to = from + count;
	dev_t n, next;

	for (n = from; n < to; n = next) {
		next = MKDEV(MAJOR(n)+1, 0);
		if (next > to)
			next = to;
		kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	}
}

void unregister_chrdev(unsigned int major, const char *name)
{
	struct char_device_struct *cd;
	cd = __unregister_chrdev_region(major, 0, 256);
	if (cd && cd->cdev)
		cdev_del(cd->cdev);
	kfree(cd);
}

static DEFINE_SPINLOCK(cdev_lock);

static struct kobject *cdev_get(struct cdev *p)
{
	struct module *owner = p->owner;
	struct kobject *kobj;

	if (owner && !try_module_get(owner))
		return NULL;
	kobj = kobject_get(&p->kobj);
	if (!kobj)
		module_put(owner);
	return kobj;
}

void cdev_put(struct cdev *p)
{
	if (p) {
		struct module *owner = p->owner;
		kobject_put(&p->kobj);
		module_put(owner);
	}
}

/*
 * Called every time a character special file is opened
 */
int chrdev_open(struct inode * inode, struct file * filp)
{
	struct cdev *p;
	struct cdev *new = NULL;
	int ret = 0;

	spin_lock(&cdev_lock);
	p = inode->i_cdev;
	if (!p) {
		struct kobject *kobj;
		int idx;
		spin_unlock(&cdev_lock);
		kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
		if (!kobj)
			return -ENXIO;
		new = container_of(kobj, struct cdev, kobj);
		spin_lock(&cdev_lock);
		p = inode->i_cdev;
		if (!p) {
			inode->i_cdev = p = new;
			inode->i_cindex = idx;
			list_add(&inode->i_devices, &p->list);
			new = NULL;
		} else if (!cdev_get(p))
			ret = -ENXIO;
	} else if (!cdev_get(p))
		ret = -ENXIO;
	spin_unlock(&cdev_lock);
	cdev_put(new);
	if (ret)
		return ret;
	filp->f_op = fops_get(p->ops);
	if (!filp->f_op) {
		cdev_put(p);
		return -ENXIO;
	}
	if (filp->f_op->open) {
		lock_kernel();
		ret = filp->f_op->open(inode,filp);
		unlock_kernel();
	}
	if (ret)
		cdev_put(p);
	return ret;
}

void cd_forget(struct inode *inode)
{
	spin_lock(&cdev_lock);
	list_del_init(&inode->i_devices);
	inode->i_cdev = NULL;
	spin_unlock(&cdev_lock);
}

static void cdev_purge(struct cdev *cdev)
{
	spin_lock(&cdev_lock);
	while (!list_empty(&cdev->list)) {
		struct inode *inode;
		inode = container_of(cdev->list.next, struct inode, i_devices);
		list_del_init(&inode->i_devices);
		inode->i_cdev = NULL;
	}
	spin_unlock(&cdev_lock);
}

/*
 * Dummy default file-operations: the only thing this does
 * is contain the open that then fills in the correct operations
 * depending on the special file...
 */
const struct file_operations def_chr_fops = {
	.open = chrdev_open,
};

static struct kobject *exact_match(dev_t dev, int *part, void *data)
{
	struct cdev *p = data;
	return &p->kobj;
}

static int exact_lock(dev_t dev, void *data)
{
	struct cdev *p = data;
	return cdev_get(p) ? 0 : -1;
}

/**
 * cdev_add() - add a char device to the system
 * @p: the cdev structure for the device
 * @dev: the first device number for which this device is responsible
 * @count: the number of consecutive minor numbers corresponding to this
 *         device
 *
 * cdev_add() adds the device represented by @p to the system, making it
 * live immediately.  A negative error code is returned on failure.
 */
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
	p->dev = dev;
	p->count = count;
	return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
}

static void cdev_unmap(dev_t dev, unsigned count)
{
	kobj_unmap(cdev_map, dev, count);
}

/**
 * cdev_del() - remove a cdev from the system
 * @p: the cdev structure to be removed
 *
 * cdev_del() removes @p from the system, possibly freeing the structure
 * itself.
 */
void cdev_del(struct cdev *p)
{
	cdev_unmap(p->dev, p->count);
	kobject_put(&p->kobj);
}


static void cdev_default_release(struct kobject *kobj)
{
	struct cdev *p = container_of(kobj, struct cdev, kobj);
	cdev_purge(p);
}

static void cdev_dynamic_release(struct kobject *kobj)
{
	struct cdev *p = container_of(kobj, struct cdev, kobj);
	cdev_purge(p);
	kfree(p);
}

static struct kobj_type ktype_cdev_default = {
	.release	= cdev_default_release,
};

static struct kobj_type ktype_cdev_dynamic = {
	.release	= cdev_dynamic_release,
};

/**
 * cdev_alloc() - allocate a cdev structure
 *
 * Allocates and returns a cdev structure, or NULL on failure.
 */
struct cdev *cdev_alloc(void)
{
	struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
	if (p) {
		p->kobj.ktype = &ktype_cdev_dynamic;
		INIT_LIST_HEAD(&p->list);
		kobject_init(&p->kobj);
	}
	return p;
}

/**
 * cdev_init() - initialize a cdev structure
 * @cdev: the structure to initialize
 * @fops: the file_operations for this device
 *
 * Initializes @cdev, remembering @fops, making it ready to add to the
 * system with cdev_add().
 */
void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
	memset(cdev, 0, sizeof *cdev);
	INIT_LIST_HEAD(&cdev->list);
	cdev->kobj.ktype = &ktype_cdev_default;
	kobject_init(&cdev->kobj);
	cdev->ops = fops;
}

static struct kobject *base_probe(dev_t dev, int *part, void *data)
{
	if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
		/* Make old-style 2.4 aliases work */
		request_module("char-major-%d", MAJOR(dev));
	return NULL;
}

void __init chrdev_init(void)
{
	cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
	bdi_init(&directly_mappable_cdev_bdi);
}


/* Let modules do char dev stuff */
EXPORT_SYMBOL(register_chrdev_region);
EXPORT_SYMBOL(unregister_chrdev_region);
EXPORT_SYMBOL(alloc_chrdev_region);
EXPORT_SYMBOL(cdev_init);
EXPORT_SYMBOL(cdev_alloc);
EXPORT_SYMBOL(cdev_del);
EXPORT_SYMBOL(cdev_add);
EXPORT_SYMBOL(register_chrdev);
EXPORT_SYMBOL(unregister_chrdev);
EXPORT_SYMBOL(directly_mappable_cdev_bdi);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/char_dev.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*/
	6
1da177e4 LT	7	#include <linux/init.h>
1da177e4 LT	8	#include <linux/fs.h>
b446b60e	9	#include <linux/kdev_t.h>
1da177e4 LT	10	#include <linux/slab.h>
	11	#include <linux/string.h>
	12
	13	#include <linux/major.h>
	14	#include <linux/errno.h>
	15	#include <linux/module.h>
	16	#include <linux/smp_lock.h>
68eef3b4	17	#include <linux/seq_file.h>
1da177e4 LT	18
	19	#include <linux/kobject.h>
	20	#include <linux/kobj_map.h>
	21	#include <linux/cdev.h>
58383af6	22	#include <linux/mutex.h>
5da6185b	23	#include <linux/backing-dev.h>
1da177e4 LT	24
	25	#ifdef CONFIG_KMOD
	26	#include <linux/kmod.h>
	27	#endif
07f3f05c	28	#include "internal.h"
1da177e4	29
5da6185b DH	30	/*
	31	* capabilities for /dev/mem, /dev/kmem and similar directly mappable character
	32	* devices
	33	* - permits shared-mmap for read, write and/or exec
	34	* - does not permit private mmap in NOMMU mode (can't do COW)
	35	* - no readahead or I/O queue unplugging required
	36	*/
	37	struct backing_dev_info directly_mappable_cdev_bdi = {
	38	.capabilities = (
	39	#ifdef CONFIG_MMU
	40	/* permit private copies of the data to be taken */
	41	BDI_CAP_MAP_COPY \|
	42	#endif
	43	/* permit direct mmap, for read, write or exec */
	44	BDI_CAP_MAP_DIRECT \|
	45	BDI_CAP_READ_MAP \| BDI_CAP_WRITE_MAP \| BDI_CAP_EXEC_MAP),
	46	};
	47
1da177e4 LT	48	static struct kobj_map *cdev_map;
1da177e4 LT	49
58383af6	50	static DEFINE_MUTEX(chrdevs_lock);
1da177e4 LT	51
	52	static struct char_device_struct {
	53	struct char_device_struct *next;
	54	unsigned int major;
	55	unsigned int baseminor;
	56	int minorct;
7170be5f	57	char name[64];
1da177e4 LT	58	struct file_operations *fops;
1da177e4 LT	59	struct cdev cdev; / will die */
68eef3b4	60	} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
1da177e4 LT	61
	62	/* index in the above */
	63	static inline int major_to_index(int major)
	64	{
68eef3b4	65	return major % CHRDEV_MAJOR_HASH_SIZE;
7170be5f NH	66	}
7170be5f NH	67
68eef3b4	68	#ifdef CONFIG_PROC_FS
7170be5f	69
68eef3b4	70	void chrdev_show(struct seq_file *f, off_t offset)
7170be5f NH	71	{
7170be5f NH	72	struct char_device_struct *cd;
7170be5f	73
68eef3b4 JK	74	if (offset < CHRDEV_MAJOR_HASH_SIZE) {
	75	mutex_lock(&chrdevs_lock);
	76	for (cd = chrdevs[offset]; cd; cd = cd->next)
	77	seq_printf(f, "%3d %s\n", cd->major, cd->name);
	78	mutex_unlock(&chrdevs_lock);
1da177e4	79	}
7170be5f NH	80	}
7170be5f NH	81
68eef3b4	82	#endif /* CONFIG_PROC_FS */
1da177e4 LT	83
	84	/*
	85	* Register a single major with a specified minor range.
	86	*
	87	* If major == 0 this functions will dynamically allocate a major and return
	88	* its number.
	89	*
	90	* If major > 0 this function will attempt to reserve the passed range of
	91	* minors and will return zero on success.
	92	*
	93	* Returns a -ve errno on failure.
	94	*/
	95	static struct char_device_struct *
	96	__register_chrdev_region(unsigned int major, unsigned int baseminor,
	97	int minorct, const char *name)
	98	{
	99	struct char_device_struct cd, *cp;
	100	int ret = 0;
	101	int i;
	102
11b0b5ab	103	cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
1da177e4 LT	104	if (cd == NULL)
	105	return ERR_PTR(-ENOMEM);
	106
58383af6	107	mutex_lock(&chrdevs_lock);
1da177e4 LT	108
	109	/* temporary */
	110	if (major == 0) {
	111	for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
	112	if (chrdevs[i] == NULL)
	113	break;
	114	}
	115
	116	if (i == 0) {
	117	ret = -EBUSY;
	118	goto out;
	119	}
	120	major = i;
	121	ret = major;
	122	}
	123
	124	cd->major = major;
	125	cd->baseminor = baseminor;
	126	cd->minorct = minorct;
7170be5f	127	strncpy(cd->name,name, 64);
1da177e4 LT	128
	129	i = major_to_index(major);
	130
	131	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)
	132	if ((*cp)->major > major \|\|
01d553d0 AW	133	((*cp)->major == major &&
	134	(((*cp)->baseminor >= baseminor) \|\|
	135	((cp)->baseminor + (cp)->minorct > baseminor))))
1da177e4	136	break;
01d553d0 AW	137
	138	/* Check for overlapping minor ranges. */
	139	if (cp && (cp)->major == major) {
	140	int old_min = (*cp)->baseminor;
	141	int old_max = (cp)->baseminor + (cp)->minorct - 1;
	142	int new_min = baseminor;
	143	int new_max = baseminor + minorct - 1;
	144
	145	/* New driver overlaps from the left. */
	146	if (new_max >= old_min && new_max <= old_max) {
	147	ret = -EBUSY;
	148	goto out;
	149	}
	150
	151	/* New driver overlaps from the right. */
	152	if (new_min <= old_max && new_min >= old_min) {
	153	ret = -EBUSY;
	154	goto out;
	155	}
1da177e4	156	}
01d553d0	157
1da177e4 LT	158	cd->next = *cp;
1da177e4 LT	159	*cp = cd;
58383af6	160	mutex_unlock(&chrdevs_lock);
1da177e4 LT	161	return cd;
1da177e4 LT	162	out:
58383af6	163	mutex_unlock(&chrdevs_lock);
1da177e4 LT	164	kfree(cd);
	165	return ERR_PTR(ret);
	166	}
	167
	168	static struct char_device_struct *
	169	__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
	170	{
	171	struct char_device_struct cd = NULL, *cp;
	172	int i = major_to_index(major);
	173
58383af6	174	mutex_lock(&chrdevs_lock);
1da177e4 LT	175	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)
	176	if ((*cp)->major == major &&
	177	(*cp)->baseminor == baseminor &&
	178	(*cp)->minorct == minorct)
	179	break;
	180	if (*cp) {
	181	cd = *cp;
	182	*cp = cd->next;
	183	}
58383af6	184	mutex_unlock(&chrdevs_lock);
1da177e4 LT	185	return cd;
	186	}
	187
cf3e43db JC	188	/**
	189	* register_chrdev_region() - register a range of device numbers
	190	* @from: the first in the desired range of device numbers; must include
	191	* the major number.
	192	* @count: the number of consecutive device numbers required
	193	* @name: the name of the device or driver.
	194	*
	195	* Return value is zero on success, a negative error code on failure.
	196	*/
1da177e4 LT	197	int register_chrdev_region(dev_t from, unsigned count, const char *name)
	198	{
	199	struct char_device_struct *cd;
	200	dev_t to = from + count;
	201	dev_t n, next;
	202
	203	for (n = from; n < to; n = next) {
	204	next = MKDEV(MAJOR(n)+1, 0);
	205	if (next > to)
	206	next = to;
	207	cd = __register_chrdev_region(MAJOR(n), MINOR(n),
	208	next - n, name);
	209	if (IS_ERR(cd))
	210	goto fail;
	211	}
	212	return 0;
	213	fail:
	214	to = n;
	215	for (n = from; n < to; n = next) {
	216	next = MKDEV(MAJOR(n)+1, 0);
	217	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	218	}
	219	return PTR_ERR(cd);
	220	}
	221
cf3e43db JC	222	/**
	223	* alloc_chrdev_region() - register a range of char device numbers
	224	* @dev: output parameter for first assigned number
	225	* @baseminor: first of the requested range of minor numbers
	226	* @count: the number of minor numbers required
	227	* @name: the name of the associated device or driver
	228	*
	229	* Allocates a range of char device numbers. The major number will be
	230	* chosen dynamically, and returned (along with the first minor number)
	231	* in @dev. Returns zero or a negative error code.
	232	*/
1da177e4 LT	233	int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
	234	const char *name)
	235	{
	236	struct char_device_struct *cd;
	237	cd = __register_chrdev_region(0, baseminor, count, name);
	238	if (IS_ERR(cd))
	239	return PTR_ERR(cd);
	240	*dev = MKDEV(cd->major, cd->baseminor);
	241	return 0;
	242	}
	243
d247e2c6 REB	244	/**
	245	* register_chrdev() - Register a major number for character devices.
	246	* @major: major device number or 0 for dynamic allocation
	247	* @name: name of this range of devices
	248	* @fops: file operations associated with this devices
	249	*
	250	* If @major == 0 this functions will dynamically allocate a major and return
	251	* its number.
	252	*
	253	* If @major > 0 this function will attempt to reserve a device with the given
	254	* major number and will return zero on success.
	255	*
	256	* Returns a -ve errno on failure.
	257	*
	258	* The name of this device has nothing to do with the name of the device in
	259	* /dev. It only helps to keep track of the different owners of devices. If
	260	* your module name has only one type of devices it's ok to use e.g. the name
	261	* of the module here.
	262	*
	263	* This function registers a range of 256 minor numbers. The first minor number
	264	* is 0.
	265	*/
1da177e4	266	int register_chrdev(unsigned int major, const char *name,
99ac48f5	267	const struct file_operations *fops)
1da177e4 LT	268	{
	269	struct char_device_struct *cd;
	270	struct cdev *cdev;
	271	char *s;
	272	int err = -ENOMEM;
	273
	274	cd = __register_chrdev_region(major, 0, 256, name);
	275	if (IS_ERR(cd))
	276	return PTR_ERR(cd);
	277
	278	cdev = cdev_alloc();
	279	if (!cdev)
	280	goto out2;
	281
	282	cdev->owner = fops->owner;
	283	cdev->ops = fops;
	284	kobject_set_name(&cdev->kobj, "%s", name);
	285	for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))
	286	*s = '!';
	287
	288	err = cdev_add(cdev, MKDEV(cd->major, 0), 256);
	289	if (err)
	290	goto out;
	291
	292	cd->cdev = cdev;
	293
	294	return major ? 0 : cd->major;
	295	out:
	296	kobject_put(&cdev->kobj);
	297	out2:
	298	kfree(__unregister_chrdev_region(cd->major, 0, 256));
	299	return err;
	300	}
	301
cf3e43db JC	302	/**
	303	* unregister_chrdev_region() - return a range of device numbers
	304	* @from: the first in the range of numbers to unregister
	305	* @count: the number of device numbers to unregister
	306	*
	307	* This function will unregister a range of @count device numbers,
	308	* starting with @from. The caller should normally be the one who
	309	* allocated those numbers in the first place...
	310	*/
1da177e4 LT	311	void unregister_chrdev_region(dev_t from, unsigned count)
	312	{
	313	dev_t to = from + count;
	314	dev_t n, next;
	315
	316	for (n = from; n < to; n = next) {
	317	next = MKDEV(MAJOR(n)+1, 0);
	318	if (next > to)
	319	next = to;
	320	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
	321	}
	322	}
	323
e53252d9	324	void unregister_chrdev(unsigned int major, const char *name)
1da177e4 LT	325	{
	326	struct char_device_struct *cd;
	327	cd = __unregister_chrdev_region(major, 0, 256);
	328	if (cd && cd->cdev)
	329	cdev_del(cd->cdev);
	330	kfree(cd);
1da177e4 LT	331	}
	332
	333	static DEFINE_SPINLOCK(cdev_lock);
	334
	335	static struct kobject cdev_get(struct cdev p)
	336	{
	337	struct module *owner = p->owner;
	338	struct kobject *kobj;
	339
	340	if (owner && !try_module_get(owner))
	341	return NULL;
	342	kobj = kobject_get(&p->kobj);
	343	if (!kobj)
	344	module_put(owner);
	345	return kobj;
	346	}
	347
	348	void cdev_put(struct cdev *p)
	349	{
	350	if (p) {
7da6844c	351	struct module *owner = p->owner;
1da177e4	352	kobject_put(&p->kobj);
7da6844c	353	module_put(owner);
1da177e4 LT	354	}
	355	}
	356
	357	/*
	358	* Called every time a character special file is opened
	359	*/
	360	int chrdev_open(struct inode * inode, struct file * filp)
	361	{
	362	struct cdev *p;
	363	struct cdev *new = NULL;
	364	int ret = 0;
	365
	366	spin_lock(&cdev_lock);
	367	p = inode->i_cdev;
	368	if (!p) {
	369	struct kobject *kobj;
	370	int idx;
	371	spin_unlock(&cdev_lock);
	372	kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
	373	if (!kobj)
	374	return -ENXIO;
	375	new = container_of(kobj, struct cdev, kobj);
	376	spin_lock(&cdev_lock);
	377	p = inode->i_cdev;
	378	if (!p) {
	379	inode->i_cdev = p = new;
	380	inode->i_cindex = idx;
	381	list_add(&inode->i_devices, &p->list);
	382	new = NULL;
	383	} else if (!cdev_get(p))
	384	ret = -ENXIO;
	385	} else if (!cdev_get(p))
	386	ret = -ENXIO;
	387	spin_unlock(&cdev_lock);
	388	cdev_put(new);
	389	if (ret)
	390	return ret;
	391	filp->f_op = fops_get(p->ops);
	392	if (!filp->f_op) {
	393	cdev_put(p);
	394	return -ENXIO;
	395	}
	396	if (filp->f_op->open) {
	397	lock_kernel();
	398	ret = filp->f_op->open(inode,filp);
	399	unlock_kernel();
	400	}
	401	if (ret)
	402	cdev_put(p);
	403	return ret;
	404	}
	405
	406	void cd_forget(struct inode *inode)
	407	{
	408	spin_lock(&cdev_lock);
	409	list_del_init(&inode->i_devices);
	410	inode->i_cdev = NULL;
	411	spin_unlock(&cdev_lock);
	412	}
	413
75c96f85	414	static void cdev_purge(struct cdev *cdev)
1da177e4 LT	415	{
	416	spin_lock(&cdev_lock);
	417	while (!list_empty(&cdev->list)) {
	418	struct inode *inode;
	419	inode = container_of(cdev->list.next, struct inode, i_devices);
	420	list_del_init(&inode->i_devices);
	421	inode->i_cdev = NULL;
	422	}
	423	spin_unlock(&cdev_lock);
	424	}
	425
	426	/*
	427	* Dummy default file-operations: the only thing this does
	428	* is contain the open that then fills in the correct operations
	429	* depending on the special file...
	430	*/
4b6f5d20	431	const struct file_operations def_chr_fops = {
1da177e4 LT	432	.open = chrdev_open,
	433	};
	434
	435	static struct kobject exact_match(dev_t dev, int part, void *data)
	436	{
	437	struct cdev *p = data;
	438	return &p->kobj;
	439	}
	440
	441	static int exact_lock(dev_t dev, void *data)
	442	{
	443	struct cdev *p = data;
	444	return cdev_get(p) ? 0 : -1;
	445	}
	446
cf3e43db JC	447	/**
	448	* cdev_add() - add a char device to the system
	449	* @p: the cdev structure for the device
	450	* @dev: the first device number for which this device is responsible
	451	* @count: the number of consecutive minor numbers corresponding to this
	452	* device
	453	*
	454	* cdev_add() adds the device represented by @p to the system, making it
	455	* live immediately. A negative error code is returned on failure.
	456	*/
1da177e4 LT	457	int cdev_add(struct cdev *p, dev_t dev, unsigned count)
	458	{
	459	p->dev = dev;
	460	p->count = count;
	461	return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
	462	}
	463
	464	static void cdev_unmap(dev_t dev, unsigned count)
	465	{
	466	kobj_unmap(cdev_map, dev, count);
	467	}
	468
cf3e43db JC	469	/**
	470	* cdev_del() - remove a cdev from the system
	471	* @p: the cdev structure to be removed
	472	*
	473	* cdev_del() removes @p from the system, possibly freeing the structure
	474	* itself.
	475	*/
1da177e4 LT	476	void cdev_del(struct cdev *p)
	477	{
	478	cdev_unmap(p->dev, p->count);
	479	kobject_put(&p->kobj);
	480	}
	481
	482
	483	static void cdev_default_release(struct kobject *kobj)
	484	{
	485	struct cdev *p = container_of(kobj, struct cdev, kobj);
	486	cdev_purge(p);
	487	}
	488
	489	static void cdev_dynamic_release(struct kobject *kobj)
	490	{
	491	struct cdev *p = container_of(kobj, struct cdev, kobj);
	492	cdev_purge(p);
	493	kfree(p);
	494	}
	495
	496	static struct kobj_type ktype_cdev_default = {
	497	.release = cdev_default_release,
	498	};
	499
	500	static struct kobj_type ktype_cdev_dynamic = {
	501	.release = cdev_dynamic_release,
	502	};
	503
cf3e43db JC	504	/**
	505	* cdev_alloc() - allocate a cdev structure
	506	*
	507	* Allocates and returns a cdev structure, or NULL on failure.
	508	*/
1da177e4 LT	509	struct cdev *cdev_alloc(void)
1da177e4 LT	510	{
11b0b5ab	511	struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
1da177e4	512	if (p) {
1da177e4 LT	513	p->kobj.ktype = &ktype_cdev_dynamic;
	514	INIT_LIST_HEAD(&p->list);
	515	kobject_init(&p->kobj);
	516	}
	517	return p;
	518	}
	519
cf3e43db JC	520	/**
	521	* cdev_init() - initialize a cdev structure
	522	* @cdev: the structure to initialize
	523	* @fops: the file_operations for this device
	524	*
	525	* Initializes @cdev, remembering @fops, making it ready to add to the
	526	* system with cdev_add().
	527	*/
99ac48f5	528	void cdev_init(struct cdev cdev, const struct file_operations fops)
1da177e4 LT	529	{
	530	memset(cdev, 0, sizeof *cdev);
	531	INIT_LIST_HEAD(&cdev->list);
	532	cdev->kobj.ktype = &ktype_cdev_default;
	533	kobject_init(&cdev->kobj);
	534	cdev->ops = fops;
	535	}
	536
	537	static struct kobject base_probe(dev_t dev, int part, void *data)
	538	{
	539	if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
	540	/* Make old-style 2.4 aliases work */
	541	request_module("char-major-%d", MAJOR(dev));
	542	return NULL;
	543	}
	544
	545	void __init chrdev_init(void)
	546	{
	547	cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
e0bf68dd	548	bdi_init(&directly_mappable_cdev_bdi);
1da177e4 LT	549	}
	550
	551
	552	/* Let modules do char dev stuff */
	553	EXPORT_SYMBOL(register_chrdev_region);
	554	EXPORT_SYMBOL(unregister_chrdev_region);
	555	EXPORT_SYMBOL(alloc_chrdev_region);
	556	EXPORT_SYMBOL(cdev_init);
	557	EXPORT_SYMBOL(cdev_alloc);
	558	EXPORT_SYMBOL(cdev_del);
	559	EXPORT_SYMBOL(cdev_add);
	560	EXPORT_SYMBOL(register_chrdev);
	561	EXPORT_SYMBOL(unregister_chrdev);
5da6185b	562	EXPORT_SYMBOL(directly_mappable_cdev_bdi);