35b6969664793fce3533681f551070ae0091b0b3
[linux-3.10.git] / drivers / net / usb / raw_ip_net.c
1 /*
2  * raw_ip_net.c
3  *
4  * USB network driver for RAW-IP modems.
5  *
6  * Copyright (c) 2011, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kernel.h>
27 #include <linux/fs.h>
28 #include <linux/errno.h>
29 #include <linux/types.h>
30 #include <linux/etherdevice.h>
31 #include <linux/usb.h>
32
33 #define BASEBAND_USB_NET_DEV_NAME               "rmnet%d"
34
35 /* ethernet packet ethertype for IP packets */
36 #define NET_IP_ETHERTYPE                0x08, 0x00
37
38 #define TX_TIMEOUT              10
39
40 #ifndef USB_NET_BUFSIZ
41 #define USB_NET_BUFSIZ                          8192
42 #endif  /* USB_NET_BUFSIZ */
43
44 /* maximum interface number supported */
45 #define MAX_INTFS       3
46
47 MODULE_LICENSE("GPL");
48
49 int g_i;
50
51 int max_intfs = MAX_INTFS;
52 unsigned long usb_net_raw_ip_vid = 0x1519;
53 unsigned long usb_net_raw_ip_pid = 0x0020;
54 unsigned long usb_net_raw_ip_intf[MAX_INTFS] = { 0x03, 0x05, 0x07 };
55 unsigned long usb_net_raw_ip_rx_debug;
56 unsigned long usb_net_raw_ip_tx_debug;
57
58 module_param(max_intfs, int, 0644);
59 MODULE_PARM_DESC(max_intfs, "usb net (raw-ip) - max. interfaces supported");
60 module_param(usb_net_raw_ip_vid, ulong, 0644);
61 MODULE_PARM_DESC(usb_net_raw_ip_vid, "usb net (raw-ip) - USB VID");
62 module_param(usb_net_raw_ip_pid, ulong, 0644);
63 MODULE_PARM_DESC(usb_net_raw_ip_pid, "usb net (raw-ip) - USB PID");
64 module_param(usb_net_raw_ip_rx_debug, ulong, 0644);
65 MODULE_PARM_DESC(usb_net_raw_ip_rx_debug, "usb net (raw-ip) - rx debug");
66 module_param(usb_net_raw_ip_tx_debug, ulong, 0644);
67 MODULE_PARM_DESC(usb_net_raw_ip_tx_debug, "usb net (raw-ip) - tx debug");
68
69 struct baseband_usb {
70         int baseband_index;
71         struct net_device_stats stats;
72         struct {
73                 struct usb_driver *driver;
74                 struct usb_device *device;
75                 struct usb_interface *interface;
76                 struct {
77                         struct {
78                                 unsigned int in;
79                                 unsigned int out;
80                         } isoch, bulk, interrupt;
81                 } pipe;
82                 /* currently active rx urb */
83                 struct urb *rx_urb;
84                 /* currently active tx urb */
85                 struct urb *tx_urb;
86                 struct usb_anchor tx_urb_deferred;
87                 struct workqueue_struct *tx_workqueue;
88                 struct work_struct tx_work;
89         } usb;
90         struct urb *urb_r;
91         void *buff;
92 };
93
94 static struct baseband_usb *baseband_usb_net[MAX_INTFS] = { 0, 0, 0};
95
96 static struct net_device *usb_net_raw_ip_dev[MAX_INTFS] = { 0, 0, 0};
97
98 static unsigned int g_usb_interface_index[MAX_INTFS];
99 static struct usb_interface *g_usb_interface[MAX_INTFS];
100
101 static int usb_net_raw_ip_rx_urb_submit(struct baseband_usb *usb);
102 static void usb_net_raw_ip_rx_urb_comp(struct urb *urb);
103
104 static int usb_net_raw_ip_tx_urb_submit(struct baseband_usb *usb,
105         struct sk_buff *skb);
106 static void usb_net_raw_ip_tx_urb_work(struct work_struct *work);
107 static void usb_net_raw_ip_tx_urb_comp(struct urb *urb);
108
109 static int baseband_usb_driver_probe(struct usb_interface *intf,
110         const struct usb_device_id *id)
111 {
112         int i = g_i;
113
114         pr_debug("%s(%d) { intf %p id %p\n", __func__, __LINE__, intf, id);
115
116         pr_debug("i %d\n", i);
117
118         pr_debug("intf->cur_altsetting->desc.bInterfaceNumber %02x\n",
119                 intf->cur_altsetting->desc.bInterfaceNumber);
120         pr_debug("intf->cur_altsetting->desc.bAlternateSetting %02x\n",
121                 intf->cur_altsetting->desc.bAlternateSetting);
122         pr_debug("intf->cur_altsetting->desc.bNumEndpoints %02x\n",
123                 intf->cur_altsetting->desc.bNumEndpoints);
124         pr_debug("intf->cur_altsetting->desc.bInterfaceClass %02x\n",
125                 intf->cur_altsetting->desc.bInterfaceClass);
126         pr_debug("intf->cur_altsetting->desc.bInterfaceSubClass %02x\n",
127                 intf->cur_altsetting->desc.bInterfaceSubClass);
128         pr_debug("intf->cur_altsetting->desc.bInterfaceProtocol %02x\n",
129                 intf->cur_altsetting->desc.bInterfaceProtocol);
130         pr_debug("intf->cur_altsetting->desc.iInterface %02x\n",
131                 intf->cur_altsetting->desc.iInterface);
132
133         if (g_usb_interface_index[i] !=
134                 intf->cur_altsetting->desc.bInterfaceNumber) {
135                 pr_debug("%s(%d) } -ENODEV\n", __func__, __LINE__);
136                 return -ENODEV;
137         } else {
138                 g_usb_interface[i] = intf;
139         }
140
141         pr_debug("%s(%d) }\n", __func__, __LINE__);
142         return 0;
143 }
144
145 static void baseband_usb_driver_disconnect(struct usb_interface *intf)
146 {
147         int i;
148         struct urb *urb;
149
150         pr_debug("%s intf %p\n", __func__, intf);
151
152         for (i = 0; i < max_intfs; i++) {
153                 pr_debug("[%d]\n", i);
154                 if (!baseband_usb_net[i])
155                         continue;
156                 if (baseband_usb_net[i]->usb.interface != intf) {
157                         pr_debug("%p != %p\n",
158                                 baseband_usb_net[i]->usb.interface, intf);
159                         continue;
160                 }
161                 /* kill usb tx */
162                 while ((urb = usb_get_from_anchor(&baseband_usb_net[i]->
163                         usb.tx_urb_deferred)) != (struct urb *) 0) {
164                         pr_info("%s: kill deferred tx urb %p\n",
165                                 __func__, urb);
166                         /* decrement count from usb_get_from_anchor() */
167                         usb_free_urb(urb);
168                         /* kill tx urb */
169                         usb_kill_urb(urb);
170                         /* free tx urb + tx urb transfer buffer */
171                         if (urb->transfer_buffer) {
172                                 kfree(urb->transfer_buffer);
173                                 urb->transfer_buffer = (void *) 0;
174                         }
175                         usb_free_urb(urb);
176                 }
177                 if (baseband_usb_net[i]->usb.tx_workqueue) {
178                         flush_workqueue(baseband_usb_net[i]
179                                 ->usb.tx_workqueue);
180                 }
181                 if (baseband_usb_net[i]->usb.tx_urb) {
182                         usb_kill_urb(baseband_usb_net[i]->usb.tx_urb);
183                         baseband_usb_net[i]->usb.tx_urb
184                                 = (struct urb *) 0;
185                 }
186                 /* kill usb rx */
187                 if (baseband_usb_net[i]->usb.rx_urb) {
188                         usb_kill_urb(baseband_usb_net[i]->usb.rx_urb);
189                         baseband_usb_net[i]->usb.rx_urb
190                                 = (struct urb *) 0;
191                 }
192                 /* mark interface as disconnected */
193                 baseband_usb_net[i]->usb.interface
194                         = (struct usb_interface *) 0;
195         }
196
197 }
198
199 #ifdef CONFIG_PM
200 static int baseband_usb_driver_suspend(struct usb_interface *intf,
201         pm_message_t message)
202 {
203         int i;
204
205         pr_debug("%s intf %p\n", __func__, intf);
206
207         for (i = 0; i < max_intfs; i++) {
208                 pr_debug("[%d]\n", i);
209                 if (!baseband_usb_net[i])
210                         continue;
211                 if (baseband_usb_net[i]->usb.interface != intf) {
212                         pr_debug("%p != %p\n",
213                                 baseband_usb_net[i]->usb.interface, intf);
214                         continue;
215                 }
216                 /* kill usb rx */
217                 if (!baseband_usb_net[i]->usb.rx_urb) {
218                         pr_debug("rx_usb already killed\n");
219                         continue;
220                 }
221                 usb_kill_urb(baseband_usb_net[i]->usb.rx_urb);
222                 baseband_usb_net[i]->usb.rx_urb = (struct urb *) 0;
223         }
224
225         return 0;
226 }
227
228 static int baseband_usb_driver_resume(struct usb_interface *intf)
229 {
230         int i, err;
231
232         pr_debug("%s intf %p\n", __func__, intf);
233
234         for (i = 0; i < max_intfs; i++) {
235                 pr_debug("[%d]\n", i);
236                 if (!baseband_usb_net[i])
237                         continue;
238                 if (baseband_usb_net[i]->usb.interface != intf) {
239                         pr_debug("%p != %p\n",
240                                 baseband_usb_net[i]->usb.interface, intf);
241                         continue;
242                 }
243                 /* start usb rx */
244                 if (baseband_usb_net[i]->usb.rx_urb) {
245                         pr_debug("rx_usb already exists\n");
246                         continue;
247                 }
248                 err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
249                 if (err < 0) {
250                         pr_err("submit rx failed - err %d\n", err);
251                         continue;
252                 }
253         }
254
255         return 0;
256 }
257 static int baseband_usb_driver_reset_resume(struct usb_interface *intf)
258 {
259         pr_debug("%s intf %p\n", __func__, intf);
260         return baseband_usb_driver_resume(intf);
261 }
262 #endif /* CONFIG_PM */
263
264 static struct usb_device_id baseband_usb_driver_id_table[MAX_INTFS][2];
265
266 static char baseband_usb_driver_name[MAX_INTFS][32];
267
268 static struct usb_driver baseband_usb_driver[MAX_INTFS] = {
269         {
270                 .name = baseband_usb_driver_name[0],
271                 .probe = baseband_usb_driver_probe,
272                 .disconnect = baseband_usb_driver_disconnect,
273                 .id_table = baseband_usb_driver_id_table[0],
274 #ifdef CONFIG_PM
275                 .suspend = baseband_usb_driver_suspend,
276                 .resume = baseband_usb_driver_resume,
277                 .reset_resume = baseband_usb_driver_reset_resume,
278                 .supports_autosuspend = 1,
279 #endif
280         },
281         {
282                 .name = baseband_usb_driver_name[1],
283                 .probe = baseband_usb_driver_probe,
284                 .disconnect = baseband_usb_driver_disconnect,
285                 .id_table = baseband_usb_driver_id_table[1],
286 #ifdef CONFIG_PM
287                 .suspend = baseband_usb_driver_suspend,
288                 .resume = baseband_usb_driver_resume,
289                 .reset_resume = baseband_usb_driver_reset_resume,
290                 .supports_autosuspend = 1,
291 #endif
292         },
293         {
294                 .name = baseband_usb_driver_name[2],
295                 .probe = baseband_usb_driver_probe,
296                 .disconnect = baseband_usb_driver_disconnect,
297                 .id_table = baseband_usb_driver_id_table[2],
298 #ifdef CONFIG_PM
299                 .suspend = baseband_usb_driver_suspend,
300                 .resume = baseband_usb_driver_resume,
301                 .reset_resume = baseband_usb_driver_reset_resume,
302                 .supports_autosuspend = 1,
303 #endif
304         },
305 };
306
307 static void find_usb_pipe(struct baseband_usb *usb)
308 {
309         struct usb_device *usbdev = usb->usb.device;
310         struct usb_interface *intf = usb->usb.interface;
311         unsigned char numendpoint = intf->cur_altsetting->desc.bNumEndpoints;
312         struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
313         unsigned char n;
314
315         for (n = 0; n < numendpoint; n++) {
316                 if (usb_endpoint_is_isoc_in(&endpoint[n].desc)) {
317                         pr_debug("endpoint[%d] isochronous in\n", n);
318                         usb->usb.pipe.isoch.in = usb_rcvisocpipe(usbdev,
319                                 endpoint[n].desc.bEndpointAddress);
320                 } else if (usb_endpoint_is_isoc_out(&endpoint[n].desc)) {
321                         pr_debug("endpoint[%d] isochronous out\n", n);
322                         usb->usb.pipe.isoch.out = usb_sndisocpipe(usbdev,
323                                 endpoint[n].desc.bEndpointAddress);
324                 } else if (usb_endpoint_is_bulk_in(&endpoint[n].desc)) {
325                         pr_debug("endpoint[%d] bulk in\n", n);
326                         usb->usb.pipe.bulk.in = usb_rcvbulkpipe(usbdev,
327                                 endpoint[n].desc.bEndpointAddress);
328                 } else if (usb_endpoint_is_bulk_out(&endpoint[n].desc)) {
329                         pr_debug("endpoint[%d] bulk out\n", n);
330                         usb->usb.pipe.bulk.out = usb_sndbulkpipe(usbdev,
331                                 endpoint[n].desc.bEndpointAddress);
332                 } else if (usb_endpoint_is_int_in(&endpoint[n].desc)) {
333                         pr_debug("endpoint[%d] interrupt in\n", n);
334                         usb->usb.pipe.interrupt.in = usb_rcvintpipe(usbdev,
335                                 endpoint[n].desc.bEndpointAddress);
336                 } else if (usb_endpoint_is_int_out(&endpoint[n].desc)) {
337                         pr_debug("endpoint[%d] interrupt out\n", n);
338                         usb->usb.pipe.interrupt.out = usb_sndintpipe(usbdev,
339                                 endpoint[n].desc.bEndpointAddress);
340                 } else {
341                         pr_debug("endpoint[%d] skipped\n", n);
342                 }
343         }
344 }
345
346 void baseband_usb_close(struct baseband_usb *usb);
347
348 struct baseband_usb *baseband_usb_open(int index,
349         unsigned int vid,
350         unsigned int pid,
351         unsigned int intf)
352 {
353         struct baseband_usb *usb;
354         int err;
355
356         pr_debug("baseband_usb_open {\n");
357
358         /* allocate baseband usb structure */
359         usb = kzalloc(sizeof(struct baseband_usb),
360                 GFP_KERNEL);
361         if (!usb)
362                 return (struct baseband_usb *) 0;
363
364         /* open usb driver */
365         sprintf(baseband_usb_driver_name[index],
366                 "baseband_usb_%x_%x_%x",
367                 vid, pid, intf);
368         baseband_usb_driver_id_table[index][0].match_flags =
369                 USB_DEVICE_ID_MATCH_DEVICE;
370         baseband_usb_driver_id_table[index][0].idVendor = vid;
371         baseband_usb_driver_id_table[index][0].idProduct = pid;
372         g_usb_interface_index[index] = intf;
373         g_usb_interface[index] = (struct usb_interface *) 0;
374         err = usb_register(&baseband_usb_driver[index]);
375         if (err < 0) {
376                 pr_err("cannot open usb driver - err %d\n", err);
377                 kfree(usb);
378                 return (struct baseband_usb *) 0;
379         }
380         usb->baseband_index = index;
381         usb->usb.driver = &baseband_usb_driver[index];
382         if (!g_usb_interface[index]) {
383                 pr_err("cannot open usb driver - !g_usb_interface[%d]\n",
384                         index);
385                 usb_deregister(usb->usb.driver);
386                 kfree(usb);
387                 return (struct baseband_usb *) 0;
388         }
389         usb->usb.device = interface_to_usbdev(g_usb_interface[index]);
390         usb->usb.interface = g_usb_interface[index];
391         find_usb_pipe(usb);
392         usb->usb.rx_urb = (struct urb *) 0;
393         usb->usb.tx_urb = (struct urb *) 0;
394         g_usb_interface_index[index] = ~0U;
395         g_usb_interface[index] = (struct usb_interface *) 0;
396         pr_debug("usb->usb.driver->name %s\n", usb->usb.driver->name);
397         pr_debug("usb->usb.device %p\n", usb->usb.device);
398         pr_debug("usb->usb.interface %p\n", usb->usb.interface);
399         pr_debug("usb->usb.pipe.isoch.in %x\n", usb->usb.pipe.isoch.in);
400         pr_debug("usb->usb.pipe.isoch.out %x\n", usb->usb.pipe.isoch.out);
401         pr_debug("usb->usb.pipe.bulk.in %x\n", usb->usb.pipe.bulk.in);
402         pr_debug("usb->usb.pipe.bulk.out %x\n", usb->usb.pipe.bulk.out);
403         pr_debug("usb->usb.pipe.interrupt.in %x\n", usb->usb.pipe.interrupt.in);
404         pr_debug("usb->usb.pipe.interrupt.out %x\n",
405                 usb->usb.pipe.interrupt.out);
406
407         pr_debug("baseband_usb_open }\n");
408         return usb;
409 }
410
411 void baseband_usb_close(struct baseband_usb *usb)
412 {
413         pr_debug("baseband_usb_close {\n");
414
415         /* check input */
416         if (!usb)
417                 return;
418
419         /* close usb driver */
420         if (usb->usb.driver) {
421                 pr_debug("close usb driver {\n");
422                 usb_deregister(usb->usb.driver);
423                 usb->usb.driver = (struct usb_driver *) 0;
424                 pr_debug("close usb driver }\n");
425         }
426
427         /* free baseband usb structure */
428         kfree(usb);
429
430         pr_debug("baseband_usb_close }\n");
431 }
432
433 static int baseband_usb_netdev_init(struct net_device *dev)
434 {
435         pr_debug("baseband_usb_netdev_init\n");
436         return 0;
437 }
438
439 static void baseband_usb_netdev_uninit(struct net_device *dev)
440 {
441         pr_debug("baseband_usb_netdev_uninit\n");
442 }
443
444 static int baseband_usb_netdev_open(struct net_device *dev)
445 {
446         pr_debug("baseband_usb_netdev_open\n");
447         netif_start_queue(dev);
448         return 0;
449 }
450
451 static int baseband_usb_netdev_stop(struct net_device *dev)
452 {
453         pr_debug("baseband_usb_netdev_stop\n");
454         netif_stop_queue(dev);
455         return 0;
456 }
457
458 static netdev_tx_t baseband_usb_netdev_start_xmit(
459         struct sk_buff *skb, struct net_device *dev)
460 {
461         int i;
462         struct baseband_usb *usb;
463         int err;
464
465         pr_debug("baseband_usb_netdev_start_xmit\n");
466
467         /* check input */
468         if (!skb) {
469                 pr_err("no skb\n");
470                 return NETDEV_TX_BUSY;
471         }
472         if (!dev) {
473                 pr_err("no net dev\n");
474                 return NETDEV_TX_BUSY;
475         }
476
477         /* find index of network device which is transmitting */
478         for (i = 0; i < max_intfs; i++) {
479                 if (usb_net_raw_ip_dev[i] == dev)
480                         break;
481         }
482         if (i >= max_intfs) {
483                 pr_err("unknown net dev %p\n", dev);
484                 return NETDEV_TX_BUSY;
485         }
486         usb = baseband_usb_net[i];
487
488         /* submit tx urb */
489         err = usb_net_raw_ip_tx_urb_submit(usb, skb);
490         if (err < 0) {
491                 pr_err("tx urb submit error\n");
492                 usb->stats.tx_errors++;
493                 return NETDEV_TX_BUSY;
494         }
495
496         return NETDEV_TX_OK;
497 }
498
499 static struct net_device_stats *baseband_usb_netdev_get_stats(
500                                 struct net_device *dev)
501 {
502         int i;
503         for (i = 0; i < max_intfs; i++) {
504                 if (dev == usb_net_raw_ip_dev[i]) {
505                         pr_debug("%s idx(%d)\n", __func__, i);
506                         return &baseband_usb_net[i]->stats;
507                 }
508         }
509         pr_debug("%s mismatch dev, default idx(0)\n", __func__);
510         return &baseband_usb_net[0]->stats;
511 }
512
513 static struct net_device_ops usb_net_raw_ip_ops = {
514         .ndo_init =             baseband_usb_netdev_init,
515         .ndo_uninit =           baseband_usb_netdev_uninit,
516         .ndo_open =             baseband_usb_netdev_open,
517         .ndo_stop =             baseband_usb_netdev_stop,
518         .ndo_start_xmit =       baseband_usb_netdev_start_xmit,
519         .ndo_get_stats = baseband_usb_netdev_get_stats,
520 };
521
522 static int usb_net_raw_ip_rx_urb_submit(struct baseband_usb *usb)
523 {
524         struct urb *urb;
525         void *buf;
526         int err;
527
528         pr_debug("usb_net_raw_ip_rx_urb_submit { usb %p\n", usb);
529
530         /* check input */
531         if (!usb) {
532                 pr_err("%s: !usb\n", __func__);
533                 return -EINVAL;
534         }
535         if (!usb->usb.interface) {
536                 pr_err("usb interface disconnected - not submitting rx urb\n");
537                 return -EINVAL;
538         }
539         if (usb->usb.rx_urb) {
540                 pr_err("previous urb still active\n");
541                 return -EBUSY;
542         }
543         if (!usb->urb_r || !usb->buff) {
544                 pr_err("no reusable rx urb found\n");
545                 return -ENOMEM;
546         }
547
548         /* reuse rx urb */
549         urb = usb->urb_r;
550         buf = usb->buff;
551         usb_fill_bulk_urb(urb, usb->usb.device, usb->usb.pipe.bulk.in,
552                 buf, USB_NET_BUFSIZ,
553                 usb_net_raw_ip_rx_urb_comp,
554                 usb);
555         urb->transfer_flags = 0;
556
557         /* submit rx urb */
558         usb_mark_last_busy(usb->usb.device);
559         usb->usb.rx_urb = urb;
560         err = usb_submit_urb(urb, GFP_ATOMIC);
561         if (err < 0) {
562                 pr_err("usb_submit_urb() failed - err %d\n", err);
563                 usb->usb.rx_urb = (struct urb *) 0;
564                 return err;
565         }
566
567         pr_debug("usb_net_raw_ip_rx_urb_submit }\n");
568         return err;
569 }
570
571 static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
572 {
573         struct baseband_usb *usb = (struct baseband_usb *) urb->context;
574         int i = usb->baseband_index;
575         struct sk_buff *skb;
576         unsigned char *dst;
577         unsigned char ethernet_header[14] = {
578                 /* Destination MAC */
579                 0x00, 0x00,
580                 0x00, 0x00,
581                 0x00, 0x00,
582                 /* Source MAC */
583                 0x00, 0x00,
584                 0x00, 0x00,
585                 0x00, 0x00,
586                 /* EtherType */
587                 NET_IP_ETHERTYPE,
588         };
589
590         pr_debug("usb_net_raw_ip_rx_urb_comp { urb %p\n", urb);
591
592         /* check input */
593         if (!urb) {
594                 pr_err("no urb\n");
595                 return;
596         }
597         switch (urb->status) {
598         case 0:
599                 break;
600         case -ENOENT:
601                 /* fall through */
602         case -ESHUTDOWN:
603                 /* fall through */
604         case -EPROTO:
605                 pr_info("%s: rx urb %p - link shutdown %d\n",
606                         __func__, urb, urb->status);
607                 goto err_exit;
608         default:
609                 pr_info("%s: rx urb %p - status %d\n",
610                         __func__, urb, urb->status);
611                 break;
612         }
613
614         /* put rx urb data in rx buffer */
615         if (urb->actual_length) {
616                 pr_debug("usb_net_raw_ip_rx_urb_comp - "
617                         "urb->actual_length %d\n", urb->actual_length);
618                 /* allocate skb with space for
619                  * - dummy ethernet header
620                  * - rx IP packet from modem
621                  */
622                 skb = netdev_alloc_skb(usb_net_raw_ip_dev[i],
623                         NET_IP_ALIGN + 14 + urb->actual_length);
624                 if (skb) {
625                         /* generate a dummy ethernet header
626                          * since modem sends IP packets without
627                          * any ethernet headers
628                          */
629                         memcpy(ethernet_header + 0,
630                                 usb_net_raw_ip_dev[i]->dev_addr, 6);
631                         memcpy(ethernet_header + 6,
632                                 "0x01\0x02\0x03\0x04\0x05\0x06", 6);
633                         /* fill skb with
634                          * - dummy ethernet header
635                          * - rx IP packet from modem
636                          */
637                         skb_reserve(skb, NET_IP_ALIGN);
638                         dst = skb_put(skb, 14);
639                         memcpy(dst, ethernet_header, 14);
640                         dst = skb_put(skb, urb->actual_length);
641                         memcpy(dst, urb->transfer_buffer, urb->actual_length);
642                         skb->protocol = eth_type_trans(skb,
643                                 usb_net_raw_ip_dev[i]);
644                         /* pass skb to network stack */
645                         if (netif_rx(skb) < 0) {
646                                 pr_err("usb_net_raw_ip_rx_urb_comp_work - "
647                                         "netif_rx(%p) failed\n", skb);
648                                 kfree_skb(skb);
649                                 usb->stats.rx_errors++;
650                         } else {
651                                 usb->stats.rx_packets++;
652                                 usb->stats.rx_bytes +=
653                                     (14 + urb->actual_length);
654                         }
655                 } else {
656                         pr_err("usb_net_raw_ip_rx_urb_comp_work - "
657                                 "netdev_alloc_skb() failed\n");
658                 }
659         }
660
661         /* mark rx urb complete */
662         usb->usb.rx_urb = (struct urb *) 0;
663
664         /* submit next rx urb */
665         usb_net_raw_ip_rx_urb_submit(usb);
666         return;
667
668 err_exit:
669         /* mark rx urb complete */
670         usb->usb.rx_urb = (struct urb *) 0;
671
672         pr_debug("usb_net_raw_ip_rx_urb_comp }\n");
673         return;
674 }
675
676 static int usb_net_raw_ip_setup_rx_urb( struct baseband_usb *usb)
677 {
678         pr_debug("usb_net_raw_ip_setup_rx_urb {\n");
679
680         /* check input */
681         if (!usb) {
682                 pr_err("%s: !usb\n", __func__);
683                 return -EINVAL;
684         }
685         if (usb->urb_r) {
686                 pr_err("%s: reusable rx urb already allocated\n", __func__);
687                 return -EINVAL;
688         }
689
690         /* allocate reusable rx urb */
691         usb->urb_r = usb_alloc_urb(0, GFP_ATOMIC);
692         if (!usb->urb_r) {
693                 pr_err("usb_alloc_urb() failed\n");
694                 return -ENOMEM;
695         }
696         usb->buff = kzalloc(USB_NET_BUFSIZ, GFP_ATOMIC);
697         if (!usb->buff) {
698                 pr_err("usb buffer kzalloc() failed\n");
699                 usb_free_urb(usb->urb_r);
700                 usb->urb_r = (struct urb *) 0;
701                 return -ENOMEM;
702         }
703
704         pr_debug("usb_net_raw_setup_ip_rx_urb }\n");
705         return 0;
706 }
707
708 static void usb_net_raw_ip_free_rx_urb(struct baseband_usb *usb)
709 {
710         pr_debug("usb_net_raw_ip_free_rx_urb {\n");
711
712         /* check input */
713         if (!usb) {
714                 pr_err("%s: !usb\n", __func__);
715                 return;
716         }
717
718         /* free reusable rx urb */
719         if (usb->urb_r) {
720                 usb_free_urb(usb->urb_r);
721                 usb->urb_r = (struct urb *) 0;
722         }
723         if (usb->buff) {
724                 kfree(usb->buff);
725                 usb->buff = (void *) 0;
726         }
727
728         pr_debug("usb_net_raw_ip_free_rx_urb }\n");
729 }
730
731 static int usb_net_raw_ip_tx_urb_submit(struct baseband_usb *usb,
732         struct sk_buff *skb)
733 {
734         struct urb *urb;
735         unsigned char *buf;
736         int err;
737
738         pr_debug("usb_net_raw_ip_tx_urb_submit {\n");
739
740         /* check input */
741         if (!usb) {
742                 pr_err("%s: !usb\n", __func__);
743                 return -EINVAL;
744         }
745         if (!skb) {
746                 pr_err("%s: !skb\n", __func__);
747                 return -EINVAL;
748         }
749         if (!usb->usb.interface) {
750                 pr_err("usb interface disconnected - not submitting tx urb\n");
751                 kfree_skb(skb);
752                 return -EINVAL;
753         }
754
755         /* allocate urb */
756         urb = usb_alloc_urb(0, GFP_ATOMIC);
757         if (!urb) {
758                 pr_err("usb_alloc_urb() failed\n");
759                 kfree_skb(skb);
760                 return -ENOMEM;
761         }
762         buf = kzalloc(skb->len - 14, GFP_ATOMIC);
763         if (!buf) {
764                 pr_err("usb buffer kzalloc() failed\n");
765                 usb_free_urb(urb);
766                 kfree_skb(skb);
767                 return -ENOMEM;
768         }
769         err = skb_copy_bits(skb, 14, buf, skb->len - 14);
770         if (err < 0) {
771                 pr_err("skb_copy_bits() failed - %d\n", err);
772                 kfree(buf);
773                 usb_free_urb(urb);
774                 kfree_skb(skb);
775                 return err;
776         }
777         usb_fill_bulk_urb(urb, usb->usb.device, usb->usb.pipe.bulk.out,
778                 buf, skb->len - 14,
779                 usb_net_raw_ip_tx_urb_comp,
780                 usb);
781         urb->transfer_flags = URB_ZERO_PACKET;
782
783         /* queue tx urb work */
784         usb_anchor_urb(urb, &usb->usb.tx_urb_deferred);
785         queue_work(usb->usb.tx_workqueue, &usb->usb.tx_work);
786
787         /* free skb */
788         consume_skb(skb);
789
790         pr_debug("usb_net_raw_ip_tx_urb_submit }\n");
791         return 0;
792 }
793
794 static void usb_net_raw_ip_tx_urb_work(struct work_struct *work)
795 {
796         struct baseband_usb *usb
797                 = container_of(work, struct baseband_usb, usb.tx_work);
798         struct urb *urb;
799         int err;
800
801         pr_debug("usb_net_raw_ip_tx_urb_work {\n");
802
803         /* check if tx urb(s) queued */
804         if (!usb->usb.tx_urb && usb_anchor_empty(&usb->usb.tx_urb_deferred)) {
805                 pr_debug("%s: nothing to do!\n", __func__);
806                 return;
807         }
808
809         /* submit queued tx urb(s) */
810         while ((urb = usb_get_from_anchor(&usb->usb.tx_urb_deferred))
811                 != (struct urb *) 0) {
812                 /* decrement count from usb_get_from_anchor() */
813                 usb_free_urb(urb);
814                 /* check if usb interface disconnected */
815                 if (!usb->usb.interface) {
816                         pr_err("%s: not submitting tx urb %p"
817                                 " - interface disconnected\n",
818                                 __func__, urb);
819                         if (urb->transfer_buffer) {
820                                 kfree(urb->transfer_buffer);
821                                 urb->transfer_buffer = (void *) 0;
822                         }
823                         usb_free_urb(urb);
824                         continue;
825                 }
826                 /* autoresume before tx */
827                 usb_mark_last_busy(usb->usb.device);
828                 err = usb_autopm_get_interface(usb->usb.interface);
829                 if (err < 0) {
830                         pr_err("%s: usb_autopm_get_interface(%p) failed %d\n",
831                                 __func__, usb->usb.interface, err);
832                         if (urb->transfer_buffer) {
833                                 kfree(urb->transfer_buffer);
834                                 urb->transfer_buffer = (void *) 0;
835                         }
836                         usb_free_urb(urb);
837                         usb->stats.tx_errors++;
838                         continue;
839                 }
840                 /* submit tx urb */
841                 err = usb_submit_urb(urb, GFP_ATOMIC);
842                 if (err < 0) {
843                         pr_err("%s: usb_submit_urb(%p) failed - err %d\n",
844                                 __func__, urb, err);
845                         usb_autopm_put_interface(usb->usb.interface);
846                         if (urb->transfer_buffer) {
847                                 kfree(urb->transfer_buffer);
848                                 urb->transfer_buffer = (void *) 0;
849                         }
850                         usb_free_urb(urb);
851                         continue;
852                 }
853                 /* free tx urb
854                  * - actual urb free occurs when refcnt which was incremented
855                  *   in usb_submit_urb is decremented to 0 (usually after urb
856                  *   completion function returns)
857                  * - tx urb transfer buffer will be freed in urb completion
858                  *   function
859                  */
860                 usb_free_urb(urb);
861         }
862
863         pr_debug("usb_net_raw_ip_tx_urb_work }\n");
864 }
865
866 static void usb_net_raw_ip_tx_urb_comp(struct urb *urb)
867 {
868         struct baseband_usb *usb = (struct baseband_usb *) urb->context;
869
870         pr_debug("usb_net_raw_ip_tx_urb_comp {\n");
871
872         /* check input */
873         if (!urb) {
874                 pr_err("no urb\n");
875                 return;
876         }
877         switch (urb->status) {
878         case 0:
879                 break;
880         case -ENOENT:
881                 /* fall through */
882         case -ESHUTDOWN:
883                 /* fall through */
884         case -EPROTO:
885                 pr_info("%s: tx urb %p - link shutdown %d\n",
886                         __func__, urb, urb->status);
887                 goto err_exit;
888         default:
889                 pr_info("%s: tx urb %p - status %d\n",
890                         __func__, urb, urb->status);
891                 break;
892         }
893         if (urb->status)
894                 usb->stats.tx_errors++;
895         else {
896                 usb->stats.tx_packets++;
897                 usb->stats.tx_bytes += urb->transfer_buffer_length;
898         }
899         /* autosuspend after tx completed */
900         if (!usb->usb.interface) {
901                 pr_err("%s: usb interface disconnected"
902                         " before tx urb completed!\n",
903                         __func__);
904                 goto err_exit;
905         }
906         usb_autopm_put_interface(usb->usb.interface);
907
908 err_exit:
909         /* free tx urb transfer buffer */
910         if (urb->transfer_buffer) {
911                 kfree(urb->transfer_buffer);
912                 urb->transfer_buffer = (void *) 0;
913         }
914
915         pr_debug("usb_net_raw_ip_tx_urb_comp }\n");
916 }
917
918 static int usb_net_raw_ip_init(void)
919 {
920         int i;
921         int err;
922         char name[32];
923
924         pr_debug("usb_net_raw_ip_init {\n");
925
926         /* create multiple raw-ip network devices */
927         for (i = 0; i < max_intfs; i++) {
928                 /* open baseband usb */
929                 g_i = i;
930                 baseband_usb_net[i] = baseband_usb_open(i, usb_net_raw_ip_vid,
931                         usb_net_raw_ip_pid, usb_net_raw_ip_intf[i]);
932                 if (!baseband_usb_net[i]) {
933                         pr_err("cannot open baseband usb net\n");
934                         err = -1;
935                         goto error_exit;
936                 }
937                 /* register network device */
938                 usb_net_raw_ip_dev[i] = alloc_netdev(0,
939                         BASEBAND_USB_NET_DEV_NAME,
940                         ether_setup);
941                 if (!usb_net_raw_ip_dev[i]) {
942                         pr_err("alloc_netdev() failed\n");
943                         err = -ENOMEM;
944                         goto error_exit;
945                 }
946                 usb_net_raw_ip_dev[i]->netdev_ops = &usb_net_raw_ip_ops;
947                 usb_net_raw_ip_dev[i]->watchdog_timeo = TX_TIMEOUT;
948                 random_ether_addr(usb_net_raw_ip_dev[i]->dev_addr);
949                 err = register_netdev(usb_net_raw_ip_dev[i]);
950                 if (err < 0) {
951                         pr_err("cannot register network device - %d\n", err);
952                         goto error_exit;
953                 }
954                 pr_debug("registered baseband usb network device"
955                                 " - dev %p name %s\n", usb_net_raw_ip_dev[i],
956                                  BASEBAND_USB_NET_DEV_NAME);
957                 /* start usb rx */
958                 err = usb_net_raw_ip_setup_rx_urb(baseband_usb_net[i]);
959                 if (err < 0) {
960                         pr_err("setup reusable rx urb failed - err %d\n", err);
961                         goto error_exit;
962                 }
963                 err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
964                 if (err < 0) {
965                         pr_err("submit rx failed - err %d\n", err);
966                         goto error_exit;
967                 }
968                 /* start usb tx */
969                 init_usb_anchor(&baseband_usb_net[i]->usb.tx_urb_deferred);
970                 sprintf(name, "raw_ip_tx_wq-%d",
971                         baseband_usb_net[i]->baseband_index);
972                 baseband_usb_net[i]->usb.tx_workqueue
973                         = create_singlethread_workqueue(name);
974                 if (!baseband_usb_net[i]->usb.tx_workqueue) {
975                         pr_err("cannot create workqueue\n");
976                         goto error_exit;
977                 }
978                 INIT_WORK(&baseband_usb_net[i]->usb.tx_work,
979                         usb_net_raw_ip_tx_urb_work);
980         }
981
982         pr_debug("usb_net_raw_ip_init }\n");
983         return 0;
984
985 error_exit:
986         /* destroy multiple raw-ip network devices */
987         for (i = 0; i < max_intfs; i++) {
988                 /* unregister network device */
989                 if (usb_net_raw_ip_dev[i]) {
990                         unregister_netdev(usb_net_raw_ip_dev[i]);
991                         free_netdev(usb_net_raw_ip_dev[i]);
992                         usb_net_raw_ip_dev[i] = (struct net_device *) 0;
993                 }
994                 /* close baseband usb */
995                 if (baseband_usb_net[i]) {
996                         /* stop usb tx */
997                         if (baseband_usb_net[i]->usb.tx_workqueue) {
998                                 destroy_workqueue(baseband_usb_net[i]
999                                         ->usb.tx_workqueue);
1000                                 baseband_usb_net[i]->usb.tx_workqueue
1001                                         = (struct workqueue_struct *) 0;
1002                         }
1003                         if (baseband_usb_net[i]->usb.tx_urb) {
1004                                 usb_kill_urb(baseband_usb_net[i]->usb.tx_urb);
1005                                 baseband_usb_net[i]->usb.tx_urb
1006                                         = (struct urb *) 0;
1007                         }
1008                         /* stop usb rx */
1009                         if (baseband_usb_net[i]->usb.rx_urb) {
1010                                 usb_kill_urb(baseband_usb_net[i]->usb.rx_urb);
1011                                 baseband_usb_net[i]->usb.rx_urb
1012                                         = (struct urb *) 0;
1013                         }
1014                         usb_net_raw_ip_free_rx_urb(baseband_usb_net[i]);
1015                         /* close usb */
1016                         baseband_usb_close(baseband_usb_net[i]);
1017                         baseband_usb_net[i] = (struct baseband_usb *) 0;
1018                 }
1019         }
1020
1021         return err;
1022 }
1023
1024 static void usb_net_raw_ip_exit(void)
1025 {
1026         int i;
1027
1028         pr_debug("usb_net_raw_ip_exit {\n");
1029
1030         /* destroy multiple raw-ip network devices */
1031         for (i = 0; i < max_intfs; i++) {
1032                 /* unregister network device */
1033                 if (usb_net_raw_ip_dev[i]) {
1034                         unregister_netdev(usb_net_raw_ip_dev[i]);
1035                         free_netdev(usb_net_raw_ip_dev[i]);
1036                         usb_net_raw_ip_dev[i] = (struct net_device *) 0;
1037                 }
1038                 /* close baseband usb */
1039                 if (baseband_usb_net[i]) {
1040                         /* stop usb tx */
1041                         if (baseband_usb_net[i]->usb.tx_workqueue) {
1042                                 destroy_workqueue(baseband_usb_net[i]
1043                                         ->usb.tx_workqueue);
1044                                 baseband_usb_net[i]->usb.tx_workqueue
1045                                         = (struct workqueue_struct *) 0;
1046                         }
1047                         if (baseband_usb_net[i]->usb.tx_urb) {
1048                                 usb_kill_urb(baseband_usb_net[i]->usb.tx_urb);
1049                                 baseband_usb_net[i]->usb.tx_urb
1050                                         = (struct urb *) 0;
1051                         }
1052                         /* stop usb rx */
1053                         if (baseband_usb_net[i]->usb.rx_urb) {
1054                                 usb_kill_urb(baseband_usb_net[i]->usb.rx_urb);
1055                                 baseband_usb_net[i]->usb.rx_urb
1056                                         = (struct urb *) 0;
1057                         }
1058                         usb_net_raw_ip_free_rx_urb(baseband_usb_net[i]);
1059                         /* close usb */
1060                         baseband_usb_close(baseband_usb_net[i]);
1061                         baseband_usb_net[i] = (struct baseband_usb *) 0;
1062                 }
1063         }
1064
1065         pr_debug("usb_net_raw_ip_exit }\n");
1066 }
1067
1068 module_init(usb_net_raw_ip_init)
1069 module_exit(usb_net_raw_ip_exit)
1070