2 * phonet.c -- USB CDC Phonet host driver
4 * Copyright (C) 2008-2009 Nokia Corporation. All rights reserved.
6 * Author: Rémi Denis-Courmont
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/usb.h>
26 #include <linux/usb/cdc.h>
27 #include <linux/netdevice.h>
28 #include <linux/if_arp.h>
29 #include <linux/if_phonet.h>
31 #define PN_MEDIA_USB 0x1B
33 static const unsigned rxq_size
= 17;
36 struct net_device
*dev
;
38 struct usb_interface
*intf
, *data_intf
;
39 struct usb_device
*usb
;
40 unsigned int tx_pipe
, rx_pipe
;
48 struct sk_buff
*rx_skb
;
52 static void tx_complete(struct urb
*req
);
53 static void rx_complete(struct urb
*req
);
56 * Network device callbacks
58 static int usbpn_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
60 struct usbpn_dev
*pnd
= netdev_priv(dev
);
61 struct urb
*req
= NULL
;
65 if (skb
->protocol
!= htons(ETH_P_PHONET
))
68 req
= usb_alloc_urb(0, GFP_ATOMIC
);
71 usb_fill_bulk_urb(req
, pnd
->usb
, pnd
->tx_pipe
, skb
->data
, skb
->len
,
73 req
->transfer_flags
= URB_ZERO_PACKET
;
74 err
= usb_submit_urb(req
, GFP_ATOMIC
);
80 spin_lock_irqsave(&pnd
->tx_lock
, flags
);
82 if (pnd
->tx_queue
>= dev
->tx_queue_len
)
83 netif_stop_queue(dev
);
84 spin_unlock_irqrestore(&pnd
->tx_lock
, flags
);
89 dev
->stats
.tx_dropped
++;
93 static void tx_complete(struct urb
*req
)
95 struct sk_buff
*skb
= req
->context
;
96 struct net_device
*dev
= skb
->dev
;
97 struct usbpn_dev
*pnd
= netdev_priv(dev
);
99 switch (req
->status
) {
101 dev
->stats
.tx_bytes
+= skb
->len
;
107 dev
->stats
.tx_aborted_errors
++;
109 dev
->stats
.tx_errors
++;
110 dev_dbg(&dev
->dev
, "TX error (%d)\n", req
->status
);
112 dev
->stats
.tx_packets
++;
114 spin_lock(&pnd
->tx_lock
);
116 netif_wake_queue(dev
);
117 spin_unlock(&pnd
->tx_lock
);
119 dev_kfree_skb_any(skb
);
123 static int rx_submit(struct usbpn_dev
*pnd
, struct urb
*req
, gfp_t gfp_flags
)
125 struct net_device
*dev
= pnd
->dev
;
129 page
= __netdev_alloc_page(dev
, gfp_flags
);
133 usb_fill_bulk_urb(req
, pnd
->usb
, pnd
->rx_pipe
, page_address(page
),
134 PAGE_SIZE
, rx_complete
, dev
);
135 req
->transfer_flags
= 0;
136 err
= usb_submit_urb(req
, gfp_flags
);
138 dev_dbg(&dev
->dev
, "RX submit error (%d)\n", err
);
139 netdev_free_page(dev
, page
);
144 static void rx_complete(struct urb
*req
)
146 struct net_device
*dev
= req
->context
;
147 struct usbpn_dev
*pnd
= netdev_priv(dev
);
148 struct page
*page
= virt_to_page(req
->transfer_buffer
);
152 switch (req
->status
) {
154 spin_lock_irqsave(&pnd
->rx_lock
, flags
);
157 skb
= pnd
->rx_skb
= netdev_alloc_skb(dev
, 12);
159 /* Can't use pskb_pull() on page in IRQ */
160 memcpy(skb_put(skb
, 1), page_address(page
), 1);
161 skb_add_rx_frag(skb
, skb_shinfo(skb
)->nr_frags
,
162 page
, 1, req
->actual_length
);
166 skb_add_rx_frag(skb
, skb_shinfo(skb
)->nr_frags
,
167 page
, 0, req
->actual_length
);
170 if (req
->actual_length
< PAGE_SIZE
)
171 pnd
->rx_skb
= NULL
; /* Last fragment */
174 spin_unlock_irqrestore(&pnd
->rx_lock
, flags
);
176 skb
->protocol
= htons(ETH_P_PHONET
);
177 skb_reset_mac_header(skb
);
180 dev
->stats
.rx_packets
++;
181 dev
->stats
.rx_bytes
+= skb
->len
;
194 dev
->stats
.rx_over_errors
++;
195 dev_dbg(&dev
->dev
, "RX overflow\n");
199 dev
->stats
.rx_crc_errors
++;
203 dev
->stats
.rx_errors
++;
206 netdev_free_page(dev
, page
);
208 rx_submit(pnd
, req
, GFP_ATOMIC
);
211 static int usbpn_close(struct net_device
*dev
);
213 static int usbpn_open(struct net_device
*dev
)
215 struct usbpn_dev
*pnd
= netdev_priv(dev
);
218 unsigned num
= pnd
->data_intf
->cur_altsetting
->desc
.bInterfaceNumber
;
220 err
= usb_set_interface(pnd
->usb
, num
, pnd
->active_setting
);
224 for (i
= 0; i
< rxq_size
; i
++) {
225 struct urb
*req
= usb_alloc_urb(0, GFP_KERNEL
);
227 if (!req
|| rx_submit(pnd
, req
, GFP_KERNEL
)) {
234 netif_wake_queue(dev
);
238 static int usbpn_close(struct net_device
*dev
)
240 struct usbpn_dev
*pnd
= netdev_priv(dev
);
242 unsigned num
= pnd
->data_intf
->cur_altsetting
->desc
.bInterfaceNumber
;
244 netif_stop_queue(dev
);
246 for (i
= 0; i
< rxq_size
; i
++) {
247 struct urb
*req
= pnd
->urbs
[i
];
256 return usb_set_interface(pnd
->usb
, num
, !pnd
->active_setting
);
259 static int usbpn_set_mtu(struct net_device
*dev
, int new_mtu
)
261 if ((new_mtu
< PHONET_MIN_MTU
) || (new_mtu
> PHONET_MAX_MTU
))
268 static const struct net_device_ops usbpn_ops
= {
269 .ndo_open
= usbpn_open
,
270 .ndo_stop
= usbpn_close
,
271 .ndo_start_xmit
= usbpn_xmit
,
272 .ndo_change_mtu
= usbpn_set_mtu
,
275 static void usbpn_setup(struct net_device
*dev
)
278 dev
->netdev_ops
= &usbpn_ops
,
279 dev
->header_ops
= &phonet_header_ops
;
280 dev
->type
= ARPHRD_PHONET
;
281 dev
->flags
= IFF_POINTOPOINT
| IFF_NOARP
;
282 dev
->mtu
= PHONET_MAX_MTU
;
283 dev
->hard_header_len
= 1;
284 dev
->dev_addr
[0] = PN_MEDIA_USB
;
286 dev
->tx_queue_len
= 3;
288 dev
->destructor
= free_netdev
;
292 * USB driver callbacks
294 static struct usb_device_id usbpn_ids
[] = {
296 .match_flags
= USB_DEVICE_ID_MATCH_VENDOR
297 | USB_DEVICE_ID_MATCH_INT_CLASS
298 | USB_DEVICE_ID_MATCH_INT_SUBCLASS
,
299 .idVendor
= 0x0421, /* Nokia */
300 .bInterfaceClass
= USB_CLASS_COMM
,
301 .bInterfaceSubClass
= 0xFE,
306 MODULE_DEVICE_TABLE(usb
, usbpn_ids
);
308 static struct usb_driver usbpn_driver
;
310 int usbpn_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
312 static const char ifname
[] = "usbpn%d";
313 const struct usb_cdc_union_desc
*union_header
= NULL
;
314 const struct usb_cdc_header_desc
*phonet_header
= NULL
;
315 const struct usb_host_interface
*data_desc
;
316 struct usb_interface
*data_intf
;
317 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
318 struct net_device
*dev
;
319 struct usbpn_dev
*pnd
;
323 data
= intf
->altsetting
->extra
;
324 len
= intf
->altsetting
->extralen
;
330 /* bDescriptorType */
331 if (data
[1] == USB_DT_CS_INTERFACE
) {
332 /* bDescriptorSubType */
334 case USB_CDC_UNION_TYPE
:
335 if (union_header
|| dlen
< 5)
338 (struct usb_cdc_union_desc
*)data
;
341 if (phonet_header
|| dlen
< 5)
344 (struct usb_cdc_header_desc
*)data
;
352 if (!union_header
|| !phonet_header
)
355 data_intf
= usb_ifnum_to_if(usbdev
, union_header
->bSlaveInterface0
);
356 if (data_intf
== NULL
)
358 /* Data interface has one inactive and one active setting */
359 if (data_intf
->num_altsetting
!= 2)
361 if (data_intf
->altsetting
[0].desc
.bNumEndpoints
== 0
362 && data_intf
->altsetting
[1].desc
.bNumEndpoints
== 2)
363 data_desc
= data_intf
->altsetting
+ 1;
365 if (data_intf
->altsetting
[0].desc
.bNumEndpoints
== 2
366 && data_intf
->altsetting
[1].desc
.bNumEndpoints
== 0)
367 data_desc
= data_intf
->altsetting
;
371 dev
= alloc_netdev(sizeof(*pnd
) + sizeof(pnd
->urbs
[0]) * rxq_size
,
372 ifname
, usbpn_setup
);
376 pnd
= netdev_priv(dev
);
377 SET_NETDEV_DEV(dev
, &intf
->dev
);
378 netif_stop_queue(dev
);
381 pnd
->usb
= usb_get_dev(usbdev
);
383 pnd
->data_intf
= data_intf
;
384 spin_lock_init(&pnd
->tx_lock
);
385 spin_lock_init(&pnd
->rx_lock
);
387 if (usb_pipein(data_desc
->endpoint
[0].desc
.bEndpointAddress
)) {
388 pnd
->rx_pipe
= usb_rcvbulkpipe(usbdev
,
389 data_desc
->endpoint
[0].desc
.bEndpointAddress
);
390 pnd
->tx_pipe
= usb_sndbulkpipe(usbdev
,
391 data_desc
->endpoint
[1].desc
.bEndpointAddress
);
393 pnd
->rx_pipe
= usb_rcvbulkpipe(usbdev
,
394 data_desc
->endpoint
[1].desc
.bEndpointAddress
);
395 pnd
->tx_pipe
= usb_sndbulkpipe(usbdev
,
396 data_desc
->endpoint
[0].desc
.bEndpointAddress
);
398 pnd
->active_setting
= data_desc
- data_intf
->altsetting
;
400 err
= usb_driver_claim_interface(&usbpn_driver
, data_intf
, pnd
);
404 /* Force inactive mode until the network device is brought UP */
405 usb_set_interface(usbdev
, union_header
->bSlaveInterface0
,
406 !pnd
->active_setting
);
407 usb_set_intfdata(intf
, pnd
);
409 err
= register_netdev(dev
);
411 usb_driver_release_interface(&usbpn_driver
, data_intf
);
415 dev_dbg(&dev
->dev
, "USB CDC Phonet device found\n");
419 usb_set_intfdata(intf
, NULL
);
424 static void usbpn_disconnect(struct usb_interface
*intf
)
426 struct usbpn_dev
*pnd
= usb_get_intfdata(intf
);
427 struct usb_device
*usb
= pnd
->usb
;
429 if (pnd
->disconnected
)
432 pnd
->disconnected
= 1;
433 usb_driver_release_interface(&usbpn_driver
,
434 (pnd
->intf
== intf
) ? pnd
->data_intf
: pnd
->intf
);
435 unregister_netdev(pnd
->dev
);
439 static struct usb_driver usbpn_driver
= {
440 .name
= "cdc_phonet",
441 .probe
= usbpn_probe
,
442 .disconnect
= usbpn_disconnect
,
443 .id_table
= usbpn_ids
,
446 static int __init
usbpn_init(void)
448 return usb_register(&usbpn_driver
);
451 static void __exit
usbpn_exit(void)
453 usb_deregister(&usbpn_driver
);
456 module_init(usbpn_init
);
457 module_exit(usbpn_exit
);
459 MODULE_AUTHOR("Remi Denis-Courmont");
460 MODULE_DESCRIPTION("USB CDC Phonet host interface");
461 MODULE_LICENSE("GPL");