Version:  2.0.40 2.2.26 2.4.37 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 3.15 3.16 3.17 3.18

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_2      0x12a2
 63 #define USB_PRODUCT_IPAD_3      0x12a6
 64 #define USB_PRODUCT_IPAD_MINI    0x12ab
 65 #define USB_PRODUCT_IPHONE_4_VZW 0x129c
 66 #define USB_PRODUCT_IPHONE_4S   0x12a0
 67 #define USB_PRODUCT_IPHONE_5    0x12a8
 68 
 69 #define IPHETH_USBINTF_CLASS    255
 70 #define IPHETH_USBINTF_SUBCLASS 253
 71 #define IPHETH_USBINTF_PROTO    1
 72 
 73 #define IPHETH_BUF_SIZE         1516
 74 #define IPHETH_IP_ALIGN         2       /* padding at front of URB */
 75 #define IPHETH_TX_TIMEOUT       (5 * HZ)
 76 
 77 #define IPHETH_INTFNUM          2
 78 #define IPHETH_ALT_INTFNUM      1
 79 
 80 #define IPHETH_CTRL_ENDP        0x00
 81 #define IPHETH_CTRL_BUF_SIZE    0x40
 82 #define IPHETH_CTRL_TIMEOUT     (5 * HZ)
 83 
 84 #define IPHETH_CMD_GET_MACADDR   0x00
 85 #define IPHETH_CMD_CARRIER_CHECK 0x45
 86 
 87 #define IPHETH_CARRIER_CHECK_TIMEOUT round_jiffies_relative(1 * HZ)
 88 #define IPHETH_CARRIER_ON       0x04
 89 
 90 static struct usb_device_id ipheth_table[] = {
 91         { USB_DEVICE_AND_INTERFACE_INFO(
 92                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE,
 93                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
 94                 IPHETH_USBINTF_PROTO) },
 95         { USB_DEVICE_AND_INTERFACE_INFO(
 96                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_3G,
 97                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
 98                 IPHETH_USBINTF_PROTO) },
 99         { USB_DEVICE_AND_INTERFACE_INFO(
100                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_3GS,
101                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
102                 IPHETH_USBINTF_PROTO) },
103         { USB_DEVICE_AND_INTERFACE_INFO(
104                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4,
105                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
106                 IPHETH_USBINTF_PROTO) },
107         { USB_DEVICE_AND_INTERFACE_INFO(
108                 USB_VENDOR_APPLE, USB_PRODUCT_IPAD,
109                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
110                 IPHETH_USBINTF_PROTO) },
111         { USB_DEVICE_AND_INTERFACE_INFO(
112                 USB_VENDOR_APPLE, USB_PRODUCT_IPAD_2,
113                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
114                 IPHETH_USBINTF_PROTO) },
115         { USB_DEVICE_AND_INTERFACE_INFO(
116                 USB_VENDOR_APPLE, USB_PRODUCT_IPAD_3,
117                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
118                 IPHETH_USBINTF_PROTO) },
119         { USB_DEVICE_AND_INTERFACE_INFO(
120                 USB_VENDOR_APPLE, USB_PRODUCT_IPAD_MINI,
121                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
122                 IPHETH_USBINTF_PROTO) },
123         { USB_DEVICE_AND_INTERFACE_INFO(
124                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4_VZW,
125                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
126                 IPHETH_USBINTF_PROTO) },
127         { USB_DEVICE_AND_INTERFACE_INFO(
128                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4S,
129                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
130                 IPHETH_USBINTF_PROTO) },
131         { USB_DEVICE_AND_INTERFACE_INFO(
132                 USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_5,
133                 IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
134                 IPHETH_USBINTF_PROTO) },
135         { }
136 };
137 MODULE_DEVICE_TABLE(usb, ipheth_table);
138 
139 struct ipheth_device {
140         struct usb_device *udev;
141         struct usb_interface *intf;
142         struct net_device *net;
143         struct sk_buff *tx_skb;
144         struct urb *tx_urb;
145         struct urb *rx_urb;
146         unsigned char *tx_buf;
147         unsigned char *rx_buf;
148         unsigned char *ctrl_buf;
149         u8 bulk_in;
150         u8 bulk_out;
151         struct delayed_work carrier_work;
152 };
153 
154 static int ipheth_rx_submit(struct ipheth_device *dev, gfp_t mem_flags);
155 
156 static int ipheth_alloc_urbs(struct ipheth_device *iphone)
157 {
158         struct urb *tx_urb = NULL;
159         struct urb *rx_urb = NULL;
160         u8 *tx_buf = NULL;
161         u8 *rx_buf = NULL;
162 
163         tx_urb = usb_alloc_urb(0, GFP_KERNEL);
164         if (tx_urb == NULL)
165                 goto error_nomem;
166 
167         rx_urb = usb_alloc_urb(0, GFP_KERNEL);
168         if (rx_urb == NULL)
169                 goto free_tx_urb;
170 
171         tx_buf = usb_alloc_coherent(iphone->udev, IPHETH_BUF_SIZE,
172                                     GFP_KERNEL, &tx_urb->transfer_dma);
173         if (tx_buf == NULL)
174                 goto free_rx_urb;
175 
176         rx_buf = usb_alloc_coherent(iphone->udev, IPHETH_BUF_SIZE,
177                                     GFP_KERNEL, &rx_urb->transfer_dma);
178         if (rx_buf == NULL)
179                 goto free_tx_buf;
180 
181 
182         iphone->tx_urb = tx_urb;
183         iphone->rx_urb = rx_urb;
184         iphone->tx_buf = tx_buf;
185         iphone->rx_buf = rx_buf;
186         return 0;
187 
188 free_tx_buf:
189         usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, tx_buf,
190                           tx_urb->transfer_dma);
191 free_rx_urb:
192         usb_free_urb(rx_urb);
193 free_tx_urb:
194         usb_free_urb(tx_urb);
195 error_nomem:
196         return -ENOMEM;
197 }
198 
199 static void ipheth_free_urbs(struct ipheth_device *iphone)
200 {
201         usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, iphone->rx_buf,
202                           iphone->rx_urb->transfer_dma);
203         usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, iphone->tx_buf,
204                           iphone->tx_urb->transfer_dma);
205         usb_free_urb(iphone->rx_urb);
206         usb_free_urb(iphone->tx_urb);
207 }
208 
209 static void ipheth_kill_urbs(struct ipheth_device *dev)
210 {
211         usb_kill_urb(dev->tx_urb);
212         usb_kill_urb(dev->rx_urb);
213 }
214 
215 static void ipheth_rcvbulk_callback(struct urb *urb)
216 {
217         struct ipheth_device *dev;
218         struct sk_buff *skb;
219         int status;
220         char *buf;
221         int len;
222 
223         dev = urb->context;
224         if (dev == NULL)
225                 return;
226 
227         status = urb->status;
228         switch (status) {
229         case -ENOENT:
230         case -ECONNRESET:
231         case -ESHUTDOWN:
232                 return;
233         case 0:
234                 break;
235         default:
236                 dev_err(&dev->intf->dev, "%s: urb status: %d\n",
237                         __func__, status);
238                 return;
239         }
240 
241         if (urb->actual_length <= IPHETH_IP_ALIGN) {
242                 dev->net->stats.rx_length_errors++;
243                 return;
244         }
245         len = urb->actual_length - IPHETH_IP_ALIGN;
246         buf = urb->transfer_buffer + IPHETH_IP_ALIGN;
247 
248         skb = dev_alloc_skb(len);
249         if (!skb) {
250                 dev_err(&dev->intf->dev, "%s: dev_alloc_skb: -ENOMEM\n",
251                         __func__);
252                 dev->net->stats.rx_dropped++;
253                 return;
254         }
255 
256         memcpy(skb_put(skb, len), buf, len);
257         skb->dev = dev->net;
258         skb->protocol = eth_type_trans(skb, dev->net);
259 
260         dev->net->stats.rx_packets++;
261         dev->net->stats.rx_bytes += len;
262 
263         netif_rx(skb);
264         ipheth_rx_submit(dev, GFP_ATOMIC);
265 }
266 
267 static void ipheth_sndbulk_callback(struct urb *urb)
268 {
269         struct ipheth_device *dev;
270         int status = urb->status;
271 
272         dev = urb->context;
273         if (dev == NULL)
274                 return;
275 
276         if (status != 0 &&
277             status != -ENOENT &&
278             status != -ECONNRESET &&
279             status != -ESHUTDOWN)
280                 dev_err(&dev->intf->dev, "%s: urb status: %d\n",
281                 __func__, status);
282 
283         dev_kfree_skb_irq(dev->tx_skb);
284         netif_wake_queue(dev->net);
285 }
286 
287 static int ipheth_carrier_set(struct ipheth_device *dev)
288 {
289         struct usb_device *udev = dev->udev;
290         int retval;
291 
292         retval = usb_control_msg(udev,
293                         usb_rcvctrlpipe(udev, IPHETH_CTRL_ENDP),
294                         IPHETH_CMD_CARRIER_CHECK, /* request */
295                         0xc0, /* request type */
296                         0x00, /* value */
297                         0x02, /* index */
298                         dev->ctrl_buf, IPHETH_CTRL_BUF_SIZE,
299                         IPHETH_CTRL_TIMEOUT);
300         if (retval < 0) {
301                 dev_err(&dev->intf->dev, "%s: usb_control_msg: %d\n",
302                         __func__, retval);
303                 return retval;
304         }
305 
306         if (dev->ctrl_buf[0] == IPHETH_CARRIER_ON)
307                 netif_carrier_on(dev->net);
308         else
309                 netif_carrier_off(dev->net);
310 
311         return 0;
312 }
313 
314 static void ipheth_carrier_check_work(struct work_struct *work)
315 {
316         struct ipheth_device *dev = container_of(work, struct ipheth_device,
317                                                  carrier_work.work);
318 
319         ipheth_carrier_set(dev);
320         schedule_delayed_work(&dev->carrier_work, IPHETH_CARRIER_CHECK_TIMEOUT);
321 }
322 
323 static int ipheth_get_macaddr(struct ipheth_device *dev)
324 {
325         struct usb_device *udev = dev->udev;
326         struct net_device *net = dev->net;
327         int retval;
328 
329         retval = usb_control_msg(udev,
330                                  usb_rcvctrlpipe(udev, IPHETH_CTRL_ENDP),
331                                  IPHETH_CMD_GET_MACADDR, /* request */
332                                  0xc0, /* request type */
333                                  0x00, /* value */
334                                  0x02, /* index */
335                                  dev->ctrl_buf,
336                                  IPHETH_CTRL_BUF_SIZE,
337                                  IPHETH_CTRL_TIMEOUT);
338         if (retval < 0) {
339                 dev_err(&dev->intf->dev, "%s: usb_control_msg: %d\n",
340                         __func__, retval);
341         } else if (retval < ETH_ALEN) {
342                 dev_err(&dev->intf->dev,
343                         "%s: usb_control_msg: short packet: %d bytes\n",
344                         __func__, retval);
345                 retval = -EINVAL;
346         } else {
347                 memcpy(net->dev_addr, dev->ctrl_buf, ETH_ALEN);
348                 retval = 0;
349         }
350 
351         return retval;
352 }
353 
354 static int ipheth_rx_submit(struct ipheth_device *dev, gfp_t mem_flags)
355 {
356         struct usb_device *udev = dev->udev;
357         int retval;
358 
359         usb_fill_bulk_urb(dev->rx_urb, udev,
360                           usb_rcvbulkpipe(udev, dev->bulk_in),
361                           dev->rx_buf, IPHETH_BUF_SIZE,
362                           ipheth_rcvbulk_callback,
363                           dev);
364         dev->rx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
365 
366         retval = usb_submit_urb(dev->rx_urb, mem_flags);
367         if (retval)
368                 dev_err(&dev->intf->dev, "%s: usb_submit_urb: %d\n",
369                         __func__, retval);
370         return retval;
371 }
372 
373 static int ipheth_open(struct net_device *net)
374 {
375         struct ipheth_device *dev = netdev_priv(net);
376         struct usb_device *udev = dev->udev;
377         int retval = 0;
378 
379         usb_set_interface(udev, IPHETH_INTFNUM, IPHETH_ALT_INTFNUM);
380 
381         retval = ipheth_carrier_set(dev);
382         if (retval)
383                 return retval;
384 
385         retval = ipheth_rx_submit(dev, GFP_KERNEL);
386         if (retval)
387                 return retval;
388 
389         schedule_delayed_work(&dev->carrier_work, IPHETH_CARRIER_CHECK_TIMEOUT);
390         netif_start_queue(net);
391         return retval;
392 }
393 
394 static int ipheth_close(struct net_device *net)
395 {
396         struct ipheth_device *dev = netdev_priv(net);
397 
398         cancel_delayed_work_sync(&dev->carrier_work);
399         netif_stop_queue(net);
400         return 0;
401 }
402 
403 static int ipheth_tx(struct sk_buff *skb, struct net_device *net)
404 {
405         struct ipheth_device *dev = netdev_priv(net);
406         struct usb_device *udev = dev->udev;
407         int retval;
408 
409         /* Paranoid */
410         if (skb->len > IPHETH_BUF_SIZE) {
411                 WARN(1, "%s: skb too large: %d bytes\n", __func__, skb->len);
412                 dev->net->stats.tx_dropped++;
413                 dev_kfree_skb_irq(skb);
414                 return NETDEV_TX_OK;
415         }
416 
417         memcpy(dev->tx_buf, skb->data, skb->len);
418         if (skb->len < IPHETH_BUF_SIZE)
419                 memset(dev->tx_buf + skb->len, 0, IPHETH_BUF_SIZE - skb->len);
420 
421         usb_fill_bulk_urb(dev->tx_urb, udev,
422                           usb_sndbulkpipe(udev, dev->bulk_out),
423                           dev->tx_buf, IPHETH_BUF_SIZE,
424                           ipheth_sndbulk_callback,
425                           dev);
426         dev->tx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
427 
428         retval = usb_submit_urb(dev->tx_urb, GFP_ATOMIC);
429         if (retval) {
430                 dev_err(&dev->intf->dev, "%s: usb_submit_urb: %d\n",
431                         __func__, retval);
432                 dev->net->stats.tx_errors++;
433                 dev_kfree_skb_irq(skb);
434         } else {
435                 dev->tx_skb = skb;
436 
437                 dev->net->stats.tx_packets++;
438                 dev->net->stats.tx_bytes += skb->len;
439                 netif_stop_queue(net);
440         }
441 
442         return NETDEV_TX_OK;
443 }
444 
445 static void ipheth_tx_timeout(struct net_device *net)
446 {
447         struct ipheth_device *dev = netdev_priv(net);
448 
449         dev_err(&dev->intf->dev, "%s: TX timeout\n", __func__);
450         dev->net->stats.tx_errors++;
451         usb_unlink_urb(dev->tx_urb);
452 }
453 
454 static u32 ipheth_ethtool_op_get_link(struct net_device *net)
455 {
456         struct ipheth_device *dev = netdev_priv(net);
457         return netif_carrier_ok(dev->net);
458 }
459 
460 static const struct ethtool_ops ops = {
461         .get_link = ipheth_ethtool_op_get_link
462 };
463 
464 static const struct net_device_ops ipheth_netdev_ops = {
465         .ndo_open = ipheth_open,
466         .ndo_stop = ipheth_close,
467         .ndo_start_xmit = ipheth_tx,
468         .ndo_tx_timeout = ipheth_tx_timeout,
469 };
470 
471 static int ipheth_probe(struct usb_interface *intf,
472                         const struct usb_device_id *id)
473 {
474         struct usb_device *udev = interface_to_usbdev(intf);
475         struct usb_host_interface *hintf;
476         struct usb_endpoint_descriptor *endp;
477         struct ipheth_device *dev;
478         struct net_device *netdev;
479         int i;
480         int retval;
481 
482         netdev = alloc_etherdev(sizeof(struct ipheth_device));
483         if (!netdev)
484                 return -ENOMEM;
485 
486         netdev->netdev_ops = &ipheth_netdev_ops;
487         netdev->watchdog_timeo = IPHETH_TX_TIMEOUT;
488         strcpy(netdev->name, "eth%d");
489 
490         dev = netdev_priv(netdev);
491         dev->udev = udev;
492         dev->net = netdev;
493         dev->intf = intf;
494 
495         /* Set up endpoints */
496         hintf = usb_altnum_to_altsetting(intf, IPHETH_ALT_INTFNUM);
497         if (hintf == NULL) {
498                 retval = -ENODEV;
499                 dev_err(&intf->dev, "Unable to find alternate settings interface\n");
500                 goto err_endpoints;
501         }
502 
503         for (i = 0; i < hintf->desc.bNumEndpoints; i++) {
504                 endp = &hintf->endpoint[i].desc;
505                 if (usb_endpoint_is_bulk_in(endp))
506                         dev->bulk_in = endp->bEndpointAddress;
507                 else if (usb_endpoint_is_bulk_out(endp))
508                         dev->bulk_out = endp->bEndpointAddress;
509         }
510         if (!(dev->bulk_in && dev->bulk_out)) {
511                 retval = -ENODEV;
512                 dev_err(&intf->dev, "Unable to find endpoints\n");
513                 goto err_endpoints;
514         }
515 
516         dev->ctrl_buf = kmalloc(IPHETH_CTRL_BUF_SIZE, GFP_KERNEL);
517         if (dev->ctrl_buf == NULL) {
518                 retval = -ENOMEM;
519                 goto err_alloc_ctrl_buf;
520         }
521 
522         retval = ipheth_get_macaddr(dev);
523         if (retval)
524                 goto err_get_macaddr;
525 
526         INIT_DELAYED_WORK(&dev->carrier_work, ipheth_carrier_check_work);
527 
528         retval = ipheth_alloc_urbs(dev);
529         if (retval) {
530                 dev_err(&intf->dev, "error allocating urbs: %d\n", retval);
531                 goto err_alloc_urbs;
532         }
533 
534         usb_set_intfdata(intf, dev);
535 
536         SET_NETDEV_DEV(netdev, &intf->dev);
537         netdev->ethtool_ops = &ops;
538 
539         retval = register_netdev(netdev);
540         if (retval) {
541                 dev_err(&intf->dev, "error registering netdev: %d\n", retval);
542                 retval = -EIO;
543                 goto err_register_netdev;
544         }
545 
546         dev_info(&intf->dev, "Apple iPhone USB Ethernet device attached\n");
547         return 0;
548 
549 err_register_netdev:
550         ipheth_free_urbs(dev);
551 err_alloc_urbs:
552 err_get_macaddr:
553 err_alloc_ctrl_buf:
554         kfree(dev->ctrl_buf);
555 err_endpoints:
556         free_netdev(netdev);
557         return retval;
558 }
559 
560 static void ipheth_disconnect(struct usb_interface *intf)
561 {
562         struct ipheth_device *dev;
563 
564         dev = usb_get_intfdata(intf);
565         if (dev != NULL) {
566                 unregister_netdev(dev->net);
567                 ipheth_kill_urbs(dev);
568                 ipheth_free_urbs(dev);
569                 kfree(dev->ctrl_buf);
570                 free_netdev(dev->net);
571         }
572         usb_set_intfdata(intf, NULL);
573         dev_info(&intf->dev, "Apple iPhone USB Ethernet now disconnected\n");
574 }
575 
576 static struct usb_driver ipheth_driver = {
577         .name =         "ipheth",
578         .probe =        ipheth_probe,
579         .disconnect =   ipheth_disconnect,
580         .id_table =     ipheth_table,
581         .disable_hub_initiated_lpm = 1,
582 };
583 
584 module_usb_driver(ipheth_driver);
585 
586 MODULE_AUTHOR("Diego Giagio <diego@giagio.com>");
587 MODULE_DESCRIPTION("Apple iPhone USB Ethernet driver");
588 MODULE_LICENSE("Dual BSD/GPL");
589 

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