• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * drivers/usb/core/file.c
3  *
4  * (C) Copyright Linus Torvalds 1999
5  * (C) Copyright Johannes Erdfelt 1999-2001
6  * (C) Copyright Andreas Gal 1999
7  * (C) Copyright Gregory P. Smith 1999
8  * (C) Copyright Deti Fliegl 1999 (new USB architecture)
9  * (C) Copyright Randy Dunlap 2000
10  * (C) Copyright David Brownell 2000-2001 (kernel hotplug, usb_device_id,
11  *	more docs, etc)
12  * (C) Copyright Yggdrasil Computing, Inc. 2000
13  *     (usb_device_id matching changes by Adam J. Richter)
14  * (C) Copyright Greg Kroah-Hartman 2002-2003
15  *
16  */
17 
18 #include <linux/module.h>
19 #include <linux/errno.h>
20 #include <linux/rwsem.h>
21 #include <linux/slab.h>
22 #include <linux/string.h>
23 #include <linux/usb.h>
24 
25 #include "usb.h"
26 
27 #define MAX_USB_MINORS	256
28 static const struct file_operations *usb_minors[MAX_USB_MINORS];
29 static DECLARE_RWSEM(minor_rwsem);
30 static DEFINE_MUTEX(init_usb_class_mutex);
31 
usb_open(struct inode * inode,struct file * file)32 static int usb_open(struct inode *inode, struct file *file)
33 {
34 	int err = -ENODEV;
35 	const struct file_operations *new_fops;
36 
37 	down_read(&minor_rwsem);
38 	new_fops = fops_get(usb_minors[iminor(inode)]);
39 
40 	if (!new_fops)
41 		goto done;
42 
43 	replace_fops(file, new_fops);
44 	/* Curiouser and curiouser... NULL ->open() as "no device" ? */
45 	if (file->f_op->open)
46 		err = file->f_op->open(inode, file);
47  done:
48 	up_read(&minor_rwsem);
49 	return err;
50 }
51 
52 static const struct file_operations usb_fops = {
53 	.owner =	THIS_MODULE,
54 	.open =		usb_open,
55 	.llseek =	noop_llseek,
56 };
57 
58 static struct usb_class {
59 	struct kref kref;
60 	struct class *class;
61 } *usb_class;
62 
usb_devnode(struct device * dev,umode_t * mode)63 static char *usb_devnode(struct device *dev, umode_t *mode)
64 {
65 	struct usb_class_driver *drv;
66 
67 	drv = dev_get_drvdata(dev);
68 	if (!drv || !drv->devnode)
69 		return NULL;
70 	return drv->devnode(dev, mode);
71 }
72 
init_usb_class(void)73 static int init_usb_class(void)
74 {
75 	int result = 0;
76 
77 	if (usb_class != NULL) {
78 		kref_get(&usb_class->kref);
79 		goto exit;
80 	}
81 
82 	usb_class = kmalloc(sizeof(*usb_class), GFP_KERNEL);
83 	if (!usb_class) {
84 		result = -ENOMEM;
85 		goto exit;
86 	}
87 
88 	kref_init(&usb_class->kref);
89 	usb_class->class = class_create(THIS_MODULE, "usbmisc");
90 	if (IS_ERR(usb_class->class)) {
91 		result = PTR_ERR(usb_class->class);
92 		printk(KERN_ERR "class_create failed for usb devices\n");
93 		kfree(usb_class);
94 		usb_class = NULL;
95 		goto exit;
96 	}
97 	usb_class->class->devnode = usb_devnode;
98 
99 exit:
100 	return result;
101 }
102 
release_usb_class(struct kref * kref)103 static void release_usb_class(struct kref *kref)
104 {
105 	/* Ok, we cheat as we know we only have one usb_class */
106 	class_destroy(usb_class->class);
107 	kfree(usb_class);
108 	usb_class = NULL;
109 }
110 
destroy_usb_class(void)111 static void destroy_usb_class(void)
112 {
113 	mutex_lock(&init_usb_class_mutex);
114 	kref_put(&usb_class->kref, release_usb_class);
115 	mutex_unlock(&init_usb_class_mutex);
116 }
117 
usb_major_init(void)118 int usb_major_init(void)
119 {
120 	int error;
121 
122 	error = register_chrdev(USB_MAJOR, "usb", &usb_fops);
123 	if (error)
124 		printk(KERN_ERR "Unable to get major %d for usb devices\n",
125 		       USB_MAJOR);
126 
127 	return error;
128 }
129 
usb_major_cleanup(void)130 void usb_major_cleanup(void)
131 {
132 	unregister_chrdev(USB_MAJOR, "usb");
133 }
134 
135 /**
136  * usb_register_dev - register a USB device, and ask for a minor number
137  * @intf: pointer to the usb_interface that is being registered
138  * @class_driver: pointer to the usb_class_driver for this device
139  *
140  * This should be called by all USB drivers that use the USB major number.
141  * If CONFIG_USB_DYNAMIC_MINORS is enabled, the minor number will be
142  * dynamically allocated out of the list of available ones.  If it is not
143  * enabled, the minor number will be based on the next available free minor,
144  * starting at the class_driver->minor_base.
145  *
146  * This function also creates a usb class device in the sysfs tree.
147  *
148  * usb_deregister_dev() must be called when the driver is done with
149  * the minor numbers given out by this function.
150  *
151  * Return: -EINVAL if something bad happens with trying to register a
152  * device, and 0 on success.
153  */
usb_register_dev(struct usb_interface * intf,struct usb_class_driver * class_driver)154 int usb_register_dev(struct usb_interface *intf,
155 		     struct usb_class_driver *class_driver)
156 {
157 	int retval;
158 	int minor_base = class_driver->minor_base;
159 	int minor;
160 	char name[20];
161 
162 #ifdef CONFIG_USB_DYNAMIC_MINORS
163 	/*
164 	 * We don't care what the device tries to start at, we want to start
165 	 * at zero to pack the devices into the smallest available space with
166 	 * no holes in the minor range.
167 	 */
168 	minor_base = 0;
169 #endif
170 
171 	if (class_driver->fops == NULL)
172 		return -EINVAL;
173 	if (intf->minor >= 0)
174 		return -EADDRINUSE;
175 
176 	mutex_lock(&init_usb_class_mutex);
177 	retval = init_usb_class();
178 	mutex_unlock(&init_usb_class_mutex);
179 
180 	if (retval)
181 		return retval;
182 
183 	dev_dbg(&intf->dev, "looking for a minor, starting at %d\n", minor_base);
184 
185 	down_write(&minor_rwsem);
186 	for (minor = minor_base; minor < MAX_USB_MINORS; ++minor) {
187 		if (usb_minors[minor])
188 			continue;
189 
190 		usb_minors[minor] = class_driver->fops;
191 		intf->minor = minor;
192 		break;
193 	}
194 	up_write(&minor_rwsem);
195 	if (intf->minor < 0)
196 		return -EXFULL;
197 
198 	/* create a usb class device for this usb interface */
199 	snprintf(name, sizeof(name), class_driver->name, minor - minor_base);
200 	intf->usb_dev = device_create(usb_class->class, &intf->dev,
201 				      MKDEV(USB_MAJOR, minor), class_driver,
202 				      "%s", kbasename(name));
203 	if (IS_ERR(intf->usb_dev)) {
204 		down_write(&minor_rwsem);
205 		usb_minors[minor] = NULL;
206 		intf->minor = -1;
207 		up_write(&minor_rwsem);
208 		retval = PTR_ERR(intf->usb_dev);
209 	}
210 	return retval;
211 }
212 EXPORT_SYMBOL_GPL(usb_register_dev);
213 
214 /**
215  * usb_deregister_dev - deregister a USB device's dynamic minor.
216  * @intf: pointer to the usb_interface that is being deregistered
217  * @class_driver: pointer to the usb_class_driver for this device
218  *
219  * Used in conjunction with usb_register_dev().  This function is called
220  * when the USB driver is finished with the minor numbers gotten from a
221  * call to usb_register_dev() (usually when the device is disconnected
222  * from the system.)
223  *
224  * This function also removes the usb class device from the sysfs tree.
225  *
226  * This should be called by all drivers that use the USB major number.
227  */
usb_deregister_dev(struct usb_interface * intf,struct usb_class_driver * class_driver)228 void usb_deregister_dev(struct usb_interface *intf,
229 			struct usb_class_driver *class_driver)
230 {
231 	if (intf->minor == -1)
232 		return;
233 
234 	dev_dbg(&intf->dev, "removing %d minor\n", intf->minor);
235 
236 	down_write(&minor_rwsem);
237 	usb_minors[intf->minor] = NULL;
238 	up_write(&minor_rwsem);
239 
240 	device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
241 	intf->usb_dev = NULL;
242 	intf->minor = -1;
243 	destroy_usb_class();
244 }
245 EXPORT_SYMBOL_GPL(usb_deregister_dev);
246