1/***************************************************************************** 2 * 3 * Filename: irda-usb.c 4 * Version: 0.10 5 * Description: IrDA-USB Driver 6 * Status: Experimental 7 * Author: Dag Brattli <dag@brattli.net> 8 * 9 * Copyright (C) 2000, Roman Weissgaerber <weissg@vienna.at> 10 * Copyright (C) 2001, Dag Brattli <dag@brattli.net> 11 * Copyright (C) 2001, Jean Tourrilhes <jt@hpl.hp.com> 12 * Copyright (C) 2004, SigmaTel, Inc. <irquality@sigmatel.com> 13 * Copyright (C) 2005, Milan Beno <beno@pobox.sk> 14 * Copyright (C) 2006, Nick Fedchik <nick@fedchik.org.ua> 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License as published by 18 * the Free Software Foundation; either version 2 of the License, or 19 * (at your option) any later version. 20 * 21 * This program is distributed in the hope that it will be useful, 22 * but WITHOUT ANY WARRANTY; without even the implied warranty of 23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24 * GNU General Public License for more details. 25 * 26 * You should have received a copy of the GNU General Public License 27 * along with this program; if not, write to the Free Software 28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 29 * 30 *****************************************************************************/ 31 32/* 33 * IMPORTANT NOTE 34 * -------------- 35 * 36 * As of kernel 2.5.20, this is the state of compliance and testing of 37 * this driver (irda-usb) with regards to the USB low level drivers... 38 * 39 * This driver has been tested SUCCESSFULLY with the following drivers : 40 * o usb-uhci-hcd (For Intel/Via USB controllers) 41 * o uhci-hcd (Alternate/JE driver for Intel/Via USB controllers) 42 * o ohci-hcd (For other USB controllers) 43 * 44 * This driver has NOT been tested with the following drivers : 45 * o ehci-hcd (USB 2.0 controllers) 46 * 47 * Note that all HCD drivers do URB_ZERO_PACKET and timeout properly, 48 * so we don't have to worry about that anymore. 49 * One common problem is the failure to set the address on the dongle, 50 * but this happens before the driver gets loaded... 51 * 52 * Jean II 53 */ 54 55/*------------------------------------------------------------------*/ 56 57#include <linux/module.h> 58#include <linux/moduleparam.h> 59#include <linux/kernel.h> 60#include <linux/types.h> 61#include <linux/init.h> 62#include <linux/skbuff.h> 63#include <linux/netdevice.h> 64#include <linux/slab.h> 65#include <linux/rtnetlink.h> 66#include <linux/usb.h> 67#include <linux/firmware.h> 68 69#include "irda-usb.h" 70 71/*------------------------------------------------------------------*/ 72 73static int qos_mtt_bits = 0; 74 75/* These are the currently known IrDA USB dongles. Add new dongles here */ 76static struct usb_device_id dongles[] = { 77 /* ACTiSYS Corp., ACT-IR2000U FIR-USB Adapter */ 78 { USB_DEVICE(0x9c4, 0x011), .driver_info = IUC_SPEED_BUG | IUC_NO_WINDOW }, 79 /* Look like ACTiSYS, Report : IBM Corp., IBM UltraPort IrDA */ 80 { USB_DEVICE(0x4428, 0x012), .driver_info = IUC_SPEED_BUG | IUC_NO_WINDOW }, 81 /* KC Technology Inc., KC-180 USB IrDA Device */ 82 { USB_DEVICE(0x50f, 0x180), .driver_info = IUC_SPEED_BUG | IUC_NO_WINDOW }, 83 /* Extended Systems, Inc., XTNDAccess IrDA USB (ESI-9685) */ 84 { USB_DEVICE(0x8e9, 0x100), .driver_info = IUC_SPEED_BUG | IUC_NO_WINDOW }, 85 /* SigmaTel STIR4210/4220/4116 USB IrDA (VFIR) Bridge */ 86 { USB_DEVICE(0x66f, 0x4210), .driver_info = IUC_STIR421X | IUC_SPEED_BUG }, 87 { USB_DEVICE(0x66f, 0x4220), .driver_info = IUC_STIR421X | IUC_SPEED_BUG }, 88 { USB_DEVICE(0x66f, 0x4116), .driver_info = IUC_STIR421X | IUC_SPEED_BUG }, 89 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 90 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 91 .bInterfaceClass = USB_CLASS_APP_SPEC, 92 .bInterfaceSubClass = USB_CLASS_IRDA, 93 .driver_info = IUC_DEFAULT, }, 94 { }, /* The end */ 95}; 96 97/* 98 * Important note : 99 * Devices based on the SigmaTel chipset (0x66f, 0x4200) are not designed 100 * using the "USB-IrDA specification" (yes, there exist such a thing), and 101 * therefore not supported by this driver (don't add them above). 102 * There is a Linux driver, stir4200, that support those USB devices. 103 * Jean II 104 */ 105 106MODULE_DEVICE_TABLE(usb, dongles); 107 108/*------------------------------------------------------------------*/ 109 110static void irda_usb_init_qos(struct irda_usb_cb *self) ; 111static struct irda_class_desc *irda_usb_find_class_desc(struct usb_interface *intf); 112static void irda_usb_disconnect(struct usb_interface *intf); 113static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self); 114static netdev_tx_t irda_usb_hard_xmit(struct sk_buff *skb, 115 struct net_device *dev); 116static int irda_usb_open(struct irda_usb_cb *self); 117static void irda_usb_close(struct irda_usb_cb *self); 118static void speed_bulk_callback(struct urb *urb); 119static void write_bulk_callback(struct urb *urb); 120static void irda_usb_receive(struct urb *urb); 121static void irda_usb_rx_defer_expired(unsigned long data); 122static int irda_usb_net_open(struct net_device *dev); 123static int irda_usb_net_close(struct net_device *dev); 124static int irda_usb_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 125static void irda_usb_net_timeout(struct net_device *dev); 126 127/************************ TRANSMIT ROUTINES ************************/ 128/* 129 * Receive packets from the IrDA stack and send them on the USB pipe. 130 * Handle speed change, timeout and lot's of ugliness... 131 */ 132 133/*------------------------------------------------------------------*/ 134/* 135 * Function irda_usb_build_header(self, skb, header) 136 * 137 * Builds USB-IrDA outbound header 138 * 139 * When we send an IrDA frame over an USB pipe, we add to it a 1 byte 140 * header. This function create this header with the proper values. 141 * 142 * Important note : the USB-IrDA spec 1.0 say very clearly in chapter 5.4.2.2 143 * that the setting of the link speed and xbof number in this outbound header 144 * should be applied *AFTER* the frame has been sent. 145 * Unfortunately, some devices are not compliant with that... It seems that 146 * reading the spec is far too difficult... 147 * Jean II 148 */ 149static void irda_usb_build_header(struct irda_usb_cb *self, 150 __u8 *header, 151 int force) 152{ 153 /* Here we check if we have an STIR421x chip, 154 * and if either speed or xbofs (or both) needs 155 * to be changed. 156 */ 157 if (self->capability & IUC_STIR421X && 158 ((self->new_speed != -1) || (self->new_xbofs != -1))) { 159 160 /* With STIR421x, speed and xBOFs must be set at the same 161 * time, even if only one of them changes. 162 */ 163 if (self->new_speed == -1) 164 self->new_speed = self->speed ; 165 166 if (self->new_xbofs == -1) 167 self->new_xbofs = self->xbofs ; 168 } 169 170 /* Set the link speed */ 171 if (self->new_speed != -1) { 172 /* Hum... Ugly hack :-( 173 * Some device are not compliant with the spec and change 174 * parameters *before* sending the frame. - Jean II 175 */ 176 if ((self->capability & IUC_SPEED_BUG) && 177 (!force) && (self->speed != -1)) { 178 /* No speed and xbofs change here 179 * (we'll do it later in the write callback) */ 180 IRDA_DEBUG(2, "%s(), not changing speed yet\n", __func__); 181 *header = 0; 182 return; 183 } 184 185 IRDA_DEBUG(2, "%s(), changing speed to %d\n", __func__, self->new_speed); 186 self->speed = self->new_speed; 187 /* We will do ` self->new_speed = -1; ' in the completion 188 * handler just in case the current URB fail - Jean II */ 189 190 switch (self->speed) { 191 case 2400: 192 *header = SPEED_2400; 193 break; 194 default: 195 case 9600: 196 *header = SPEED_9600; 197 break; 198 case 19200: 199 *header = SPEED_19200; 200 break; 201 case 38400: 202 *header = SPEED_38400; 203 break; 204 case 57600: 205 *header = SPEED_57600; 206 break; 207 case 115200: 208 *header = SPEED_115200; 209 break; 210 case 576000: 211 *header = SPEED_576000; 212 break; 213 case 1152000: 214 *header = SPEED_1152000; 215 break; 216 case 4000000: 217 *header = SPEED_4000000; 218 self->new_xbofs = 0; 219 break; 220 case 16000000: 221 *header = SPEED_16000000; 222 self->new_xbofs = 0; 223 break; 224 } 225 } else 226 /* No change */ 227 *header = 0; 228 229 /* Set the negotiated additional XBOFS */ 230 if (self->new_xbofs != -1) { 231 IRDA_DEBUG(2, "%s(), changing xbofs to %d\n", __func__, self->new_xbofs); 232 self->xbofs = self->new_xbofs; 233 /* We will do ` self->new_xbofs = -1; ' in the completion 234 * handler just in case the current URB fail - Jean II */ 235 236 switch (self->xbofs) { 237 case 48: 238 *header |= 0x10; 239 break; 240 case 28: 241 case 24: /* USB spec 1.0 says 24 */ 242 *header |= 0x20; 243 break; 244 default: 245 case 12: 246 *header |= 0x30; 247 break; 248 case 5: /* Bug in IrLAP spec? (should be 6) */ 249 case 6: 250 *header |= 0x40; 251 break; 252 case 3: 253 *header |= 0x50; 254 break; 255 case 2: 256 *header |= 0x60; 257 break; 258 case 1: 259 *header |= 0x70; 260 break; 261 case 0: 262 *header |= 0x80; 263 break; 264 } 265 } 266} 267 268/* 269* calculate turnaround time for SigmaTel header 270*/ 271static __u8 get_turnaround_time(struct sk_buff *skb) 272{ 273 int turnaround_time = irda_get_mtt(skb); 274 275 if ( turnaround_time == 0 ) 276 return 0; 277 else if ( turnaround_time <= 10 ) 278 return 1; 279 else if ( turnaround_time <= 50 ) 280 return 2; 281 else if ( turnaround_time <= 100 ) 282 return 3; 283 else if ( turnaround_time <= 500 ) 284 return 4; 285 else if ( turnaround_time <= 1000 ) 286 return 5; 287 else if ( turnaround_time <= 5000 ) 288 return 6; 289 else 290 return 7; 291} 292 293 294/*------------------------------------------------------------------*/ 295/* 296 * Send a command to change the speed of the dongle 297 * Need to be called with spinlock on. 298 */ 299static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self) 300{ 301 __u8 *frame; 302 struct urb *urb; 303 int ret; 304 305 IRDA_DEBUG(2, "%s(), speed=%d, xbofs=%d\n", __func__, 306 self->new_speed, self->new_xbofs); 307 308 /* Grab the speed URB */ 309 urb = self->speed_urb; 310 if (urb->status != 0) { 311 IRDA_WARNING("%s(), URB still in use!\n", __func__); 312 return; 313 } 314 315 /* Allocate the fake frame */ 316 frame = self->speed_buff; 317 318 /* Set the new speed and xbofs in this fake frame */ 319 irda_usb_build_header(self, frame, 1); 320 321 if (self->capability & IUC_STIR421X) { 322 if (frame[0] == 0) return ; // do nothing if no change 323 frame[1] = 0; // other parameters don't change here 324 frame[2] = 0; 325 } 326 327 /* Submit the 0 length IrDA frame to trigger new speed settings */ 328 usb_fill_bulk_urb(urb, self->usbdev, 329 usb_sndbulkpipe(self->usbdev, self->bulk_out_ep), 330 frame, IRDA_USB_SPEED_MTU, 331 speed_bulk_callback, self); 332 urb->transfer_buffer_length = self->header_length; 333 urb->transfer_flags = 0; 334 335 /* Irq disabled -> GFP_ATOMIC */ 336 if ((ret = usb_submit_urb(urb, GFP_ATOMIC))) { 337 IRDA_WARNING("%s(), failed Speed URB\n", __func__); 338 } 339} 340 341/*------------------------------------------------------------------*/ 342/* 343 * Speed URB callback 344 * Now, we can only get called for the speed URB. 345 */ 346static void speed_bulk_callback(struct urb *urb) 347{ 348 struct irda_usb_cb *self = urb->context; 349 350 IRDA_DEBUG(2, "%s()\n", __func__); 351 352 /* We should always have a context */ 353 IRDA_ASSERT(self != NULL, return;); 354 /* We should always be called for the speed URB */ 355 IRDA_ASSERT(urb == self->speed_urb, return;); 356 357 /* Check for timeout and other USB nasties */ 358 if (urb->status != 0) { 359 /* I get a lot of -ECONNABORTED = -103 here - Jean II */ 360 IRDA_DEBUG(0, "%s(), URB complete status %d, transfer_flags 0x%04X\n", __func__, urb->status, urb->transfer_flags); 361 362 /* Don't do anything here, that might confuse the USB layer. 363 * Instead, we will wait for irda_usb_net_timeout(), the 364 * network layer watchdog, to fix the situation. 365 * Jean II */ 366 /* A reset of the dongle might be welcomed here - Jean II */ 367 return; 368 } 369 370 /* urb is now available */ 371 //urb->status = 0; -> tested above 372 373 /* New speed and xbof is now commited in hardware */ 374 self->new_speed = -1; 375 self->new_xbofs = -1; 376 377 /* Allow the stack to send more packets */ 378 netif_wake_queue(self->netdev); 379} 380 381/*------------------------------------------------------------------*/ 382/* 383 * Send an IrDA frame to the USB dongle (for transmission) 384 */ 385static netdev_tx_t irda_usb_hard_xmit(struct sk_buff *skb, 386 struct net_device *netdev) 387{ 388 struct irda_usb_cb *self = netdev_priv(netdev); 389 struct urb *urb = self->tx_urb; 390 unsigned long flags; 391 s32 speed; 392 s16 xbofs; 393 int res, mtt; 394 395 IRDA_DEBUG(4, "%s() on %s\n", __func__, netdev->name); 396 397 netif_stop_queue(netdev); 398 399 /* Protect us from USB callbacks, net watchdog and else. */ 400 spin_lock_irqsave(&self->lock, flags); 401 402 /* Check if the device is still there. 403 * We need to check self->present under the spinlock because 404 * of irda_usb_disconnect() is synchronous - Jean II */ 405 if (!self->present) { 406 IRDA_DEBUG(0, "%s(), Device is gone...\n", __func__); 407 goto drop; 408 } 409 410 /* Check if we need to change the number of xbofs */ 411 xbofs = irda_get_next_xbofs(skb); 412 if ((xbofs != self->xbofs) && (xbofs != -1)) { 413 self->new_xbofs = xbofs; 414 } 415 416 /* Check if we need to change the speed */ 417 speed = irda_get_next_speed(skb); 418 if ((speed != self->speed) && (speed != -1)) { 419 /* Set the desired speed */ 420 self->new_speed = speed; 421 422 /* Check for empty frame */ 423 if (!skb->len) { 424 /* IrLAP send us an empty frame to make us change the 425 * speed. Changing speed with the USB adapter is in 426 * fact sending an empty frame to the adapter, so we 427 * could just let the present function do its job. 428 * However, we would wait for min turn time, 429 * do an extra memcpy and increment packet counters... 430 * Jean II */ 431 irda_usb_change_speed_xbofs(self); 432 netdev->trans_start = jiffies; 433 /* Will netif_wake_queue() in callback */ 434 goto drop; 435 } 436 } 437 438 if (urb->status != 0) { 439 IRDA_WARNING("%s(), URB still in use!\n", __func__); 440 goto drop; 441 } 442 443 skb_copy_from_linear_data(skb, self->tx_buff + self->header_length, skb->len); 444 445 /* Change setting for next frame */ 446 if (self->capability & IUC_STIR421X) { 447 __u8 turnaround_time; 448 __u8* frame = self->tx_buff; 449 turnaround_time = get_turnaround_time( skb ); 450 irda_usb_build_header(self, frame, 0); 451 frame[2] = turnaround_time; 452 if ((skb->len != 0) && 453 ((skb->len % 128) == 0) && 454 ((skb->len % 512) != 0)) { 455 /* add extra byte for special SigmaTel feature */ 456 frame[1] = 1; 457 skb_put(skb, 1); 458 } else { 459 frame[1] = 0; 460 } 461 } else { 462 irda_usb_build_header(self, self->tx_buff, 0); 463 } 464 465 ((struct irda_skb_cb *)skb->cb)->context = self; 466 467 usb_fill_bulk_urb(urb, self->usbdev, 468 usb_sndbulkpipe(self->usbdev, self->bulk_out_ep), 469 self->tx_buff, skb->len + self->header_length, 470 write_bulk_callback, skb); 471 472 /* This flag (URB_ZERO_PACKET) indicates that what we send is not 473 * a continuous stream of data but separate packets. 474 * In this case, the USB layer will insert an empty USB frame (TD) 475 * after each of our packets that is exact multiple of the frame size. 476 * This is how the dongle will detect the end of packet - Jean II */ 477 urb->transfer_flags = URB_ZERO_PACKET; 478 479 /* Trying to a turnaround time at this level is trying to measure 480 * processor clock cycle with a wrist-watch, approximate at best... 481 * 482 * What we know is the last time we received a frame over USB. 483 * Due to latency over USB that depend on the USB load, we don't 484 * know when this frame was received over IrDA (a few ms before ?) 485 * Then, same story for our outgoing frame... 486 * 487 * In theory, the USB dongle is supposed to handle the turnaround 488 * by itself (spec 1.0, chater 4, page 6). Who knows ??? That's 489 * why this code is enabled only for dongles that doesn't meet 490 * the spec. 491 * Jean II */ 492 if (self->capability & IUC_NO_TURN) { 493 mtt = irda_get_mtt(skb); 494 if (mtt) { 495 int diff; 496 do_gettimeofday(&self->now); 497 diff = self->now.tv_usec - self->stamp.tv_usec; 498#ifdef IU_USB_MIN_RTT 499 /* Factor in USB delays -> Get rid of udelay() that 500 * would be lost in the noise - Jean II */ 501 diff += IU_USB_MIN_RTT; 502#endif /* IU_USB_MIN_RTT */ 503 /* If the usec counter did wraparound, the diff will 504 * go negative (tv_usec is a long), so we need to 505 * correct it by one second. Jean II */ 506 if (diff < 0) 507 diff += 1000000; 508 509 /* Check if the mtt is larger than the time we have 510 * already used by all the protocol processing 511 */ 512 if (mtt > diff) { 513 mtt -= diff; 514 if (mtt > 1000) 515 mdelay(mtt/1000); 516 else 517 udelay(mtt); 518 } 519 } 520 } 521 522 /* Ask USB to send the packet - Irq disabled -> GFP_ATOMIC */ 523 if ((res = usb_submit_urb(urb, GFP_ATOMIC))) { 524 IRDA_WARNING("%s(), failed Tx URB\n", __func__); 525 netdev->stats.tx_errors++; 526 /* Let USB recover : We will catch that in the watchdog */ 527 /*netif_start_queue(netdev);*/ 528 } else { 529 /* Increment packet stats */ 530 netdev->stats.tx_packets++; 531 netdev->stats.tx_bytes += skb->len; 532 533 netdev->trans_start = jiffies; 534 } 535 spin_unlock_irqrestore(&self->lock, flags); 536 537 return NETDEV_TX_OK; 538 539drop: 540 /* Drop silently the skb and exit */ 541 dev_kfree_skb(skb); 542 spin_unlock_irqrestore(&self->lock, flags); 543 return NETDEV_TX_OK; 544} 545 546/*------------------------------------------------------------------*/ 547/* 548 * Note : this function will be called only for tx_urb... 549 */ 550static void write_bulk_callback(struct urb *urb) 551{ 552 unsigned long flags; 553 struct sk_buff *skb = urb->context; 554 struct irda_usb_cb *self = ((struct irda_skb_cb *) skb->cb)->context; 555 556 IRDA_DEBUG(2, "%s()\n", __func__); 557 558 /* We should always have a context */ 559 IRDA_ASSERT(self != NULL, return;); 560 /* We should always be called for the speed URB */ 561 IRDA_ASSERT(urb == self->tx_urb, return;); 562 563 /* Free up the skb */ 564 dev_kfree_skb_any(skb); 565 urb->context = NULL; 566 567 /* Check for timeout and other USB nasties */ 568 if (urb->status != 0) { 569 /* I get a lot of -ECONNABORTED = -103 here - Jean II */ 570 IRDA_DEBUG(0, "%s(), URB complete status %d, transfer_flags 0x%04X\n", __func__, urb->status, urb->transfer_flags); 571 572 /* Don't do anything here, that might confuse the USB layer, 573 * and we could go in recursion and blow the kernel stack... 574 * Instead, we will wait for irda_usb_net_timeout(), the 575 * network layer watchdog, to fix the situation. 576 * Jean II */ 577 /* A reset of the dongle might be welcomed here - Jean II */ 578 return; 579 } 580 581 /* urb is now available */ 582 //urb->status = 0; -> tested above 583 584 /* Make sure we read self->present properly */ 585 spin_lock_irqsave(&self->lock, flags); 586 587 /* If the network is closed, stop everything */ 588 if ((!self->netopen) || (!self->present)) { 589 IRDA_DEBUG(0, "%s(), Network is gone...\n", __func__); 590 spin_unlock_irqrestore(&self->lock, flags); 591 return; 592 } 593 594 /* If changes to speed or xbofs is pending... */ 595 if ((self->new_speed != -1) || (self->new_xbofs != -1)) { 596 if ((self->new_speed != self->speed) || 597 (self->new_xbofs != self->xbofs)) { 598 /* We haven't changed speed yet (because of 599 * IUC_SPEED_BUG), so do it now - Jean II */ 600 IRDA_DEBUG(1, "%s(), Changing speed now...\n", __func__); 601 irda_usb_change_speed_xbofs(self); 602 } else { 603 /* New speed and xbof is now commited in hardware */ 604 self->new_speed = -1; 605 self->new_xbofs = -1; 606 /* Done, waiting for next packet */ 607 netif_wake_queue(self->netdev); 608 } 609 } else { 610 /* Otherwise, allow the stack to send more packets */ 611 netif_wake_queue(self->netdev); 612 } 613 spin_unlock_irqrestore(&self->lock, flags); 614} 615 616/*------------------------------------------------------------------*/ 617/* 618 * Watchdog timer from the network layer. 619 * After a predetermined timeout, if we don't give confirmation that 620 * the packet has been sent (i.e. no call to netif_wake_queue()), 621 * the network layer will call this function. 622 * Note that URB that we submit have also a timeout. When the URB timeout 623 * expire, the normal URB callback is called (write_bulk_callback()). 624 */ 625static void irda_usb_net_timeout(struct net_device *netdev) 626{ 627 unsigned long flags; 628 struct irda_usb_cb *self = netdev_priv(netdev); 629 struct urb *urb; 630 int done = 0; /* If we have made any progress */ 631 632 IRDA_DEBUG(0, "%s(), Network layer thinks we timed out!\n", __func__); 633 IRDA_ASSERT(self != NULL, return;); 634 635 /* Protect us from USB callbacks, net Tx and else. */ 636 spin_lock_irqsave(&self->lock, flags); 637 638 /* self->present *MUST* be read under spinlock */ 639 if (!self->present) { 640 IRDA_WARNING("%s(), device not present!\n", __func__); 641 netif_stop_queue(netdev); 642 spin_unlock_irqrestore(&self->lock, flags); 643 return; 644 } 645 646 /* Check speed URB */ 647 urb = self->speed_urb; 648 if (urb->status != 0) { 649 IRDA_DEBUG(0, "%s: Speed change timed out, urb->status=%d, urb->transfer_flags=0x%04X\n", netdev->name, urb->status, urb->transfer_flags); 650 651 switch (urb->status) { 652 case -EINPROGRESS: 653 usb_unlink_urb(urb); 654 /* Note : above will *NOT* call netif_wake_queue() 655 * in completion handler, we will come back here. 656 * Jean II */ 657 done = 1; 658 break; 659 case -ECONNRESET: 660 case -ENOENT: /* urb unlinked by us */ 661 default: /* ??? - Play safe */ 662 urb->status = 0; 663 netif_wake_queue(self->netdev); 664 done = 1; 665 break; 666 } 667 } 668 669 /* Check Tx URB */ 670 urb = self->tx_urb; 671 if (urb->status != 0) { 672 struct sk_buff *skb = urb->context; 673 674 IRDA_DEBUG(0, "%s: Tx timed out, urb->status=%d, urb->transfer_flags=0x%04X\n", netdev->name, urb->status, urb->transfer_flags); 675 676 /* Increase error count */ 677 netdev->stats.tx_errors++; 678 679#ifdef IU_BUG_KICK_TIMEOUT 680 /* Can't be a bad idea to reset the speed ;-) - Jean II */ 681 if(self->new_speed == -1) 682 self->new_speed = self->speed; 683 if(self->new_xbofs == -1) 684 self->new_xbofs = self->xbofs; 685 irda_usb_change_speed_xbofs(self); 686#endif /* IU_BUG_KICK_TIMEOUT */ 687 688 switch (urb->status) { 689 case -EINPROGRESS: 690 usb_unlink_urb(urb); 691 /* Note : above will *NOT* call netif_wake_queue() 692 * in completion handler, because urb->status will 693 * be -ENOENT. We will fix that at the next watchdog, 694 * leaving more time to USB to recover... 695 * Jean II */ 696 done = 1; 697 break; 698 case -ECONNRESET: 699 case -ENOENT: /* urb unlinked by us */ 700 default: /* ??? - Play safe */ 701 if(skb != NULL) { 702 dev_kfree_skb_any(skb); 703 urb->context = NULL; 704 } 705 urb->status = 0; 706 netif_wake_queue(self->netdev); 707 done = 1; 708 break; 709 } 710 } 711 spin_unlock_irqrestore(&self->lock, flags); 712 713 /* Maybe we need a reset */ 714 /* Note : Some drivers seem to use a usb_set_interface() when they 715 * need to reset the hardware. Hum... 716 */ 717 718 /* if(done == 0) */ 719} 720 721/************************* RECEIVE ROUTINES *************************/ 722 723/* 724 * Note : 725 * Some of you may have noticed that most dongle have an interrupt in pipe 726 * that we don't use. Here is the little secret... 727 * When we hang a Rx URB on the bulk in pipe, it generates some USB traffic 728 * in every USB frame. This is unnecessary overhead. 729 * The interrupt in pipe will generate an event every time a packet is 730 * received. Reading an interrupt pipe adds minimal overhead, but has some 731 * latency (~1ms). 732 * If we are connected (speed != 9600), we want to minimise latency, so 733 * we just always hang the Rx URB and ignore the interrupt. 734 * If we are not connected (speed == 9600), there is usually no Rx traffic, 735 * and we want to minimise the USB overhead. In this case we should wait 736 * on the interrupt pipe and hang the Rx URB only when an interrupt is 737 * received. 738 * Jean II 739 * 740 * Note : don't read the above as what we are currently doing, but as 741 * something we could do with KC dongle. Also don't forget that the 742 * interrupt pipe is not part of the original standard, so this would 743 * need to be optional... 744 * Jean II 745 */ 746 747/*------------------------------------------------------------------*/ 748/* 749 * Submit a Rx URB to the USB layer to handle reception of a frame 750 * Mostly called by the completion callback of the previous URB. 751 * 752 * Jean II 753 */ 754static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struct urb *urb) 755{ 756 struct irda_skb_cb *cb; 757 int ret; 758 759 IRDA_DEBUG(2, "%s()\n", __func__); 760 761 /* This should never happen */ 762 IRDA_ASSERT(skb != NULL, return;); 763 IRDA_ASSERT(urb != NULL, return;); 764 765 /* Save ourselves in the skb */ 766 cb = (struct irda_skb_cb *) skb->cb; 767 cb->context = self; 768 769 /* Reinitialize URB */ 770 usb_fill_bulk_urb(urb, self->usbdev, 771 usb_rcvbulkpipe(self->usbdev, self->bulk_in_ep), 772 skb->data, IRDA_SKB_MAX_MTU, 773 irda_usb_receive, skb); 774 urb->status = 0; 775 776 /* Can be called from irda_usb_receive (irq handler) -> GFP_ATOMIC */ 777 ret = usb_submit_urb(urb, GFP_ATOMIC); 778 if (ret) { 779 /* If this ever happen, we are in deep s***. 780 * Basically, the Rx path will stop... */ 781 IRDA_WARNING("%s(), Failed to submit Rx URB %d\n", 782 __func__, ret); 783 } 784} 785 786/*------------------------------------------------------------------*/ 787/* 788 * Function irda_usb_receive(urb) 789 * 790 * Called by the USB subsystem when a frame has been received 791 * 792 */ 793static void irda_usb_receive(struct urb *urb) 794{ 795 struct sk_buff *skb = (struct sk_buff *) urb->context; 796 struct irda_usb_cb *self; 797 struct irda_skb_cb *cb; 798 struct sk_buff *newskb; 799 struct sk_buff *dataskb; 800 struct urb *next_urb; 801 unsigned int len, docopy; 802 803 IRDA_DEBUG(2, "%s(), len=%d\n", __func__, urb->actual_length); 804 805 /* Find ourselves */ 806 cb = (struct irda_skb_cb *) skb->cb; 807 IRDA_ASSERT(cb != NULL, return;); 808 self = (struct irda_usb_cb *) cb->context; 809 IRDA_ASSERT(self != NULL, return;); 810 811 /* If the network is closed or the device gone, stop everything */ 812 if ((!self->netopen) || (!self->present)) { 813 IRDA_DEBUG(0, "%s(), Network is gone!\n", __func__); 814 /* Don't re-submit the URB : will stall the Rx path */ 815 return; 816 } 817 818 /* Check the status */ 819 if (urb->status != 0) { 820 switch (urb->status) { 821 case -EILSEQ: 822 self->netdev->stats.rx_crc_errors++; 823 /* Also precursor to a hot-unplug on UHCI. */ 824 /* Fallthrough... */ 825 case -ECONNRESET: 826 /* Random error, if I remember correctly */ 827 /* uhci_cleanup_unlink() is going to kill the Rx 828 * URB just after we return. No problem, at this 829 * point the URB will be idle ;-) - Jean II */ 830 case -ESHUTDOWN: 831 /* That's usually a hot-unplug. Submit will fail... */ 832 case -ETIME: 833 /* Usually precursor to a hot-unplug on OHCI. */ 834 default: 835 self->netdev->stats.rx_errors++; 836 IRDA_DEBUG(0, "%s(), RX status %d, transfer_flags 0x%04X\n", __func__, urb->status, urb->transfer_flags); 837 break; 838 } 839 /* If we received an error, we don't want to resubmit the 840 * Rx URB straight away but to give the USB layer a little 841 * bit of breathing room. 842 * We are in the USB thread context, therefore there is a 843 * danger of recursion (new URB we submit fails, we come 844 * back here). 845 * With recent USB stack (2.6.15+), I'm seeing that on 846 * hot unplug of the dongle... 847 * Lowest effective timer is 10ms... 848 * Jean II */ 849 self->rx_defer_timer.function = irda_usb_rx_defer_expired; 850 self->rx_defer_timer.data = (unsigned long) urb; 851 mod_timer(&self->rx_defer_timer, jiffies + (10 * HZ / 1000)); 852 return; 853 } 854 855 /* Check for empty frames */ 856 if (urb->actual_length <= self->header_length) { 857 IRDA_WARNING("%s(), empty frame!\n", __func__); 858 goto done; 859 } 860 861 /* 862 * Remember the time we received this frame, so we can 863 * reduce the min turn time a bit since we will know 864 * how much time we have used for protocol processing 865 */ 866 do_gettimeofday(&self->stamp); 867 868 /* Check if we need to copy the data to a new skb or not. 869 * For most frames, we use ZeroCopy and pass the already 870 * allocated skb up the stack. 871 * If the frame is small, it is more efficient to copy it 872 * to save memory (copy will be fast anyway - that's 873 * called Rx-copy-break). Jean II */ 874 docopy = (urb->actual_length < IRDA_RX_COPY_THRESHOLD); 875 876 /* Allocate a new skb */ 877 if (self->capability & IUC_STIR421X) 878 newskb = dev_alloc_skb(docopy ? urb->actual_length : 879 IRDA_SKB_MAX_MTU + 880 USB_IRDA_STIR421X_HEADER); 881 else 882 newskb = dev_alloc_skb(docopy ? urb->actual_length : 883 IRDA_SKB_MAX_MTU); 884 885 if (!newskb) { 886 self->netdev->stats.rx_dropped++; 887 /* We could deliver the current skb, but this would stall 888 * the Rx path. Better drop the packet... Jean II */ 889 goto done; 890 } 891 892 /* Make sure IP header get aligned (IrDA header is 5 bytes) */ 893 /* But IrDA-USB header is 1 byte. Jean II */ 894 //skb_reserve(newskb, USB_IRDA_HEADER - 1); 895 896 if(docopy) { 897 /* Copy packet, so we can recycle the original */ 898 skb_copy_from_linear_data(skb, newskb->data, urb->actual_length); 899 /* Deliver this new skb */ 900 dataskb = newskb; 901 /* And hook the old skb to the URB 902 * Note : we don't need to "clean up" the old skb, 903 * as we never touched it. Jean II */ 904 } else { 905 /* We are using ZeroCopy. Deliver old skb */ 906 dataskb = skb; 907 /* And hook the new skb to the URB */ 908 skb = newskb; 909 } 910 911 /* Set proper length on skb & remove USB-IrDA header */ 912 skb_put(dataskb, urb->actual_length); 913 skb_pull(dataskb, self->header_length); 914 915 /* Ask the networking layer to queue the packet for the IrDA stack */ 916 dataskb->dev = self->netdev; 917 skb_reset_mac_header(dataskb); 918 dataskb->protocol = htons(ETH_P_IRDA); 919 len = dataskb->len; 920 netif_rx(dataskb); 921 922 /* Keep stats up to date */ 923 self->netdev->stats.rx_bytes += len; 924 self->netdev->stats.rx_packets++; 925 926done: 927 /* Note : at this point, the URB we've just received (urb) 928 * is still referenced by the USB layer. For example, if we 929 * have received a -ECONNRESET, uhci_cleanup_unlink() will 930 * continue to process it (in fact, cleaning it up). 931 * If we were to submit this URB, disaster would ensue. 932 * Therefore, we submit our idle URB, and put this URB in our 933 * idle slot.... 934 * Jean II */ 935 /* Note : with this scheme, we could submit the idle URB before 936 * processing the Rx URB. I don't think it would buy us anything as 937 * we are running in the USB thread context. Jean II */ 938 next_urb = self->idle_rx_urb; 939 940 /* Recycle Rx URB : Now, the idle URB is the present one */ 941 urb->context = NULL; 942 self->idle_rx_urb = urb; 943 944 /* Submit the idle URB to replace the URB we've just received. 945 * Do it last to avoid race conditions... Jean II */ 946 irda_usb_submit(self, skb, next_urb); 947} 948 949/*------------------------------------------------------------------*/ 950/* 951 * In case of errors, we want the USB layer to have time to recover. 952 * Now, it is time to resubmit ouur Rx URB... 953 */ 954static void irda_usb_rx_defer_expired(unsigned long data) 955{ 956 struct urb *urb = (struct urb *) data; 957 struct sk_buff *skb = (struct sk_buff *) urb->context; 958 struct irda_usb_cb *self; 959 struct irda_skb_cb *cb; 960 struct urb *next_urb; 961 962 IRDA_DEBUG(2, "%s()\n", __func__); 963 964 /* Find ourselves */ 965 cb = (struct irda_skb_cb *) skb->cb; 966 IRDA_ASSERT(cb != NULL, return;); 967 self = (struct irda_usb_cb *) cb->context; 968 IRDA_ASSERT(self != NULL, return;); 969 970 /* Same stuff as when Rx is done, see above... */ 971 next_urb = self->idle_rx_urb; 972 urb->context = NULL; 973 self->idle_rx_urb = urb; 974 irda_usb_submit(self, skb, next_urb); 975} 976 977/*------------------------------------------------------------------*/ 978/* 979 * Callbak from IrDA layer. IrDA wants to know if we have 980 * started receiving anything. 981 */ 982static int irda_usb_is_receiving(struct irda_usb_cb *self) 983{ 984 /* Note : because of the way UHCI works, it's almost impossible 985 * to get this info. The Controller DMA directly to memory and 986 * signal only when the whole frame is finished. To know if the 987 * first TD of the URB has been filled or not seems hard work... 988 * 989 * The other solution would be to use the "receiving" command 990 * on the default decriptor with a usb_control_msg(), but that 991 * would add USB traffic and would return result only in the 992 * next USB frame (~1ms). 993 * 994 * I've been told that current dongles send status info on their 995 * interrupt endpoint, and that's what the Windows driver uses 996 * to know this info. Unfortunately, this is not yet in the spec... 997 * 998 * Jean II 999 */ 1000 1001 return 0; /* For now */ 1002} 1003 1004#define STIR421X_PATCH_PRODUCT_VER "Product Version: " 1005#define STIR421X_PATCH_STMP_TAG "STMP" 1006#define STIR421X_PATCH_CODE_OFFSET 512 /* patch image starts before here */ 1007/* marks end of patch file header (PC DOS text file EOF character) */ 1008#define STIR421X_PATCH_END_OF_HDR_TAG 0x1A 1009#define STIR421X_PATCH_BLOCK_SIZE 1023 1010 1011/* 1012 * Function stir421x_fwupload (struct irda_usb_cb *self, 1013 * unsigned char *patch, 1014 * const unsigned int patch_len) 1015 * 1016 * Upload firmware code to SigmaTel 421X IRDA-USB dongle 1017 */ 1018static int stir421x_fw_upload(struct irda_usb_cb *self, 1019 const unsigned char *patch, 1020 const unsigned int patch_len) 1021{ 1022 int ret = -ENOMEM; 1023 int actual_len = 0; 1024 unsigned int i; 1025 unsigned int block_size = 0; 1026 unsigned char *patch_block; 1027 1028 patch_block = kzalloc(STIR421X_PATCH_BLOCK_SIZE, GFP_KERNEL); 1029 if (patch_block == NULL) 1030 return -ENOMEM; 1031 1032 /* break up patch into 1023-byte sections */ 1033 for (i = 0; i < patch_len; i += block_size) { 1034 block_size = patch_len - i; 1035 1036 if (block_size > STIR421X_PATCH_BLOCK_SIZE) 1037 block_size = STIR421X_PATCH_BLOCK_SIZE; 1038 1039 /* upload the patch section */ 1040 memcpy(patch_block, patch + i, block_size); 1041 1042 ret = usb_bulk_msg(self->usbdev, 1043 usb_sndbulkpipe(self->usbdev, 1044 self->bulk_out_ep), 1045 patch_block, block_size, 1046 &actual_len, msecs_to_jiffies(500)); 1047 IRDA_DEBUG(3,"%s(): Bulk send %u bytes, ret=%d\n", 1048 __func__, actual_len, ret); 1049 1050 if (ret < 0) 1051 break; 1052 1053 mdelay(10); 1054 } 1055 1056 kfree(patch_block); 1057 1058 return ret; 1059 } 1060 1061/* 1062 * Function stir421x_patch_device(struct irda_usb_cb *self) 1063 * 1064 * Get a firmware code from userspase using hotplug request_firmware() call 1065 */ 1066static int stir421x_patch_device(struct irda_usb_cb *self) 1067{ 1068 unsigned int i; 1069 int ret; 1070 char stir421x_fw_name[12]; 1071 const struct firmware *fw; 1072 const unsigned char *fw_version_ptr; /* pointer to version string */ 1073 unsigned long fw_version = 0; 1074 1075 /* 1076 * Known firmware patch file names for STIR421x dongles 1077 * are "42101001.sb" or "42101002.sb" 1078 */ 1079 sprintf(stir421x_fw_name, "4210%4X.sb", 1080 self->usbdev->descriptor.bcdDevice); 1081 ret = request_firmware(&fw, stir421x_fw_name, &self->usbdev->dev); 1082 if (ret < 0) 1083 return ret; 1084 1085 /* We get a patch from userspace */ 1086 IRDA_MESSAGE("%s(): Received firmware %s (%zu bytes)\n", 1087 __func__, stir421x_fw_name, fw->size); 1088 1089 ret = -EINVAL; 1090 1091 /* Get the bcd product version */ 1092 if (!memcmp(fw->data, STIR421X_PATCH_PRODUCT_VER, 1093 sizeof(STIR421X_PATCH_PRODUCT_VER) - 1)) { 1094 fw_version_ptr = fw->data + 1095 sizeof(STIR421X_PATCH_PRODUCT_VER) - 1; 1096 1097 /* Let's check if the product version is dotted */ 1098 if (fw_version_ptr[3] == '.' && 1099 fw_version_ptr[7] == '.') { 1100 unsigned long major, minor, build; 1101 major = simple_strtoul(fw_version_ptr, NULL, 10); 1102 minor = simple_strtoul(fw_version_ptr + 4, NULL, 10); 1103 build = simple_strtoul(fw_version_ptr + 8, NULL, 10); 1104 1105 fw_version = (major << 12) 1106 + (minor << 8) 1107 + ((build / 10) << 4) 1108 + (build % 10); 1109 1110 IRDA_DEBUG(3, "%s(): Firmware Product version %ld\n", 1111 __func__, fw_version); 1112 } 1113 } 1114 1115 if (self->usbdev->descriptor.bcdDevice == cpu_to_le16(fw_version)) { 1116 /* 1117 * If we're here, we've found a correct patch 1118 * The actual image starts after the "STMP" keyword 1119 * so forward to the firmware header tag 1120 */ 1121 for (i = 0; (fw->data[i] != STIR421X_PATCH_END_OF_HDR_TAG) && 1122 (i < fw->size); i++) ; 1123 /* here we check for the out of buffer case */ 1124 if ((STIR421X_PATCH_END_OF_HDR_TAG == fw->data[i]) && 1125 (i < STIR421X_PATCH_CODE_OFFSET)) { 1126 if (!memcmp(fw->data + i + 1, STIR421X_PATCH_STMP_TAG, 1127 sizeof(STIR421X_PATCH_STMP_TAG) - 1)) { 1128 1129 /* We can upload the patch to the target */ 1130 i += sizeof(STIR421X_PATCH_STMP_TAG); 1131 ret = stir421x_fw_upload(self, &fw->data[i], 1132 fw->size - i); 1133 } 1134 } 1135 } 1136 1137 release_firmware(fw); 1138 1139 return ret; 1140} 1141 1142 1143/********************** IRDA DEVICE CALLBACKS **********************/ 1144/* 1145 * Main calls from the IrDA/Network subsystem. 1146 * Mostly registering a new irda-usb device and removing it.... 1147 * We only deal with the IrDA side of the business, the USB side will 1148 * be dealt with below... 1149 */ 1150 1151 1152/*------------------------------------------------------------------*/ 1153/* 1154 * Function irda_usb_net_open (dev) 1155 * 1156 * Network device is taken up. Usually this is done by "ifconfig irda0 up" 1157 * 1158 * Note : don't mess with self->netopen - Jean II 1159 */ 1160static int irda_usb_net_open(struct net_device *netdev) 1161{ 1162 struct irda_usb_cb *self; 1163 unsigned long flags; 1164 char hwname[16]; 1165 int i; 1166 1167 IRDA_DEBUG(1, "%s()\n", __func__); 1168 1169 IRDA_ASSERT(netdev != NULL, return -1;); 1170 self = netdev_priv(netdev); 1171 IRDA_ASSERT(self != NULL, return -1;); 1172 1173 spin_lock_irqsave(&self->lock, flags); 1174 /* Can only open the device if it's there */ 1175 if(!self->present) { 1176 spin_unlock_irqrestore(&self->lock, flags); 1177 IRDA_WARNING("%s(), device not present!\n", __func__); 1178 return -1; 1179 } 1180 1181 if(self->needspatch) { 1182 spin_unlock_irqrestore(&self->lock, flags); 1183 IRDA_WARNING("%s(), device needs patch\n", __func__) ; 1184 return -EIO ; 1185 } 1186 1187 /* Initialise default speed and xbofs value 1188 * (IrLAP will change that soon) */ 1189 self->speed = -1; 1190 self->xbofs = -1; 1191 self->new_speed = -1; 1192 self->new_xbofs = -1; 1193 1194 /* To do *before* submitting Rx urbs and starting net Tx queue 1195 * Jean II */ 1196 self->netopen = 1; 1197 spin_unlock_irqrestore(&self->lock, flags); 1198 1199 /* 1200 * Now that everything should be initialized properly, 1201 * Open new IrLAP layer instance to take care of us... 1202 * Note : will send immediately a speed change... 1203 */ 1204 sprintf(hwname, "usb#%d", self->usbdev->devnum); 1205 self->irlap = irlap_open(netdev, &self->qos, hwname); 1206 IRDA_ASSERT(self->irlap != NULL, return -1;); 1207 1208 /* Allow IrLAP to send data to us */ 1209 netif_start_queue(netdev); 1210 1211 /* We submit all the Rx URB except for one that we keep idle. 1212 * Need to be initialised before submitting other USBs, because 1213 * in some cases as soon as we submit the URBs the USB layer 1214 * will trigger a dummy receive - Jean II */ 1215 self->idle_rx_urb = self->rx_urb[IU_MAX_ACTIVE_RX_URBS]; 1216 self->idle_rx_urb->context = NULL; 1217 1218 /* Now that we can pass data to IrLAP, allow the USB layer 1219 * to send us some data... */ 1220 for (i = 0; i < IU_MAX_ACTIVE_RX_URBS; i++) { 1221 struct sk_buff *skb = dev_alloc_skb(IRDA_SKB_MAX_MTU); 1222 if (!skb) { 1223 /* If this ever happen, we are in deep s***. 1224 * Basically, we can't start the Rx path... */ 1225 IRDA_WARNING("%s(), Failed to allocate Rx skb\n", 1226 __func__); 1227 return -1; 1228 } 1229 //skb_reserve(newskb, USB_IRDA_HEADER - 1); 1230 irda_usb_submit(self, skb, self->rx_urb[i]); 1231 } 1232 1233 /* Ready to play !!! */ 1234 return 0; 1235} 1236 1237/*------------------------------------------------------------------*/ 1238/* 1239 * Function irda_usb_net_close (self) 1240 * 1241 * Network device is taken down. Usually this is done by 1242 * "ifconfig irda0 down" 1243 */ 1244static int irda_usb_net_close(struct net_device *netdev) 1245{ 1246 struct irda_usb_cb *self; 1247 int i; 1248 1249 IRDA_DEBUG(1, "%s()\n", __func__); 1250 1251 IRDA_ASSERT(netdev != NULL, return -1;); 1252 self = netdev_priv(netdev); 1253 IRDA_ASSERT(self != NULL, return -1;); 1254 1255 /* Clear this flag *before* unlinking the urbs and *before* 1256 * stopping the network Tx queue - Jean II */ 1257 self->netopen = 0; 1258 1259 /* Stop network Tx queue */ 1260 netif_stop_queue(netdev); 1261 1262 /* Kill defered Rx URB */ 1263 del_timer(&self->rx_defer_timer); 1264 1265 /* Deallocate all the Rx path buffers (URBs and skb) */ 1266 for (i = 0; i < self->max_rx_urb; i++) { 1267 struct urb *urb = self->rx_urb[i]; 1268 struct sk_buff *skb = (struct sk_buff *) urb->context; 1269 /* Cancel the receive command */ 1270 usb_kill_urb(urb); 1271 /* The skb is ours, free it */ 1272 if(skb) { 1273 dev_kfree_skb(skb); 1274 urb->context = NULL; 1275 } 1276 } 1277 /* Cancel Tx and speed URB - need to be synchronous to avoid races */ 1278 usb_kill_urb(self->tx_urb); 1279 usb_kill_urb(self->speed_urb); 1280 1281 /* Stop and remove instance of IrLAP */ 1282 if (self->irlap) 1283 irlap_close(self->irlap); 1284 self->irlap = NULL; 1285 1286 return 0; 1287} 1288 1289/*------------------------------------------------------------------*/ 1290/* 1291 * IOCTLs : Extra out-of-band network commands... 1292 */ 1293static int irda_usb_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 1294{ 1295 unsigned long flags; 1296 struct if_irda_req *irq = (struct if_irda_req *) rq; 1297 struct irda_usb_cb *self; 1298 int ret = 0; 1299 1300 IRDA_ASSERT(dev != NULL, return -1;); 1301 self = netdev_priv(dev); 1302 IRDA_ASSERT(self != NULL, return -1;); 1303 1304 IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __func__, dev->name, cmd); 1305 1306 switch (cmd) { 1307 case SIOCSBANDWIDTH: /* Set bandwidth */ 1308 if (!capable(CAP_NET_ADMIN)) 1309 return -EPERM; 1310 /* Protect us from USB callbacks, net watchdog and else. */ 1311 spin_lock_irqsave(&self->lock, flags); 1312 /* Check if the device is still there */ 1313 if(self->present) { 1314 /* Set the desired speed */ 1315 self->new_speed = irq->ifr_baudrate; 1316 irda_usb_change_speed_xbofs(self); 1317 } 1318 spin_unlock_irqrestore(&self->lock, flags); 1319 break; 1320 case SIOCSMEDIABUSY: /* Set media busy */ 1321 if (!capable(CAP_NET_ADMIN)) 1322 return -EPERM; 1323 /* Check if the IrDA stack is still there */ 1324 if(self->netopen) 1325 irda_device_set_media_busy(self->netdev, TRUE); 1326 break; 1327 case SIOCGRECEIVING: /* Check if we are receiving right now */ 1328 irq->ifr_receiving = irda_usb_is_receiving(self); 1329 break; 1330 default: 1331 ret = -EOPNOTSUPP; 1332 } 1333 1334 return ret; 1335} 1336 1337/*------------------------------------------------------------------*/ 1338 1339/********************* IRDA CONFIG SUBROUTINES *********************/ 1340/* 1341 * Various subroutines dealing with IrDA and network stuff we use to 1342 * configure and initialise each irda-usb instance. 1343 * These functions are used below in the main calls of the driver... 1344 */ 1345 1346/*------------------------------------------------------------------*/ 1347/* 1348 * Set proper values in the IrDA QOS structure 1349 */ 1350static inline void irda_usb_init_qos(struct irda_usb_cb *self) 1351{ 1352 struct irda_class_desc *desc; 1353 1354 IRDA_DEBUG(3, "%s()\n", __func__); 1355 1356 desc = self->irda_desc; 1357 1358 /* Initialize QoS for this device */ 1359 irda_init_max_qos_capabilies(&self->qos); 1360 1361 /* See spec section 7.2 for meaning. 1362 * Values are little endian (as most USB stuff), the IrDA stack 1363 * use it in native order (see parameters.c). - Jean II */ 1364 self->qos.baud_rate.bits = le16_to_cpu(desc->wBaudRate); 1365 self->qos.min_turn_time.bits = desc->bmMinTurnaroundTime; 1366 self->qos.additional_bofs.bits = desc->bmAdditionalBOFs; 1367 self->qos.window_size.bits = desc->bmWindowSize; 1368 self->qos.data_size.bits = desc->bmDataSize; 1369 1370 IRDA_DEBUG(0, "%s(), dongle says speed=0x%X, size=0x%X, window=0x%X, bofs=0x%X, turn=0x%X\n", 1371 __func__, self->qos.baud_rate.bits, self->qos.data_size.bits, self->qos.window_size.bits, self->qos.additional_bofs.bits, self->qos.min_turn_time.bits); 1372 1373 /* Don't always trust what the dongle tell us */ 1374 if(self->capability & IUC_SIR_ONLY) 1375 self->qos.baud_rate.bits &= 0x00ff; 1376 if(self->capability & IUC_SMALL_PKT) 1377 self->qos.data_size.bits = 0x07; 1378 if(self->capability & IUC_NO_WINDOW) 1379 self->qos.window_size.bits = 0x01; 1380 if(self->capability & IUC_MAX_WINDOW) 1381 self->qos.window_size.bits = 0x7f; 1382 if(self->capability & IUC_MAX_XBOFS) 1383 self->qos.additional_bofs.bits = 0x01; 1384 1385 /* Module parameter can override the rx window size */ 1386 if (qos_mtt_bits) 1387 self->qos.min_turn_time.bits = qos_mtt_bits; 1388 /* 1389 * Note : most of those values apply only for the receive path, 1390 * the transmit path will be set differently - Jean II 1391 */ 1392 irda_qos_bits_to_value(&self->qos); 1393} 1394 1395/*------------------------------------------------------------------*/ 1396static const struct net_device_ops irda_usb_netdev_ops = { 1397 .ndo_open = irda_usb_net_open, 1398 .ndo_stop = irda_usb_net_close, 1399 .ndo_do_ioctl = irda_usb_net_ioctl, 1400 .ndo_start_xmit = irda_usb_hard_xmit, 1401 .ndo_tx_timeout = irda_usb_net_timeout, 1402}; 1403 1404/* 1405 * Initialise the network side of the irda-usb instance 1406 * Called when a new USB instance is registered in irda_usb_probe() 1407 */ 1408static inline int irda_usb_open(struct irda_usb_cb *self) 1409{ 1410 struct net_device *netdev = self->netdev; 1411 1412 IRDA_DEBUG(1, "%s()\n", __func__); 1413 1414 netdev->netdev_ops = &irda_usb_netdev_ops; 1415 1416 irda_usb_init_qos(self); 1417 1418 return register_netdev(netdev); 1419} 1420 1421/*------------------------------------------------------------------*/ 1422/* 1423 * Cleanup the network side of the irda-usb instance 1424 * Called when a USB instance is removed in irda_usb_disconnect() 1425 */ 1426static inline void irda_usb_close(struct irda_usb_cb *self) 1427{ 1428 IRDA_DEBUG(1, "%s()\n", __func__); 1429 1430 /* Remove netdevice */ 1431 unregister_netdev(self->netdev); 1432 1433 /* Remove the speed buffer */ 1434 kfree(self->speed_buff); 1435 self->speed_buff = NULL; 1436 1437 kfree(self->tx_buff); 1438 self->tx_buff = NULL; 1439} 1440 1441/********************** USB CONFIG SUBROUTINES **********************/ 1442/* 1443 * Various subroutines dealing with USB stuff we use to configure and 1444 * initialise each irda-usb instance. 1445 * These functions are used below in the main calls of the driver... 1446 */ 1447 1448/*------------------------------------------------------------------*/ 1449/* 1450 * Function irda_usb_parse_endpoints(dev, ifnum) 1451 * 1452 * Parse the various endpoints and find the one we need. 1453 * 1454 * The endpoint are the pipes used to communicate with the USB device. 1455 * The spec defines 2 endpoints of type bulk transfer, one in, and one out. 1456 * These are used to pass frames back and forth with the dongle. 1457 * Most dongle have also an interrupt endpoint, that will be probably 1458 * documented in the next spec... 1459 */ 1460static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_host_endpoint *endpoint, int ennum) 1461{ 1462 int i; /* Endpoint index in table */ 1463 1464 /* Init : no endpoints */ 1465 self->bulk_in_ep = 0; 1466 self->bulk_out_ep = 0; 1467 self->bulk_int_ep = 0; 1468 1469 /* Let's look at all those endpoints */ 1470 for(i = 0; i < ennum; i++) { 1471 /* All those variables will get optimised by the compiler, 1472 * so let's aim for clarity... - Jean II */ 1473 __u8 ep; /* Endpoint address */ 1474 __u8 dir; /* Endpoint direction */ 1475 __u8 attr; /* Endpoint attribute */ 1476 __u16 psize; /* Endpoint max packet size in bytes */ 1477 1478 /* Get endpoint address, direction and attribute */ 1479 ep = endpoint[i].desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; 1480 dir = endpoint[i].desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK; 1481 attr = endpoint[i].desc.bmAttributes; 1482 psize = le16_to_cpu(endpoint[i].desc.wMaxPacketSize); 1483 1484 /* Is it a bulk endpoint ??? */ 1485 if(attr == USB_ENDPOINT_XFER_BULK) { 1486 /* We need to find an IN and an OUT */ 1487 if(dir == USB_DIR_IN) { 1488 /* This is our Rx endpoint */ 1489 self->bulk_in_ep = ep; 1490 } else { 1491 /* This is our Tx endpoint */ 1492 self->bulk_out_ep = ep; 1493 self->bulk_out_mtu = psize; 1494 } 1495 } else { 1496 if((attr == USB_ENDPOINT_XFER_INT) && 1497 (dir == USB_DIR_IN)) { 1498 /* This is our interrupt endpoint */ 1499 self->bulk_int_ep = ep; 1500 } else { 1501 IRDA_ERROR("%s(), Unrecognised endpoint %02X.\n", __func__, ep); 1502 } 1503 } 1504 } 1505 1506 IRDA_DEBUG(0, "%s(), And our endpoints are : in=%02X, out=%02X (%d), int=%02X\n", 1507 __func__, self->bulk_in_ep, self->bulk_out_ep, self->bulk_out_mtu, self->bulk_int_ep); 1508 1509 return((self->bulk_in_ep != 0) && (self->bulk_out_ep != 0)); 1510} 1511 1512#ifdef IU_DUMP_CLASS_DESC 1513/*------------------------------------------------------------------*/ 1514/* 1515 * Function usb_irda_dump_class_desc(desc) 1516 * 1517 * Prints out the contents of the IrDA class descriptor 1518 * 1519 */ 1520static inline void irda_usb_dump_class_desc(struct irda_class_desc *desc) 1521{ 1522 /* Values are little endian */ 1523 printk("bLength=%x\n", desc->bLength); 1524 printk("bDescriptorType=%x\n", desc->bDescriptorType); 1525 printk("bcdSpecRevision=%x\n", le16_to_cpu(desc->bcdSpecRevision)); 1526 printk("bmDataSize=%x\n", desc->bmDataSize); 1527 printk("bmWindowSize=%x\n", desc->bmWindowSize); 1528 printk("bmMinTurnaroundTime=%d\n", desc->bmMinTurnaroundTime); 1529 printk("wBaudRate=%x\n", le16_to_cpu(desc->wBaudRate)); 1530 printk("bmAdditionalBOFs=%x\n", desc->bmAdditionalBOFs); 1531 printk("bIrdaRateSniff=%x\n", desc->bIrdaRateSniff); 1532 printk("bMaxUnicastList=%x\n", desc->bMaxUnicastList); 1533} 1534#endif /* IU_DUMP_CLASS_DESC */ 1535 1536/*------------------------------------------------------------------*/ 1537/* 1538 * Function irda_usb_find_class_desc(intf) 1539 * 1540 * Returns instance of IrDA class descriptor, or NULL if not found 1541 * 1542 * The class descriptor is some extra info that IrDA USB devices will 1543 * offer to us, describing their IrDA characteristics. We will use that in 1544 * irda_usb_init_qos() 1545 */ 1546static inline struct irda_class_desc *irda_usb_find_class_desc(struct usb_interface *intf) 1547{ 1548 struct usb_device *dev = interface_to_usbdev (intf); 1549 struct irda_class_desc *desc; 1550 int ret; 1551 1552 desc = kzalloc(sizeof(*desc), GFP_KERNEL); 1553 if (!desc) 1554 return NULL; 1555 1556 /* USB-IrDA class spec 1.0: 1557 * 6.1.3: Standard "Get Descriptor" Device Request is not 1558 * appropriate to retrieve class-specific descriptor 1559 * 6.2.5: Class Specific "Get Class Descriptor" Interface Request 1560 * is mandatory and returns the USB-IrDA class descriptor 1561 */ 1562 1563 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0), 1564 IU_REQ_GET_CLASS_DESC, 1565 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 1566 0, intf->altsetting->desc.bInterfaceNumber, desc, 1567 sizeof(*desc), 500); 1568 1569 IRDA_DEBUG(1, "%s(), ret=%d\n", __func__, ret); 1570 if (ret < sizeof(*desc)) { 1571 IRDA_WARNING("usb-irda: class_descriptor read %s (%d)\n", 1572 (ret<0) ? "failed" : "too short", ret); 1573 } 1574 else if (desc->bDescriptorType != USB_DT_IRDA) { 1575 IRDA_WARNING("usb-irda: bad class_descriptor type\n"); 1576 } 1577 else { 1578#ifdef IU_DUMP_CLASS_DESC 1579 irda_usb_dump_class_desc(desc); 1580#endif /* IU_DUMP_CLASS_DESC */ 1581 1582 return desc; 1583 } 1584 kfree(desc); 1585 return NULL; 1586} 1587 1588/*********************** USB DEVICE CALLBACKS ***********************/ 1589/* 1590 * Main calls from the USB subsystem. 1591 * Mostly registering a new irda-usb device and removing it.... 1592 */ 1593 1594/*------------------------------------------------------------------*/ 1595/* 1596 * This routine is called by the USB subsystem for each new device 1597 * in the system. We need to check if the device is ours, and in 1598 * this case start handling it. 1599 * The USB layer protect us from reentrancy (via BKL), so we don't need 1600 * to spinlock in there... Jean II 1601 */ 1602static int irda_usb_probe(struct usb_interface *intf, 1603 const struct usb_device_id *id) 1604{ 1605 struct net_device *net; 1606 struct usb_device *dev = interface_to_usbdev(intf); 1607 struct irda_usb_cb *self; 1608 struct usb_host_interface *interface; 1609 struct irda_class_desc *irda_desc; 1610 int ret = -ENOMEM; 1611 int i; /* Driver instance index / Rx URB index */ 1612 1613 /* Note : the probe make sure to call us only for devices that 1614 * matches the list of dongle (top of the file). So, we 1615 * don't need to check if the dongle is really ours. 1616 * Jean II */ 1617 1618 IRDA_MESSAGE("IRDA-USB found at address %d, Vendor: %x, Product: %x\n", 1619 dev->devnum, le16_to_cpu(dev->descriptor.idVendor), 1620 le16_to_cpu(dev->descriptor.idProduct)); 1621 1622 net = alloc_irdadev(sizeof(*self)); 1623 if (!net) 1624 goto err_out; 1625 1626 SET_NETDEV_DEV(net, &intf->dev); 1627 self = netdev_priv(net); 1628 self->netdev = net; 1629 spin_lock_init(&self->lock); 1630 init_timer(&self->rx_defer_timer); 1631 1632 self->capability = id->driver_info; 1633 self->needspatch = ((self->capability & IUC_STIR421X) != 0); 1634 1635 /* Create all of the needed urbs */ 1636 if (self->capability & IUC_STIR421X) { 1637 self->max_rx_urb = IU_SIGMATEL_MAX_RX_URBS; 1638 self->header_length = USB_IRDA_STIR421X_HEADER; 1639 } else { 1640 self->max_rx_urb = IU_MAX_RX_URBS; 1641 self->header_length = USB_IRDA_HEADER; 1642 } 1643 1644 self->rx_urb = kcalloc(self->max_rx_urb, sizeof(struct urb *), 1645 GFP_KERNEL); 1646 if (!self->rx_urb) 1647 goto err_free_net; 1648 1649 for (i = 0; i < self->max_rx_urb; i++) { 1650 self->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL); 1651 if (!self->rx_urb[i]) { 1652 goto err_out_1; 1653 } 1654 } 1655 self->tx_urb = usb_alloc_urb(0, GFP_KERNEL); 1656 if (!self->tx_urb) { 1657 goto err_out_1; 1658 } 1659 self->speed_urb = usb_alloc_urb(0, GFP_KERNEL); 1660 if (!self->speed_urb) { 1661 goto err_out_2; 1662 } 1663 1664 /* Is this really necessary? (no, except maybe for broken devices) */ 1665 if (usb_reset_configuration (dev) < 0) { 1666 err("reset_configuration failed"); 1667 ret = -EIO; 1668 goto err_out_3; 1669 } 1670 1671 /* Is this really necessary? */ 1672 /* Note : some driver do hardcode the interface number, some others 1673 * specify an alternate, but very few driver do like this. 1674 * Jean II */ 1675 ret = usb_set_interface(dev, intf->altsetting->desc.bInterfaceNumber, 0); 1676 IRDA_DEBUG(1, "usb-irda: set interface %d result %d\n", intf->altsetting->desc.bInterfaceNumber, ret); 1677 switch (ret) { 1678 case 0: 1679 break; 1680 case -EPIPE: /* -EPIPE = -32 */ 1681 /* Martin Diehl says if we get a -EPIPE we should 1682 * be fine and we don't need to do a usb_clear_halt(). 1683 * - Jean II */ 1684 IRDA_DEBUG(0, "%s(), Received -EPIPE, ignoring...\n", __func__); 1685 break; 1686 default: 1687 IRDA_DEBUG(0, "%s(), Unknown error %d\n", __func__, ret); 1688 ret = -EIO; 1689 goto err_out_3; 1690 } 1691 1692 /* Find our endpoints */ 1693 interface = intf->cur_altsetting; 1694 if(!irda_usb_parse_endpoints(self, interface->endpoint, 1695 interface->desc.bNumEndpoints)) { 1696 IRDA_ERROR("%s(), Bogus endpoints...\n", __func__); 1697 ret = -EIO; 1698 goto err_out_3; 1699 } 1700 1701 self->usbdev = dev; 1702 1703 /* Find IrDA class descriptor */ 1704 irda_desc = irda_usb_find_class_desc(intf); 1705 ret = -ENODEV; 1706 if (!irda_desc) 1707 goto err_out_3; 1708 1709 if (self->needspatch) { 1710 ret = usb_control_msg (self->usbdev, usb_sndctrlpipe (self->usbdev, 0), 1711 0x02, 0x40, 0, 0, NULL, 0, 500); 1712 if (ret < 0) { 1713 IRDA_DEBUG (0, "usb_control_msg failed %d\n", ret); 1714 goto err_out_3; 1715 } else { 1716 mdelay(10); 1717 } 1718 } 1719 1720 self->irda_desc = irda_desc; 1721 self->present = 1; 1722 self->netopen = 0; 1723 self->usbintf = intf; 1724 1725 /* Allocate the buffer for speed changes */ 1726 /* Don't change this buffer size and allocation without doing 1727 * some heavy and complete testing. Don't ask why :-( 1728 * Jean II */ 1729 self->speed_buff = kzalloc(IRDA_USB_SPEED_MTU, GFP_KERNEL); 1730 if (!self->speed_buff) 1731 goto err_out_3; 1732 1733 self->tx_buff = kzalloc(IRDA_SKB_MAX_MTU + self->header_length, 1734 GFP_KERNEL); 1735 if (!self->tx_buff) 1736 goto err_out_4; 1737 1738 ret = irda_usb_open(self); 1739 if (ret) 1740 goto err_out_5; 1741 1742 IRDA_MESSAGE("IrDA: Registered device %s\n", net->name); 1743 usb_set_intfdata(intf, self); 1744 1745 if (self->needspatch) { 1746 /* Now we fetch and upload the firmware patch */ 1747 ret = stir421x_patch_device(self); 1748 self->needspatch = (ret < 0); 1749 if (self->needspatch) { 1750 IRDA_ERROR("STIR421X: Couldn't upload patch\n"); 1751 goto err_out_6; 1752 } 1753 1754 /* replace IrDA class descriptor with what patched device is now reporting */ 1755 irda_desc = irda_usb_find_class_desc (self->usbintf); 1756 if (!irda_desc) { 1757 ret = -ENODEV; 1758 goto err_out_6; 1759 } 1760 kfree(self->irda_desc); 1761 self->irda_desc = irda_desc; 1762 irda_usb_init_qos(self); 1763 } 1764 1765 return 0; 1766err_out_6: 1767 unregister_netdev(self->netdev); 1768err_out_5: 1769 kfree(self->tx_buff); 1770err_out_4: 1771 kfree(self->speed_buff); 1772err_out_3: 1773 /* Free all urbs that we may have created */ 1774 usb_free_urb(self->speed_urb); 1775err_out_2: 1776 usb_free_urb(self->tx_urb); 1777err_out_1: 1778 for (i = 0; i < self->max_rx_urb; i++) 1779 usb_free_urb(self->rx_urb[i]); 1780 kfree(self->rx_urb); 1781err_free_net: 1782 free_netdev(net); 1783err_out: 1784 return ret; 1785} 1786 1787/*------------------------------------------------------------------*/ 1788/* 1789 * The current irda-usb device is removed, the USB layer tell us 1790 * to shut it down... 1791 * One of the constraints is that when we exit this function, 1792 * we cannot use the usb_device no more. Gone. Destroyed. kfree(). 1793 * Most other subsystem allow you to destroy the instance at a time 1794 * when it's convenient to you, to postpone it to a later date, but 1795 * not the USB subsystem. 1796 * So, we must make bloody sure that everything gets deactivated. 1797 * Jean II 1798 */ 1799static void irda_usb_disconnect(struct usb_interface *intf) 1800{ 1801 unsigned long flags; 1802 struct irda_usb_cb *self = usb_get_intfdata(intf); 1803 int i; 1804 1805 IRDA_DEBUG(1, "%s()\n", __func__); 1806 1807 usb_set_intfdata(intf, NULL); 1808 if (!self) 1809 return; 1810 1811 /* Make sure that the Tx path is not executing. - Jean II */ 1812 spin_lock_irqsave(&self->lock, flags); 1813 1814 /* Oups ! We are not there any more. 1815 * This will stop/desactivate the Tx path. - Jean II */ 1816 self->present = 0; 1817 1818 /* Kill defered Rx URB */ 1819 del_timer(&self->rx_defer_timer); 1820 1821 /* We need to have irq enabled to unlink the URBs. That's OK, 1822 * at this point the Tx path is gone - Jean II */ 1823 spin_unlock_irqrestore(&self->lock, flags); 1824 1825 /* Hum... Check if networking is still active (avoid races) */ 1826 if((self->netopen) || (self->irlap)) { 1827 /* Accept no more transmissions */ 1828 /*netif_device_detach(self->netdev);*/ 1829 netif_stop_queue(self->netdev); 1830 /* Stop all the receive URBs. Must be synchronous. */ 1831 for (i = 0; i < self->max_rx_urb; i++) 1832 usb_kill_urb(self->rx_urb[i]); 1833 /* Cancel Tx and speed URB. 1834 * Make sure it's synchronous to avoid races. */ 1835 usb_kill_urb(self->tx_urb); 1836 usb_kill_urb(self->speed_urb); 1837 } 1838 1839 /* Cleanup the device stuff */ 1840 irda_usb_close(self); 1841 /* No longer attached to USB bus */ 1842 self->usbdev = NULL; 1843 self->usbintf = NULL; 1844 1845 /* Clean up our urbs */ 1846 for (i = 0; i < self->max_rx_urb; i++) 1847 usb_free_urb(self->rx_urb[i]); 1848 kfree(self->rx_urb); 1849 /* Clean up Tx and speed URB */ 1850 usb_free_urb(self->tx_urb); 1851 usb_free_urb(self->speed_urb); 1852 1853 /* Free self and network device */ 1854 free_netdev(self->netdev); 1855 IRDA_DEBUG(0, "%s(), USB IrDA Disconnected\n", __func__); 1856} 1857 1858#ifdef CONFIG_PM 1859/* USB suspend, so power off the transmitter/receiver */ 1860static int irda_usb_suspend(struct usb_interface *intf, pm_message_t message) 1861{ 1862 struct irda_usb_cb *self = usb_get_intfdata(intf); 1863 int i; 1864 1865 netif_device_detach(self->netdev); 1866 1867 if (self->tx_urb != NULL) 1868 usb_kill_urb(self->tx_urb); 1869 if (self->speed_urb != NULL) 1870 usb_kill_urb(self->speed_urb); 1871 for (i = 0; i < self->max_rx_urb; i++) { 1872 if (self->rx_urb[i] != NULL) 1873 usb_kill_urb(self->rx_urb[i]); 1874 } 1875 return 0; 1876} 1877 1878/* Coming out of suspend, so reset hardware */ 1879static int irda_usb_resume(struct usb_interface *intf) 1880{ 1881 struct irda_usb_cb *self = usb_get_intfdata(intf); 1882 int i; 1883 1884 for (i = 0; i < self->max_rx_urb; i++) { 1885 if (self->rx_urb[i] != NULL) 1886 usb_submit_urb(self->rx_urb[i], GFP_KERNEL); 1887 } 1888 1889 netif_device_attach(self->netdev); 1890 return 0; 1891} 1892#endif 1893 1894/*------------------------------------------------------------------*/ 1895/* 1896 * USB device callbacks 1897 */ 1898static struct usb_driver irda_driver = { 1899 .name = "irda-usb", 1900 .probe = irda_usb_probe, 1901 .disconnect = irda_usb_disconnect, 1902 .id_table = dongles, 1903#ifdef CONFIG_PM 1904 .suspend = irda_usb_suspend, 1905 .resume = irda_usb_resume, 1906#endif 1907}; 1908 1909/************************* MODULE CALLBACKS *************************/ 1910/* 1911 * Deal with module insertion/removal 1912 * Mostly tell USB about our existence 1913 */ 1914 1915/*------------------------------------------------------------------*/ 1916/* 1917 * Module insertion 1918 */ 1919static int __init usb_irda_init(void) 1920{ 1921 int ret; 1922 1923 ret = usb_register(&irda_driver); 1924 if (ret < 0) 1925 return ret; 1926 1927 IRDA_MESSAGE("USB IrDA support registered\n"); 1928 return 0; 1929} 1930module_init(usb_irda_init); 1931 1932/*------------------------------------------------------------------*/ 1933/* 1934 * Module removal 1935 */ 1936static void __exit usb_irda_cleanup(void) 1937{ 1938 /* Deregister the driver and remove all pending instances */ 1939 usb_deregister(&irda_driver); 1940} 1941module_exit(usb_irda_cleanup); 1942 1943/*------------------------------------------------------------------*/ 1944/* 1945 * Module parameters 1946 */ 1947module_param(qos_mtt_bits, int, 0); 1948MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time"); 1949MODULE_AUTHOR("Roman Weissgaerber <weissg@vienna.at>, Dag Brattli <dag@brattli.net>, Jean Tourrilhes <jt@hpl.hp.com> and Nick Fedchik <nick@fedchik.org.ua>"); 1950MODULE_DESCRIPTION("IrDA-USB Dongle Driver"); 1951MODULE_LICENSE("GPL"); 1952