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