Branch data Line data Source code
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/usb.h>
23 : :
24 : : #include "usb.h"
25 : :
26 : : #define MAX_USB_MINORS 256
27 : : static const struct file_operations *usb_minors[MAX_USB_MINORS];
28 : : static DECLARE_RWSEM(minor_rwsem);
29 : :
30 : 0 : static int usb_open(struct inode *inode, struct file *file)
31 : : {
32 : : int err = -ENODEV;
33 : : const struct file_operations *new_fops;
34 : :
35 : 0 : down_read(&minor_rwsem);
36 [ # # ][ # # ]: 0 : new_fops = fops_get(usb_minors[iminor(inode)]);
37 : :
38 [ # # ]: 0 : if (!new_fops)
39 : : goto done;
40 : :
41 [ # # ][ # # ]: 0 : replace_fops(file, new_fops);
42 : : /* Curiouser and curiouser... NULL ->open() as "no device" ? */
43 [ # # ]: 0 : if (file->f_op->open)
44 : 0 : err = file->f_op->open(inode, file);
45 : : done:
46 : 0 : up_read(&minor_rwsem);
47 : 0 : return err;
48 : : }
49 : :
50 : : static const struct file_operations usb_fops = {
51 : : .owner = THIS_MODULE,
52 : : .open = usb_open,
53 : : .llseek = noop_llseek,
54 : : };
55 : :
56 : : static struct usb_class {
57 : : struct kref kref;
58 : : struct class *class;
59 : : } *usb_class;
60 : :
61 : 0 : static char *usb_devnode(struct device *dev, umode_t *mode)
62 : : {
63 : : struct usb_class_driver *drv;
64 : :
65 : 0 : drv = dev_get_drvdata(dev);
66 [ # # ][ # # ]: 0 : if (!drv || !drv->devnode)
67 : : return NULL;
68 : 0 : return drv->devnode(dev, mode);
69 : : }
70 : :
71 : 0 : static int init_usb_class(void)
72 : : {
73 : : int result = 0;
74 : :
75 [ # # ]: 0 : if (usb_class != NULL) {
76 : : kref_get(&usb_class->kref);
77 : : goto exit;
78 : : }
79 : :
80 : 0 : usb_class = kmalloc(sizeof(*usb_class), GFP_KERNEL);
81 [ # # ]: 0 : if (!usb_class) {
82 : : result = -ENOMEM;
83 : : goto exit;
84 : : }
85 : :
86 : : kref_init(&usb_class->kref);
87 : 0 : usb_class->class = class_create(THIS_MODULE, "usbmisc");
88 [ # # ]: 0 : if (IS_ERR(usb_class->class)) {
89 : : result = PTR_ERR(usb_class->class);
90 : 0 : printk(KERN_ERR "class_create failed for usb devices\n");
91 : 0 : kfree(usb_class);
92 : 0 : usb_class = NULL;
93 : 0 : goto exit;
94 : : }
95 : 0 : usb_class->class->devnode = usb_devnode;
96 : :
97 : : exit:
98 : 0 : return result;
99 : : }
100 : :
101 : 0 : static void release_usb_class(struct kref *kref)
102 : : {
103 : : /* Ok, we cheat as we know we only have one usb_class */
104 : 0 : class_destroy(usb_class->class);
105 : 0 : kfree(usb_class);
106 : 0 : usb_class = NULL;
107 : 0 : }
108 : :
109 : 0 : static void destroy_usb_class(void)
110 : : {
111 [ # # ]: 0 : if (usb_class)
112 : 0 : kref_put(&usb_class->kref, release_usb_class);
113 : 0 : }
114 : :
115 : 0 : int usb_major_init(void)
116 : : {
117 : : int error;
118 : :
119 : : error = register_chrdev(USB_MAJOR, "usb", &usb_fops);
120 [ # # ]: 0 : if (error)
121 : 0 : printk(KERN_ERR "Unable to get major %d for usb devices\n",
122 : : USB_MAJOR);
123 : :
124 : 0 : return error;
125 : : }
126 : :
127 : 0 : void usb_major_cleanup(void)
128 : : {
129 : : unregister_chrdev(USB_MAJOR, "usb");
130 : 0 : }
131 : :
132 : : /**
133 : : * usb_register_dev - register a USB device, and ask for a minor number
134 : : * @intf: pointer to the usb_interface that is being registered
135 : : * @class_driver: pointer to the usb_class_driver for this device
136 : : *
137 : : * This should be called by all USB drivers that use the USB major number.
138 : : * If CONFIG_USB_DYNAMIC_MINORS is enabled, the minor number will be
139 : : * dynamically allocated out of the list of available ones. If it is not
140 : : * enabled, the minor number will be based on the next available free minor,
141 : : * starting at the class_driver->minor_base.
142 : : *
143 : : * This function also creates a usb class device in the sysfs tree.
144 : : *
145 : : * usb_deregister_dev() must be called when the driver is done with
146 : : * the minor numbers given out by this function.
147 : : *
148 : : * Return: -EINVAL if something bad happens with trying to register a
149 : : * device, and 0 on success.
150 : : */
151 : 0 : int usb_register_dev(struct usb_interface *intf,
152 : : struct usb_class_driver *class_driver)
153 : : {
154 : : int retval;
155 : 0 : int minor_base = class_driver->minor_base;
156 : : int minor;
157 : : char name[20];
158 : : char *temp;
159 : :
160 : : #ifdef CONFIG_USB_DYNAMIC_MINORS
161 : : /*
162 : : * We don't care what the device tries to start at, we want to start
163 : : * at zero to pack the devices into the smallest available space with
164 : : * no holes in the minor range.
165 : : */
166 : : minor_base = 0;
167 : : #endif
168 : :
169 [ # # ]: 0 : if (class_driver->fops == NULL)
170 : : return -EINVAL;
171 [ # # ]: 0 : if (intf->minor >= 0)
172 : : return -EADDRINUSE;
173 : :
174 : 0 : retval = init_usb_class();
175 [ # # ]: 0 : if (retval)
176 : : return retval;
177 : :
178 : : dev_dbg(&intf->dev, "looking for a minor, starting at %d\n", minor_base);
179 : :
180 : 0 : down_write(&minor_rwsem);
181 [ # # ]: 0 : for (minor = minor_base; minor < MAX_USB_MINORS; ++minor) {
182 [ # # ]: 0 : if (usb_minors[minor])
183 : 0 : continue;
184 : :
185 : 0 : usb_minors[minor] = class_driver->fops;
186 : 0 : intf->minor = minor;
187 : 0 : break;
188 : : }
189 : 0 : up_write(&minor_rwsem);
190 [ # # ]: 0 : if (intf->minor < 0)
191 : : return -EXFULL;
192 : :
193 : : /* create a usb class device for this usb interface */
194 : 0 : snprintf(name, sizeof(name), class_driver->name, minor - minor_base);
195 : 0 : temp = strrchr(name, '/');
196 [ # # ][ # # ]: 0 : if (temp && (temp[1] != '\0'))
197 : 0 : ++temp;
198 : : else
199 : : temp = name;
200 : 0 : intf->usb_dev = device_create(usb_class->class, &intf->dev,
201 : 0 : MKDEV(USB_MAJOR, minor), class_driver,
202 : : "%s", temp);
203 [ # # ]: 0 : if (IS_ERR(intf->usb_dev)) {
204 : 0 : down_write(&minor_rwsem);
205 : 0 : usb_minors[minor] = NULL;
206 : 0 : intf->minor = -1;
207 : 0 : up_write(&minor_rwsem);
208 : 0 : retval = PTR_ERR(intf->usb_dev);
209 : : }
210 : 0 : 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 : : */
228 : 0 : void usb_deregister_dev(struct usb_interface *intf,
229 : : struct usb_class_driver *class_driver)
230 : : {
231 [ # # ]: 0 : if (intf->minor == -1)
232 : 0 : return;
233 : :
234 : : dev_dbg(&intf->dev, "removing %d minor\n", intf->minor);
235 : :
236 : 0 : down_write(&minor_rwsem);
237 : 0 : usb_minors[intf->minor] = NULL;
238 : 0 : up_write(&minor_rwsem);
239 : :
240 : 0 : device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
241 : 0 : intf->usb_dev = NULL;
242 : 0 : intf->minor = -1;
243 : 0 : destroy_usb_class();
244 : : }
245 : : EXPORT_SYMBOL_GPL(usb_deregister_dev);
|
