USB: serial: sierra: clean up urb->status usage
[linux-2.6] / drivers / usb / serial / bus.c
1 /*
2  * USB Serial Converter Bus specific functions
3  *
4  * Copyright (C) 2002 Greg Kroah-Hartman (greg@kroah.com)
5  *
6  *      This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License version
8  *      2 as published by the Free Software Foundation.
9  */
10
11 #include <linux/kernel.h>
12 #include <linux/errno.h>
13 #include <linux/tty.h>
14 #include <linux/module.h>
15 #include <linux/usb.h>
16 #include <linux/usb/serial.h>
17
18 static int usb_serial_device_match (struct device *dev, struct device_driver *drv)
19 {
20         struct usb_serial_driver *driver;
21         const struct usb_serial_port *port;
22
23         /*
24          * drivers are already assigned to ports in serial_probe so it's
25          * a simple check here.
26          */
27         port = to_usb_serial_port(dev);
28         if (!port)
29                 return 0;
30
31         driver = to_usb_serial_driver(drv);
32
33         if (driver == port->serial->type)
34                 return 1;
35
36         return 0;
37 }
38
39 static int usb_serial_device_probe (struct device *dev)
40 {
41         struct usb_serial_driver *driver;
42         struct usb_serial_port *port;
43         int retval = 0;
44         int minor;
45
46         port = to_usb_serial_port(dev);
47         if (!port) {
48                 retval = -ENODEV;
49                 goto exit;
50         }
51
52         driver = port->serial->type;
53         if (driver->port_probe) {
54                 if (!try_module_get(driver->driver.owner)) {
55                         dev_err(dev, "module get failed, exiting\n");
56                         retval = -EIO;
57                         goto exit;
58                 }
59                 retval = driver->port_probe (port);
60                 module_put(driver->driver.owner);
61                 if (retval)
62                         goto exit;
63         }
64
65         minor = port->number;
66         tty_register_device (usb_serial_tty_driver, minor, dev);
67         dev_info(&port->serial->dev->dev, 
68                  "%s converter now attached to ttyUSB%d\n",
69                  driver->description, minor);
70
71 exit:
72         return retval;
73 }
74
75 static int usb_serial_device_remove (struct device *dev)
76 {
77         struct usb_serial_driver *driver;
78         struct usb_serial_port *port;
79         int retval = 0;
80         int minor;
81
82         port = to_usb_serial_port(dev);
83         if (!port) {
84                 return -ENODEV;
85         }
86
87         driver = port->serial->type;
88         if (driver->port_remove) {
89                 if (!try_module_get(driver->driver.owner)) {
90                         dev_err(dev, "module get failed, exiting\n");
91                         retval = -EIO;
92                         goto exit;
93                 }
94                 retval = driver->port_remove (port);
95                 module_put(driver->driver.owner);
96         }
97 exit:
98         minor = port->number;
99         tty_unregister_device (usb_serial_tty_driver, minor);
100         dev_info(dev, "%s converter now disconnected from ttyUSB%d\n",
101                  driver->description, minor);
102
103         return retval;
104 }
105
106 #ifdef CONFIG_HOTPLUG
107 static ssize_t store_new_id(struct device_driver *driver,
108                             const char *buf, size_t count)
109 {
110         struct usb_serial_driver *usb_drv = to_usb_serial_driver(driver);
111         ssize_t retval = usb_store_new_id(&usb_drv->dynids, driver, buf, count);
112
113         if (retval >= 0 && usb_drv->usb_driver != NULL)
114                 retval = usb_store_new_id(&usb_drv->usb_driver->dynids,
115                                           &usb_drv->usb_driver->drvwrap.driver,
116                                           buf, count);
117         return retval;
118 }
119
120 static struct driver_attribute drv_attrs[] = {
121         __ATTR(new_id, S_IWUSR, NULL, store_new_id),
122         __ATTR_NULL,
123 };
124
125 static void free_dynids(struct usb_serial_driver *drv)
126 {
127         struct usb_dynid *dynid, *n;
128
129         spin_lock(&drv->dynids.lock);
130         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
131                 list_del(&dynid->node);
132                 kfree(dynid);
133         }
134         spin_unlock(&drv->dynids.lock);
135 }
136
137 #else
138 static struct driver_attribute drv_attrs[] = {
139         __ATTR_NULL,
140 };
141 static inline void free_dynids(struct usb_driver *drv)
142 {
143 }
144 #endif
145
146 struct bus_type usb_serial_bus_type = {
147         .name =         "usb-serial",
148         .match =        usb_serial_device_match,
149         .probe =        usb_serial_device_probe,
150         .remove =       usb_serial_device_remove,
151         .drv_attrs =    drv_attrs,
152 };
153
154 int usb_serial_bus_register(struct usb_serial_driver *driver)
155 {
156         int retval;
157
158         driver->driver.bus = &usb_serial_bus_type;
159         spin_lock_init(&driver->dynids.lock);
160         INIT_LIST_HEAD(&driver->dynids.list);
161
162         retval = driver_register(&driver->driver);
163
164         return retval;
165 }
166
167 void usb_serial_bus_deregister(struct usb_serial_driver *driver)
168 {
169         free_dynids(driver);
170         driver_unregister(&driver->driver);
171 }
172