Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/net/usb/ipheth.c

  1 /*
  2  * ipheth.c - Apple iPhone USB Ethernet driver
  3  *
  4  * Copyright (c) 2009 Diego Giagio <diego@giagio.com>
  5  * All rights reserved.
  6  *
  7  * Redistribution and use in source and binary forms, with or without
  8  * modification, are permitted provided that the following conditions
  9  * are met:
 10  * 1. Redistributions of source code must retain the above copyright
 11  *    notice, this list of conditions and the following disclaimer.
 12  * 2. Redistributions in binary form must reproduce the above copyright
 13  *    notice, this list of conditions and the following disclaimer in the
 14  *    documentation and/or other materials provided with the distribution.
 15  * 3. Neither the name of GIAGIO.COM nor the names of its contributors
 16  *    may be used to endorse or promote products derived from this software
 17  *    without specific prior written permission.
 18  *
 19  * Alternatively, provided that this notice is retained in full, this
 20  * software may be distributed under the terms of the GNU General
 21  * Public License ("GPL") version 2, in which case the provisions of the
 22  * GPL apply INSTEAD OF those given above.
 23  *
 24  * The provided data structures and external interfaces from this code
 25  * are not restricted to be used by modules with a GPL compatible license.
 26  *
 27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 28  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 29  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 30  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 31  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 32  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 33  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 34  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 35  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 36  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 37  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 38  * DAMAGE.
 39  *
 40  *
 41  * Attention: iPhone device must be paired, otherwise it won't respond to our
 42  * driver. For more info: http://giagio.com/wiki/moin.cgi/iPhoneEthernetDriver
 43  *
 44  */
 45 
 46 #include <linux/kernel.h>
 47 #include <linux/errno.h>
 48 #include <linux/slab.h>
 49 #include <linux/module.h>
 50 #include <linux/netdevice.h>
 51 #include <linux/etherdevice.h>
 52 #include <linux/ethtool.h>
 53 #include <linux/usb.h>
 54 #include <linux/workqueue.h>
 55 
 56 #define USB_VENDOR_APPLE        0x05ac
 57 #define USB_PRODUCT_IPHONE      0x1290
 58 #define USB_PRODUCT_IPHONE_3G   0x1292
 59 #define USB_PRODUCT_IPHONE_3GS  0x1294
 60 #define USB_PRODUCT_IPHONE_4    0x1297
 61 #define USB_PRODUCT_IPAD 0x129a
 62 #define USB_PRODUCT_IPAD_MINI    0x12ab
 63 #define USB_PRODUCT_IPHONE_4_VZW 0x129c
 64 #define USB_PRODUCT_IPHONE_4S   0x12a0
 65 #define USB_PRODUCT_IPHONE_5    0x12a8
 66 
 67 #define IPHETH_USBINTF_CLASS    255
 68 #define IPHETH_USBINTF_SUBCLASS 253
 69 #define IPHETH_USBINTF_PROTO    1
 70 
 71 #define IPHETH_BUF_SIZE         1516
 72 #define IPHETH_IP_ALIGN         2       /* padding at front of URB */
 73 #define IPHETH_TX_TIMEOUT       (5 * HZ)
 74 
 75 #define IPHETH_INTFNUM          2
 76 #define IPHETH_ALT_INTFNUM      1
 77 
 78 #define IPHETH_CTRL_ENDP        0x00
 79 #define IPHETH_CTRL_BUF_SIZE    0x40
 80 #define IPHETH_CTRL_TIMEOUT     (5 * HZ)
 81 
 82 #define IPHETH_CMD_GET_MACADDR   0x00
 83 #define IPHETH_CMD_CARRIER_CHECK 0x45
 84 
 85 #define IPHETH_CARRIER_CHECK_TIMEOUT round_jiffies_relative(1 * HZ)
 86 #define IPHETH_CARRIER_ON       0x04
 87 
 88 static struct usb_device_id ipheth_table[] = {
 89         { USB_DEVICE_AND_INTERFACE_INFO(
 90                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE,
 91                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
 92                 IPHETH_USBINTF_PROTO) },
 93         { USB_DEVICE_AND_INTERFACE_INFO(
 94                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_3G,
 95                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
 96                 IPHETH_USBINTF_PROTO) },
 97         { USB_DEVICE_AND_INTERFACE_INFO(
 98                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_3GS,
 99                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
100                 IPHETH_USBINTF_PROTO) },
101         { USB_DEVICE_AND_INTERFACE_INFO(
102                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4,
103                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
104                 IPHETH_USBINTF_PROTO) },
105         { USB_DEVICE_AND_INTERFACE_INFO(
106                 USB_VENDOR_APPLE, USB_PRODUCT_IPAD,
107                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
108                 IPHETH_USBINTF_PROTO) },
109         { USB_DEVICE_AND_INTERFACE_INFO(
110                 USB_VENDOR_APPLE, USB_PRODUCT_IPAD_MINI,
111                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
112                 IPHETH_USBINTF_PROTO) },
113         { USB_DEVICE_AND_INTERFACE_INFO(
114                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4_VZW,
115                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
116                 IPHETH_USBINTF_PROTO) },
117         { USB_DEVICE_AND_INTERFACE_INFO(
118                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4S,
119                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
120                 IPHETH_USBINTF_PROTO) },
121         { USB_DEVICE_AND_INTERFACE_INFO(
122                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_5,
123                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
124                 IPHETH_USBINTF_PROTO) },
125         { }
126 };
127 MODULE_DEVICE_TABLE(usb, ipheth_table);
128 
129 struct ipheth_device {
130         struct usb_device *udev;
131         struct usb_interface *intf;
132         struct net_device *net;
133         struct sk_buff *tx_skb;
134         struct urb *tx_urb;
135         struct urb *rx_urb;
136         unsigned char *tx_buf;
137         unsigned char *rx_buf;
138         unsigned char *ctrl_buf;
139         u8 bulk_in;
140         u8 bulk_out;
141         struct delayed_work carrier_work;
142 };
143 
144 static int ipheth_rx_submit(struct ipheth_device *dev, gfp_t mem_flags);
145 
146 static int ipheth_alloc_urbs(struct ipheth_device *iphone)
147 {
148         struct urb *tx_urb = NULL;
149         struct urb *rx_urb = NULL;
150         u8 *tx_buf = NULL;
151         u8 *rx_buf = NULL;
152 
153         tx_urb = usb_alloc_urb(0, GFP_KERNEL);
154         if (tx_urb == NULL)
155                 goto error_nomem;
156 
157         rx_urb = usb_alloc_urb(0, GFP_KERNEL);
158         if (rx_urb == NULL)
159                 goto free_tx_urb;
160 
161         tx_buf = usb_alloc_coherent(iphone->udev, IPHETH_BUF_SIZE,
162                                     GFP_KERNEL, &tx_urb->transfer_dma);
163         if (tx_buf == NULL)
164                 goto free_rx_urb;
165 
166         rx_buf = usb_alloc_coherent(iphone->udev, IPHETH_BUF_SIZE,
167                                     GFP_KERNEL, &rx_urb->transfer_dma);
168         if (rx_buf == NULL)
169                 goto free_tx_buf;
170 
171 
172         iphone->tx_urb = tx_urb;
173         iphone->rx_urb = rx_urb;
174         iphone->tx_buf = tx_buf;
175         iphone->rx_buf = rx_buf;
176         return 0;
177 
178 free_tx_buf:
179         usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, tx_buf,
180                           tx_urb->transfer_dma);
181 free_rx_urb:
182         usb_free_urb(rx_urb);
183 free_tx_urb:
184         usb_free_urb(tx_urb);
185 error_nomem:
186         return -ENOMEM;
187 }
188 
189 static void ipheth_free_urbs(struct ipheth_device *iphone)
190 {
191         usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, iphone->rx_buf,
192                           iphone->rx_urb->transfer_dma);
193         usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, iphone->tx_buf,
194                           iphone->tx_urb->transfer_dma);
195         usb_free_urb(iphone->rx_urb);
196         usb_free_urb(iphone->tx_urb);
197 }
198 
199 static void ipheth_kill_urbs(struct ipheth_device *dev)
200 {
201         usb_kill_urb(dev->tx_urb);
202         usb_kill_urb(dev->rx_urb);
203 }
204 
205 static void ipheth_rcvbulk_callback(struct urb *urb)
206 {
207         struct ipheth_device *dev;
208         struct sk_buff *skb;
209         int status;
210         char *buf;
211         int len;
212 
213         dev = urb->context;
214         if (dev == NULL)
215                 return;
216 
217         status = urb->status;
218         switch (status) {
219         case -ENOENT:
220         case -ECONNRESET:
221         case -ESHUTDOWN:
222                 return;
223         case 0:
224                 break;
225         default:
226                 dev_err(&dev->intf->dev, "%s: urb status: %d\n",
227                         __func__, status);
228                 return;
229         }
230 
231         if (urb->actual_length <= IPHETH_IP_ALIGN) {
232                 dev->net->stats.rx_length_errors++;
233                 return;
234         }
235         len = urb->actual_length - IPHETH_IP_ALIGN;
236         buf = urb->transfer_buffer + IPHETH_IP_ALIGN;
237 
238         skb = dev_alloc_skb(len);
239         if (!skb) {
240                 dev_err(&dev->intf->dev, "%s: dev_alloc_skb: -ENOMEM\n",
241                         __func__);
242                 dev->net->stats.rx_dropped++;
243                 return;
244         }
245 
246         memcpy(skb_put(skb, len), buf, len);
247         skb->dev = dev->net;
248         skb->protocol = eth_type_trans(skb, dev->net);
249 
250         dev->net->stats.rx_packets++;
251         dev->net->stats.rx_bytes += len;
252 
253         netif_rx(skb);
254         ipheth_rx_submit(dev, GFP_ATOMIC);
255 }
256 
257 static void ipheth_sndbulk_callback(struct urb *urb)
258 {
259         struct ipheth_device *dev;
260         int status = urb->status;
261 
262         dev = urb->context;
263         if (dev == NULL)
264                 return;
265 
266         if (status != 0 &&
267             status != -ENOENT &&
268             status != -ECONNRESET &&
269             status != -ESHUTDOWN)
270                 dev_err(&dev->intf->dev, "%s: urb status: %d\n",
271                 __func__, status);
272 
273         dev_kfree_skb_irq(dev->tx_skb);
274         netif_wake_queue(dev->net);
275 }
276 
277 static int ipheth_carrier_set(struct ipheth_device *dev)
278 {
279         struct usb_device *udev = dev->udev;
280         int retval;
281 
282         retval = usb_control_msg(udev,
283                         usb_rcvctrlpipe(udev, IPHETH_CTRL_ENDP),
284                         IPHETH_CMD_CARRIER_CHECK, /* request */
285                         0xc0, /* request type */
286                         0x00, /* value */
287                         0x02, /* index */
288                         dev->ctrl_buf, IPHETH_CTRL_BUF_SIZE,
289                         IPHETH_CTRL_TIMEOUT);
290         if (retval < 0) {
291                 dev_err(&dev->intf->dev, "%s: usb_control_msg: %d\n",
292                         __func__, retval);
293                 return retval;
294         }
295 
296         if (dev->ctrl_buf[0] == IPHETH_CARRIER_ON)
297                 netif_carrier_on(dev->net);
298         else
299                 netif_carrier_off(dev->net);
300 
301         return 0;
302 }
303 
304 static void ipheth_carrier_check_work(struct work_struct *work)
305 {
306         struct ipheth_device *dev = container_of(work, struct ipheth_device,
307                                                  carrier_work.work);
308 
309         ipheth_carrier_set(dev);
310         schedule_delayed_work(&dev->carrier_work, IPHETH_CARRIER_CHECK_TIMEOUT);
311 }
312 
313 static int ipheth_get_macaddr(struct ipheth_device *dev)
314 {
315         struct usb_device *udev = dev->udev;
316         struct net_device *net = dev->net;
317         int retval;
318 
319         retval = usb_control_msg(udev,
320                                  usb_rcvctrlpipe(udev, IPHETH_CTRL_ENDP),
321                                  IPHETH_CMD_GET_MACADDR, /* request */
322                                  0xc0, /* request type */
323                                  0x00, /* value */
324                                  0x02, /* index */
325                                  dev->ctrl_buf,
326                                  IPHETH_CTRL_BUF_SIZE,
327                                  IPHETH_CTRL_TIMEOUT);
328         if (retval < 0) {
329                 dev_err(&dev->intf->dev, "%s: usb_control_msg: %d\n",
330                         __func__, retval);
331         } else if (retval < ETH_ALEN) {
332                 dev_err(&dev->intf->dev,
333                         "%s: usb_control_msg: short packet: %d bytes\n",
334                         __func__, retval);
335                 retval = -EINVAL;
336         } else {
337                 memcpy(net->dev_addr, dev->ctrl_buf, ETH_ALEN);
338                 retval = 0;
339         }
340 
341         return retval;
342 }
343 
344 static int ipheth_rx_submit(struct ipheth_device *dev, gfp_t mem_flags)
345 {
346         struct usb_device *udev = dev->udev;
347         int retval;
348 
349         usb_fill_bulk_urb(dev->rx_urb, udev,
350                           usb_rcvbulkpipe(udev, dev->bulk_in),
351                           dev->rx_buf, IPHETH_BUF_SIZE,
352                           ipheth_rcvbulk_callback,
353                           dev);
354         dev->rx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
355 
356         retval = usb_submit_urb(dev->rx_urb, mem_flags);
357         if (retval)
358                 dev_err(&dev->intf->dev, "%s: usb_submit_urb: %d\n",
359                         __func__, retval);
360         return retval;
361 }
362 
363 static int ipheth_open(struct net_device *net)
364 {
365         struct ipheth_device *dev = netdev_priv(net);
366         struct usb_device *udev = dev->udev;
367         int retval = 0;
368 
369         usb_set_interface(udev, IPHETH_INTFNUM, IPHETH_ALT_INTFNUM);
370 
371         retval = ipheth_carrier_set(dev);
372         if (retval)
373                 return retval;
374 
375         retval = ipheth_rx_submit(dev, GFP_KERNEL);
376         if (retval)
377                 return retval;
378 
379         schedule_delayed_work(&dev->carrier_work, IPHETH_CARRIER_CHECK_TIMEOUT);
380         netif_start_queue(net);
381         return retval;
382 }
383 
384 static int ipheth_close(struct net_device *net)
385 {
386         struct ipheth_device *dev = netdev_priv(net);
387 
388         cancel_delayed_work_sync(&dev->carrier_work);
389         netif_stop_queue(net);
390         return 0;
391 }
392 
393 static int ipheth_tx(struct sk_buff *skb, struct net_device *net)
394 {
395         struct ipheth_device *dev = netdev_priv(net);
396         struct usb_device *udev = dev->udev;
397         int retval;
398 
399         /* Paranoid */
400         if (skb->len > IPHETH_BUF_SIZE) {
401                 WARN(1, "%s: skb too large: %d bytes\n", __func__, skb->len);
402                 dev->net->stats.tx_dropped++;
403                 dev_kfree_skb_irq(skb);
404                 return NETDEV_TX_OK;
405         }
406 
407         memcpy(dev->tx_buf, skb->data, skb->len);
408         if (skb->len < IPHETH_BUF_SIZE)
409                 memset(dev->tx_buf + skb->len, 0, IPHETH_BUF_SIZE - skb->len);
410 
411         usb_fill_bulk_urb(dev->tx_urb, udev,
412                           usb_sndbulkpipe(udev, dev->bulk_out),
413                           dev->tx_buf, IPHETH_BUF_SIZE,
414                           ipheth_sndbulk_callback,
415                           dev);
416         dev->tx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
417 
418         retval = usb_submit_urb(dev->tx_urb, GFP_ATOMIC);
419         if (retval) {
420                 dev_err(&dev->intf->dev, "%s: usb_submit_urb: %d\n",
421                         __func__, retval);
422                 dev->net->stats.tx_errors++;
423                 dev_kfree_skb_irq(skb);
424         } else {
425                 dev->tx_skb = skb;
426 
427                 dev->net->stats.tx_packets++;
428                 dev->net->stats.tx_bytes += skb->len;
429                 netif_stop_queue(net);
430         }
431 
432         return NETDEV_TX_OK;
433 }
434 
435 static void ipheth_tx_timeout(struct net_device *net)
436 {
437         struct ipheth_device *dev = netdev_priv(net);
438 
439         dev_err(&dev->intf->dev, "%s: TX timeout\n", __func__);
440         dev->net->stats.tx_errors++;
441         usb_unlink_urb(dev->tx_urb);
442 }
443 
444 static u32 ipheth_ethtool_op_get_link(struct net_device *net)
445 {
446         struct ipheth_device *dev = netdev_priv(net);
447         return netif_carrier_ok(dev->net);
448 }
449 
450 static const struct ethtool_ops ops = {
451         .get_link = ipheth_ethtool_op_get_link
452 };
453 
454 static const struct net_device_ops ipheth_netdev_ops = {
455         .ndo_open = ipheth_open,
456         .ndo_stop = ipheth_close,
457         .ndo_start_xmit = ipheth_tx,
458         .ndo_tx_timeout = ipheth_tx_timeout,
459 };
460 
461 static int ipheth_probe(struct usb_interface *intf,
462                         const struct usb_device_id *id)
463 {
464         struct usb_device *udev = interface_to_usbdev(intf);
465         struct usb_host_interface *hintf;
466         struct usb_endpoint_descriptor *endp;
467         struct ipheth_device *dev;
468         struct net_device *netdev;
469         int i;
470         int retval;
471 
472         netdev = alloc_etherdev(sizeof(struct ipheth_device));
473         if (!netdev)
474                 return -ENOMEM;
475 
476         netdev->netdev_ops = &ipheth_netdev_ops;
477         netdev->watchdog_timeo = IPHETH_TX_TIMEOUT;
478         strcpy(netdev->name, "eth%d");
479 
480         dev = netdev_priv(netdev);
481         dev->udev = udev;
482         dev->net = netdev;
483         dev->intf = intf;
484 
485         /* Set up endpoints */
486         hintf = usb_altnum_to_altsetting(intf, IPHETH_ALT_INTFNUM);
487         if (hintf == NULL) {
488                 retval = -ENODEV;
489                 dev_err(&intf->dev, "Unable to find alternate settings interface\n");
490                 goto err_endpoints;
491         }
492 
493         for (i = 0; i < hintf->desc.bNumEndpoints; i++) {
494                 endp = &hintf->endpoint[i].desc;
495                 if (usb_endpoint_is_bulk_in(endp))
496                         dev->bulk_in = endp->bEndpointAddress;
497                 else if (usb_endpoint_is_bulk_out(endp))
498                         dev->bulk_out = endp->bEndpointAddress;
499         }
500         if (!(dev->bulk_in && dev->bulk_out)) {
501                 retval = -ENODEV;
502                 dev_err(&intf->dev, "Unable to find endpoints\n");
503                 goto err_endpoints;
504         }
505 
506         dev->ctrl_buf = kmalloc(IPHETH_CTRL_BUF_SIZE, GFP_KERNEL);
507         if (dev->ctrl_buf == NULL) {
508                 retval = -ENOMEM;
509                 goto err_alloc_ctrl_buf;
510         }
511 
512         retval = ipheth_get_macaddr(dev);
513         if (retval)
514                 goto err_get_macaddr;
515 
516         INIT_DELAYED_WORK(&dev->carrier_work, ipheth_carrier_check_work);
517 
518         retval = ipheth_alloc_urbs(dev);
519         if (retval) {
520                 dev_err(&intf->dev, "error allocating urbs: %d\n", retval);
521                 goto err_alloc_urbs;
522         }
523 
524         usb_set_intfdata(intf, dev);
525 
526         SET_NETDEV_DEV(netdev, &intf->dev);
527         SET_ETHTOOL_OPS(netdev, &ops);
528 
529         retval = register_netdev(netdev);
530         if (retval) {
531                 dev_err(&intf->dev, "error registering netdev: %d\n", retval);
532                 retval = -EIO;
533                 goto err_register_netdev;
534         }
535 
536         dev_info(&intf->dev, "Apple iPhone USB Ethernet device attached\n");
537         return 0;
538 
539 err_register_netdev:
540         ipheth_free_urbs(dev);
541 err_alloc_urbs:
542 err_get_macaddr:
543 err_alloc_ctrl_buf:
544         kfree(dev->ctrl_buf);
545 err_endpoints:
546         free_netdev(netdev);
547         return retval;
548 }
549 
550 static void ipheth_disconnect(struct usb_interface *intf)
551 {
552         struct ipheth_device *dev;
553 
554         dev = usb_get_intfdata(intf);
555         if (dev != NULL) {
556                 unregister_netdev(dev->net);
557                 ipheth_kill_urbs(dev);
558                 ipheth_free_urbs(dev);
559                 kfree(dev->ctrl_buf);
560                 free_netdev(dev->net);
561         }
562         usb_set_intfdata(intf, NULL);
563         dev_info(&intf->dev, "Apple iPhone USB Ethernet now disconnected\n");
564 }
565 
566 static struct usb_driver ipheth_driver = {
567         .name =         "ipheth",
568         .probe =        ipheth_probe,
569         .disconnect =   ipheth_disconnect,
570         .id_table =     ipheth_table,
571         .disable_hub_initiated_lpm = 1,
572 };
573 
574 module_usb_driver(ipheth_driver);
575 
576 MODULE_AUTHOR("Diego Giagio <diego@giagio.com>");
577 MODULE_DESCRIPTION("Apple iPhone USB Ethernet driver");
578 MODULE_LICENSE("Dual BSD/GPL");
579 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us