]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/usb/usbip/stub_dev.c
Merge remote-tracking branch 'asoc/fix/pcm' into asoc-linus
[karo-tx-linux.git] / drivers / usb / usbip / stub_dev.c
1 /*
2  * Copyright (C) 2003-2008 Takahiro Hirofuchi
3  *
4  * This is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17  * USA.
18  */
19
20 #include <linux/device.h>
21 #include <linux/file.h>
22 #include <linux/kthread.h>
23 #include <linux/module.h>
24
25 #include "usbip_common.h"
26 #include "stub.h"
27
28 /*
29  * usbip_status shows the status of usbip-host as long as this driver is bound
30  * to the target device.
31  */
32 static ssize_t usbip_status_show(struct device *dev,
33                                  struct device_attribute *attr, char *buf)
34 {
35         struct stub_device *sdev = dev_get_drvdata(dev);
36         int status;
37
38         if (!sdev) {
39                 dev_err(dev, "sdev is null\n");
40                 return -ENODEV;
41         }
42
43         spin_lock_irq(&sdev->ud.lock);
44         status = sdev->ud.status;
45         spin_unlock_irq(&sdev->ud.lock);
46
47         return snprintf(buf, PAGE_SIZE, "%d\n", status);
48 }
49 static DEVICE_ATTR_RO(usbip_status);
50
51 /*
52  * usbip_sockfd gets a socket descriptor of an established TCP connection that
53  * is used to transfer usbip requests by kernel threads. -1 is a magic number
54  * by which usbip connection is finished.
55  */
56 static ssize_t store_sockfd(struct device *dev, struct device_attribute *attr,
57                             const char *buf, size_t count)
58 {
59         struct stub_device *sdev = dev_get_drvdata(dev);
60         int sockfd = 0;
61         struct socket *socket;
62         int rv;
63
64         if (!sdev) {
65                 dev_err(dev, "sdev is null\n");
66                 return -ENODEV;
67         }
68
69         rv = sscanf(buf, "%d", &sockfd);
70         if (rv != 1)
71                 return -EINVAL;
72
73         if (sockfd != -1) {
74                 int err;
75
76                 dev_info(dev, "stub up\n");
77
78                 spin_lock_irq(&sdev->ud.lock);
79
80                 if (sdev->ud.status != SDEV_ST_AVAILABLE) {
81                         dev_err(dev, "not ready\n");
82                         goto err;
83                 }
84
85                 socket = sockfd_lookup(sockfd, &err);
86                 if (!socket)
87                         goto err;
88
89                 sdev->ud.tcp_socket = socket;
90
91                 spin_unlock_irq(&sdev->ud.lock);
92
93                 sdev->ud.tcp_rx = kthread_get_run(stub_rx_loop, &sdev->ud,
94                                                   "stub_rx");
95                 sdev->ud.tcp_tx = kthread_get_run(stub_tx_loop, &sdev->ud,
96                                                   "stub_tx");
97
98                 spin_lock_irq(&sdev->ud.lock);
99                 sdev->ud.status = SDEV_ST_USED;
100                 spin_unlock_irq(&sdev->ud.lock);
101
102         } else {
103                 dev_info(dev, "stub down\n");
104
105                 spin_lock_irq(&sdev->ud.lock);
106                 if (sdev->ud.status != SDEV_ST_USED)
107                         goto err;
108
109                 spin_unlock_irq(&sdev->ud.lock);
110
111                 usbip_event_add(&sdev->ud, SDEV_EVENT_DOWN);
112         }
113
114         return count;
115
116 err:
117         spin_unlock_irq(&sdev->ud.lock);
118         return -EINVAL;
119 }
120 static DEVICE_ATTR(usbip_sockfd, S_IWUSR, NULL, store_sockfd);
121
122 static int stub_add_files(struct device *dev)
123 {
124         int err = 0;
125
126         err = device_create_file(dev, &dev_attr_usbip_status);
127         if (err)
128                 goto err_status;
129
130         err = device_create_file(dev, &dev_attr_usbip_sockfd);
131         if (err)
132                 goto err_sockfd;
133
134         err = device_create_file(dev, &dev_attr_usbip_debug);
135         if (err)
136                 goto err_debug;
137
138         return 0;
139
140 err_debug:
141         device_remove_file(dev, &dev_attr_usbip_sockfd);
142 err_sockfd:
143         device_remove_file(dev, &dev_attr_usbip_status);
144 err_status:
145         return err;
146 }
147
148 static void stub_remove_files(struct device *dev)
149 {
150         device_remove_file(dev, &dev_attr_usbip_status);
151         device_remove_file(dev, &dev_attr_usbip_sockfd);
152         device_remove_file(dev, &dev_attr_usbip_debug);
153 }
154
155 static void stub_shutdown_connection(struct usbip_device *ud)
156 {
157         struct stub_device *sdev = container_of(ud, struct stub_device, ud);
158
159         /*
160          * When removing an exported device, kernel panic sometimes occurred
161          * and then EIP was sk_wait_data of stub_rx thread. Is this because
162          * sk_wait_data returned though stub_rx thread was already finished by
163          * step 1?
164          */
165         if (ud->tcp_socket) {
166                 dev_dbg(&sdev->udev->dev, "shutdown tcp_socket %p\n",
167                         ud->tcp_socket);
168                 kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
169         }
170
171         /* 1. stop threads */
172         if (ud->tcp_rx) {
173                 kthread_stop_put(ud->tcp_rx);
174                 ud->tcp_rx = NULL;
175         }
176         if (ud->tcp_tx) {
177                 kthread_stop_put(ud->tcp_tx);
178                 ud->tcp_tx = NULL;
179         }
180
181         /*
182          * 2. close the socket
183          *
184          * tcp_socket is freed after threads are killed so that usbip_xmit does
185          * not touch NULL socket.
186          */
187         if (ud->tcp_socket) {
188                 sockfd_put(ud->tcp_socket);
189                 ud->tcp_socket = NULL;
190         }
191
192         /* 3. free used data */
193         stub_device_cleanup_urbs(sdev);
194
195         /* 4. free stub_unlink */
196         {
197                 unsigned long flags;
198                 struct stub_unlink *unlink, *tmp;
199
200                 spin_lock_irqsave(&sdev->priv_lock, flags);
201                 list_for_each_entry_safe(unlink, tmp, &sdev->unlink_tx, list) {
202                         list_del(&unlink->list);
203                         kfree(unlink);
204                 }
205                 list_for_each_entry_safe(unlink, tmp, &sdev->unlink_free,
206                                          list) {
207                         list_del(&unlink->list);
208                         kfree(unlink);
209                 }
210                 spin_unlock_irqrestore(&sdev->priv_lock, flags);
211         }
212 }
213
214 static void stub_device_reset(struct usbip_device *ud)
215 {
216         struct stub_device *sdev = container_of(ud, struct stub_device, ud);
217         struct usb_device *udev = sdev->udev;
218         int ret;
219
220         dev_dbg(&udev->dev, "device reset");
221
222         ret = usb_lock_device_for_reset(udev, sdev->interface);
223         if (ret < 0) {
224                 dev_err(&udev->dev, "lock for reset\n");
225                 spin_lock_irq(&ud->lock);
226                 ud->status = SDEV_ST_ERROR;
227                 spin_unlock_irq(&ud->lock);
228                 return;
229         }
230
231         /* try to reset the device */
232         ret = usb_reset_device(udev);
233         usb_unlock_device(udev);
234
235         spin_lock_irq(&ud->lock);
236         if (ret) {
237                 dev_err(&udev->dev, "device reset\n");
238                 ud->status = SDEV_ST_ERROR;
239         } else {
240                 dev_info(&udev->dev, "device reset\n");
241                 ud->status = SDEV_ST_AVAILABLE;
242         }
243         spin_unlock_irq(&ud->lock);
244 }
245
246 static void stub_device_unusable(struct usbip_device *ud)
247 {
248         spin_lock_irq(&ud->lock);
249         ud->status = SDEV_ST_ERROR;
250         spin_unlock_irq(&ud->lock);
251 }
252
253 /**
254  * stub_device_alloc - allocate a new stub_device struct
255  * @interface: usb_interface of a new device
256  *
257  * Allocates and initializes a new stub_device struct.
258  */
259 static struct stub_device *stub_device_alloc(struct usb_device *udev)
260 {
261         struct stub_device *sdev;
262         int busnum = udev->bus->busnum;
263         int devnum = udev->devnum;
264
265         dev_dbg(&udev->dev, "allocating stub device");
266
267         /* yes, it's a new device */
268         sdev = kzalloc(sizeof(struct stub_device), GFP_KERNEL);
269         if (!sdev)
270                 return NULL;
271
272         sdev->udev = usb_get_dev(udev);
273
274         /*
275          * devid is defined with devnum when this driver is first allocated.
276          * devnum may change later if a device is reset. However, devid never
277          * changes during a usbip connection.
278          */
279         sdev->devid             = (busnum << 16) | devnum;
280         sdev->ud.side           = USBIP_STUB;
281         sdev->ud.status         = SDEV_ST_AVAILABLE;
282         spin_lock_init(&sdev->ud.lock);
283         sdev->ud.tcp_socket     = NULL;
284
285         INIT_LIST_HEAD(&sdev->priv_init);
286         INIT_LIST_HEAD(&sdev->priv_tx);
287         INIT_LIST_HEAD(&sdev->priv_free);
288         INIT_LIST_HEAD(&sdev->unlink_free);
289         INIT_LIST_HEAD(&sdev->unlink_tx);
290         spin_lock_init(&sdev->priv_lock);
291
292         init_waitqueue_head(&sdev->tx_waitq);
293
294         sdev->ud.eh_ops.shutdown = stub_shutdown_connection;
295         sdev->ud.eh_ops.reset    = stub_device_reset;
296         sdev->ud.eh_ops.unusable = stub_device_unusable;
297
298         usbip_start_eh(&sdev->ud);
299
300         dev_dbg(&udev->dev, "register new device\n");
301
302         return sdev;
303 }
304
305 static void stub_device_free(struct stub_device *sdev)
306 {
307         kfree(sdev);
308 }
309
310 static int stub_probe(struct usb_device *udev)
311 {
312         struct stub_device *sdev = NULL;
313         const char *udev_busid = dev_name(&udev->dev);
314         int err = 0;
315         struct bus_id_priv *busid_priv;
316         int rc;
317
318         dev_dbg(&udev->dev, "Enter\n");
319
320         /* check we should claim or not by busid_table */
321         busid_priv = get_busid_priv(udev_busid);
322         if (!busid_priv || (busid_priv->status == STUB_BUSID_REMOV) ||
323             (busid_priv->status == STUB_BUSID_OTHER)) {
324                 dev_info(&udev->dev,
325                         "%s is not in match_busid table... skip!\n",
326                         udev_busid);
327
328                 /*
329                  * Return value should be ENODEV or ENOXIO to continue trying
330                  * other matched drivers by the driver core.
331                  * See driver_probe_device() in driver/base/dd.c
332                  */
333                 return -ENODEV;
334         }
335
336         if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) {
337                 dev_dbg(&udev->dev, "%s is a usb hub device... skip!\n",
338                          udev_busid);
339                 return -ENODEV;
340         }
341
342         if (!strcmp(udev->bus->bus_name, "vhci_hcd")) {
343                 dev_dbg(&udev->dev,
344                         "%s is attached on vhci_hcd... skip!\n",
345                         udev_busid);
346
347                 return -ENODEV;
348         }
349
350         /* ok, this is my device */
351         sdev = stub_device_alloc(udev);
352         if (!sdev)
353                 return -ENOMEM;
354
355         dev_info(&udev->dev,
356                 "usbip-host: register new device (bus %u dev %u)\n",
357                 udev->bus->busnum, udev->devnum);
358
359         busid_priv->shutdown_busid = 0;
360
361         /* set private data to usb_device */
362         dev_set_drvdata(&udev->dev, sdev);
363         busid_priv->sdev = sdev;
364         busid_priv->udev = udev;
365
366         /*
367          * Claim this hub port.
368          * It doesn't matter what value we pass as owner
369          * (struct dev_state) as long as it is unique.
370          */
371         rc = usb_hub_claim_port(udev->parent, udev->portnum,
372                         (struct usb_dev_state *) udev);
373         if (rc) {
374                 dev_dbg(&udev->dev, "unable to claim port\n");
375                 return rc;
376         }
377
378         err = stub_add_files(&udev->dev);
379         if (err) {
380                 dev_err(&udev->dev, "stub_add_files for %s\n", udev_busid);
381                 dev_set_drvdata(&udev->dev, NULL);
382                 usb_put_dev(udev);
383                 kthread_stop_put(sdev->ud.eh);
384
385                 busid_priv->sdev = NULL;
386                 stub_device_free(sdev);
387                 return err;
388         }
389         busid_priv->status = STUB_BUSID_ALLOC;
390
391         return 0;
392 }
393
394 static void shutdown_busid(struct bus_id_priv *busid_priv)
395 {
396         if (busid_priv->sdev && !busid_priv->shutdown_busid) {
397                 busid_priv->shutdown_busid = 1;
398                 usbip_event_add(&busid_priv->sdev->ud, SDEV_EVENT_REMOVED);
399
400                 /* wait for the stop of the event handler */
401                 usbip_stop_eh(&busid_priv->sdev->ud);
402         }
403 }
404
405 /*
406  * called in usb_disconnect() or usb_deregister()
407  * but only if actconfig(active configuration) exists
408  */
409 static void stub_disconnect(struct usb_device *udev)
410 {
411         struct stub_device *sdev;
412         const char *udev_busid = dev_name(&udev->dev);
413         struct bus_id_priv *busid_priv;
414         int rc;
415
416         dev_dbg(&udev->dev, "Enter\n");
417
418         busid_priv = get_busid_priv(udev_busid);
419         if (!busid_priv) {
420                 BUG();
421                 return;
422         }
423
424         sdev = dev_get_drvdata(&udev->dev);
425
426         /* get stub_device */
427         if (!sdev) {
428                 dev_err(&udev->dev, "could not get device");
429                 return;
430         }
431
432         dev_set_drvdata(&udev->dev, NULL);
433
434         /*
435          * NOTE: rx/tx threads are invoked for each usb_device.
436          */
437         stub_remove_files(&udev->dev);
438
439         /* release port */
440         rc = usb_hub_release_port(udev->parent, udev->portnum,
441                                   (struct usb_dev_state *) udev);
442         if (rc) {
443                 dev_dbg(&udev->dev, "unable to release port\n");
444                 return;
445         }
446
447         /* If usb reset is called from event handler */
448         if (busid_priv->sdev->ud.eh == current)
449                 return;
450
451         /* shutdown the current connection */
452         shutdown_busid(busid_priv);
453
454         usb_put_dev(sdev->udev);
455
456         /* free sdev */
457         busid_priv->sdev = NULL;
458         stub_device_free(sdev);
459
460         if (busid_priv->status == STUB_BUSID_ALLOC) {
461                 busid_priv->status = STUB_BUSID_ADDED;
462         } else {
463                 busid_priv->status = STUB_BUSID_OTHER;
464                 del_match_busid((char *)udev_busid);
465         }
466 }
467
468 #ifdef CONFIG_PM
469
470 /* These functions need usb_port_suspend and usb_port_resume,
471  * which reside in drivers/usb/core/usb.h. Skip for now. */
472
473 static int stub_suspend(struct usb_device *udev, pm_message_t message)
474 {
475         dev_dbg(&udev->dev, "stub_suspend\n");
476
477         return 0;
478 }
479
480 static int stub_resume(struct usb_device *udev, pm_message_t message)
481 {
482         dev_dbg(&udev->dev, "stub_resume\n");
483
484         return 0;
485 }
486
487 #endif  /* CONFIG_PM */
488
489 struct usb_device_driver stub_driver = {
490         .name           = "usbip-host",
491         .probe          = stub_probe,
492         .disconnect     = stub_disconnect,
493 #ifdef CONFIG_PM
494         .suspend        = stub_suspend,
495         .resume         = stub_resume,
496 #endif
497         .supports_autosuspend   =       0,
498 };