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