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