PageRenderTime 101ms CodeModel.GetById 29ms app.highlight 59ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/irda/irda-usb.c

http://github.com/mirrors/linux
C | 1913 lines | 1043 code | 237 blank | 633 comment | 213 complexity | e604f5500a6e0295bf13fbb75a2bb5ed MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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			pr_debug("%s(), not changing speed yet\n", __func__);
 180			*header = 0;
 181			return;
 182		}
 183
 184		pr_debug("%s(), changing speed to %d\n",
 185			 __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		pr_debug("%s(), changing xbofs to %d\n",
 232			 __func__, self->new_xbofs);
 233		self->xbofs = self->new_xbofs;
 234		/* We will do ` self->new_xbofs = -1; ' in the completion
 235		 * handler just in case the current URB fail - Jean II */
 236
 237		switch (self->xbofs) {
 238		case 48:
 239			*header |= 0x10;
 240			break;
 241		case 28:
 242		case 24:	/* USB spec 1.0 says 24 */
 243			*header |= 0x20;
 244			break;
 245		default:
 246		case 12:
 247			*header |= 0x30;
 248			break;
 249		case 5: /* Bug in IrLAP spec? (should be 6) */
 250		case 6:
 251			*header |= 0x40;
 252			break;
 253		case 3:
 254			*header |= 0x50;
 255			break;
 256		case 2:
 257			*header |= 0x60;
 258			break;
 259		case 1:
 260			*header |= 0x70;
 261			break;
 262		case 0:
 263			*header |= 0x80;
 264			break;
 265		}
 266	}
 267}
 268
 269/*
 270*   calculate turnaround time for SigmaTel header
 271*/
 272static __u8 get_turnaround_time(struct sk_buff *skb)
 273{
 274	int turnaround_time = irda_get_mtt(skb);
 275
 276	if ( turnaround_time == 0 )
 277		return 0;
 278	else if ( turnaround_time <= 10 )
 279		return 1;
 280	else if ( turnaround_time <= 50 )
 281		return 2;
 282	else if ( turnaround_time <= 100 )
 283		return 3;
 284	else if ( turnaround_time <= 500 )
 285		return 4;
 286	else if ( turnaround_time <= 1000 )
 287		return 5;
 288	else if ( turnaround_time <= 5000 )
 289		return 6;
 290	else
 291		return 7;
 292}
 293
 294
 295/*------------------------------------------------------------------*/
 296/*
 297 * Send a command to change the speed of the dongle
 298 * Need to be called with spinlock on.
 299 */
 300static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self)
 301{
 302	__u8 *frame;
 303	struct urb *urb;
 304	int ret;
 305
 306	pr_debug("%s(), speed=%d, xbofs=%d\n", __func__,
 307		 self->new_speed, self->new_xbofs);
 308
 309	/* Grab the speed URB */
 310	urb = self->speed_urb;
 311	if (urb->status != 0) {
 312		net_warn_ratelimited("%s(), URB still in use!\n", __func__);
 313		return;
 314	}
 315
 316	/* Allocate the fake frame */
 317	frame = self->speed_buff;
 318
 319	/* Set the new speed and xbofs in this fake frame */
 320	irda_usb_build_header(self, frame, 1);
 321
 322	if (self->capability & IUC_STIR421X) {
 323		if (frame[0] == 0) return ; // do nothing if no change
 324		frame[1] = 0; // other parameters don't change here
 325		frame[2] = 0;
 326	}
 327
 328	/* Submit the 0 length IrDA frame to trigger new speed settings */
 329        usb_fill_bulk_urb(urb, self->usbdev,
 330		      usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
 331                      frame, IRDA_USB_SPEED_MTU,
 332                      speed_bulk_callback, self);
 333	urb->transfer_buffer_length = self->header_length;
 334	urb->transfer_flags = 0;
 335
 336	/* Irq disabled -> GFP_ATOMIC */
 337	if ((ret = usb_submit_urb(urb, GFP_ATOMIC))) {
 338		net_warn_ratelimited("%s(), failed Speed URB\n", __func__);
 339	}
 340}
 341
 342/*------------------------------------------------------------------*/
 343/*
 344 * Speed URB callback
 345 * Now, we can only get called for the speed URB.
 346 */
 347static void speed_bulk_callback(struct urb *urb)
 348{
 349	struct irda_usb_cb *self = urb->context;
 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		pr_debug("%s(), URB complete status %d, transfer_flags 0x%04X\n",
 360			 __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 committed 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	pr_debug("%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		pr_debug("%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			netif_trans_update(netdev);
 433			/* Will netif_wake_queue() in callback */
 434			goto drop;
 435		}
 436	}
 437
 438	if (urb->status != 0) {
 439		net_warn_ratelimited("%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	/* FIXME: Make macro out of this one */
 466	((struct irda_skb_cb *)skb->cb)->context = self;
 467
 468	usb_fill_bulk_urb(urb, self->usbdev,
 469		      usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
 470                      self->tx_buff, skb->len + self->header_length,
 471                      write_bulk_callback, skb);
 472
 473	/* This flag (URB_ZERO_PACKET) indicates that what we send is not
 474	 * a continuous stream of data but separate packets.
 475	 * In this case, the USB layer will insert an empty USB frame (TD)
 476	 * after each of our packets that is exact multiple of the frame size.
 477	 * This is how the dongle will detect the end of packet - Jean II */
 478	urb->transfer_flags = URB_ZERO_PACKET;
 479
 480	/* Generate min turn time. FIXME: can we do better than this? */
 481	/* Trying to a turnaround time at this level is trying to measure
 482	 * processor clock cycle with a wrist-watch, approximate at best...
 483	 *
 484	 * What we know is the last time we received a frame over USB.
 485	 * Due to latency over USB that depend on the USB load, we don't
 486	 * know when this frame was received over IrDA (a few ms before ?)
 487	 * Then, same story for our outgoing frame...
 488	 *
 489	 * In theory, the USB dongle is supposed to handle the turnaround
 490	 * by itself (spec 1.0, chater 4, page 6). Who knows ??? That's
 491	 * why this code is enabled only for dongles that doesn't meet
 492	 * the spec.
 493	 * Jean II */
 494	if (self->capability & IUC_NO_TURN) {
 495		mtt = irda_get_mtt(skb);
 496		if (mtt) {
 497			int diff;
 498			diff = ktime_us_delta(ktime_get(), self->stamp);
 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
 505		        /* Check if the mtt is larger than the time we have
 506			 * already used by all the protocol processing
 507			 */
 508			if (mtt > diff) {
 509				mtt -= diff;
 510				if (mtt > 1000)
 511					mdelay(mtt/1000);
 512				else
 513					udelay(mtt);
 514			}
 515		}
 516	}
 517	
 518	/* Ask USB to send the packet - Irq disabled -> GFP_ATOMIC */
 519	if ((res = usb_submit_urb(urb, GFP_ATOMIC))) {
 520		net_warn_ratelimited("%s(), failed Tx URB\n", __func__);
 521		netdev->stats.tx_errors++;
 522		/* Let USB recover : We will catch that in the watchdog */
 523		/*netif_start_queue(netdev);*/
 524	} else {
 525		/* Increment packet stats */
 526		netdev->stats.tx_packets++;
 527                netdev->stats.tx_bytes += skb->len;
 528		
 529		netif_trans_update(netdev);
 530	}
 531	spin_unlock_irqrestore(&self->lock, flags);
 532	
 533	return NETDEV_TX_OK;
 534
 535drop:
 536	/* Drop silently the skb and exit */
 537	dev_kfree_skb(skb);
 538	spin_unlock_irqrestore(&self->lock, flags);
 539	return NETDEV_TX_OK;
 540}
 541
 542/*------------------------------------------------------------------*/
 543/*
 544 * Note : this function will be called only for tx_urb...
 545 */
 546static void write_bulk_callback(struct urb *urb)
 547{
 548	unsigned long flags;
 549	struct sk_buff *skb = urb->context;
 550	struct irda_usb_cb *self = ((struct irda_skb_cb *) skb->cb)->context;
 551	
 552	/* We should always have a context */
 553	IRDA_ASSERT(self != NULL, return;);
 554	/* We should always be called for the speed URB */
 555	IRDA_ASSERT(urb == self->tx_urb, return;);
 556
 557	/* Free up the skb */
 558	dev_kfree_skb_any(skb);
 559	urb->context = NULL;
 560
 561	/* Check for timeout and other USB nasties */
 562	if (urb->status != 0) {
 563		/* I get a lot of -ECONNABORTED = -103 here - Jean II */
 564		pr_debug("%s(), URB complete status %d, transfer_flags 0x%04X\n",
 565			 __func__, urb->status, urb->transfer_flags);
 566
 567		/* Don't do anything here, that might confuse the USB layer,
 568		 * and we could go in recursion and blow the kernel stack...
 569		 * Instead, we will wait for irda_usb_net_timeout(), the
 570		 * network layer watchdog, to fix the situation.
 571		 * Jean II */
 572		/* A reset of the dongle might be welcomed here - Jean II */
 573		return;
 574	}
 575
 576	/* urb is now available */
 577	//urb->status = 0; -> tested above
 578
 579	/* Make sure we read self->present properly */
 580	spin_lock_irqsave(&self->lock, flags);
 581
 582	/* If the network is closed, stop everything */
 583	if ((!self->netopen) || (!self->present)) {
 584		pr_debug("%s(), Network is gone...\n", __func__);
 585		spin_unlock_irqrestore(&self->lock, flags);
 586		return;
 587	}
 588
 589	/* If changes to speed or xbofs is pending... */
 590	if ((self->new_speed != -1) || (self->new_xbofs != -1)) {
 591		if ((self->new_speed != self->speed) ||
 592		    (self->new_xbofs != self->xbofs)) {
 593			/* We haven't changed speed yet (because of
 594			 * IUC_SPEED_BUG), so do it now - Jean II */
 595			pr_debug("%s(), Changing speed now...\n", __func__);
 596			irda_usb_change_speed_xbofs(self);
 597		} else {
 598			/* New speed and xbof is now committed in hardware */
 599			self->new_speed = -1;
 600			self->new_xbofs = -1;
 601			/* Done, waiting for next packet */
 602			netif_wake_queue(self->netdev);
 603		}
 604	} else {
 605		/* Otherwise, allow the stack to send more packets */
 606		netif_wake_queue(self->netdev);
 607	}
 608	spin_unlock_irqrestore(&self->lock, flags);
 609}
 610
 611/*------------------------------------------------------------------*/
 612/*
 613 * Watchdog timer from the network layer.
 614 * After a predetermined timeout, if we don't give confirmation that
 615 * the packet has been sent (i.e. no call to netif_wake_queue()),
 616 * the network layer will call this function.
 617 * Note that URB that we submit have also a timeout. When the URB timeout
 618 * expire, the normal URB callback is called (write_bulk_callback()).
 619 */
 620static void irda_usb_net_timeout(struct net_device *netdev)
 621{
 622	unsigned long flags;
 623	struct irda_usb_cb *self = netdev_priv(netdev);
 624	struct urb *urb;
 625	int	done = 0;	/* If we have made any progress */
 626
 627	pr_debug("%s(), Network layer thinks we timed out!\n", __func__);
 628	IRDA_ASSERT(self != NULL, return;);
 629
 630	/* Protect us from USB callbacks, net Tx and else. */
 631	spin_lock_irqsave(&self->lock, flags);
 632
 633	/* self->present *MUST* be read under spinlock */
 634	if (!self->present) {
 635		net_warn_ratelimited("%s(), device not present!\n", __func__);
 636		netif_stop_queue(netdev);
 637		spin_unlock_irqrestore(&self->lock, flags);
 638		return;
 639	}
 640
 641	/* Check speed URB */
 642	urb = self->speed_urb;
 643	if (urb->status != 0) {
 644		pr_debug("%s: Speed change timed out, urb->status=%d, urb->transfer_flags=0x%04X\n",
 645			 netdev->name, urb->status, urb->transfer_flags);
 646
 647		switch (urb->status) {
 648		case -EINPROGRESS:
 649			usb_unlink_urb(urb);
 650			/* Note : above will  *NOT* call netif_wake_queue()
 651			 * in completion handler, we will come back here.
 652			 * Jean II */
 653			done = 1;
 654			break;
 655		case -ECONNRESET:
 656		case -ENOENT:			/* urb unlinked by us */
 657		default:			/* ??? - Play safe */
 658			urb->status = 0;
 659			netif_wake_queue(self->netdev);
 660			done = 1;
 661			break;
 662		}
 663	}
 664
 665	/* Check Tx URB */
 666	urb = self->tx_urb;
 667	if (urb->status != 0) {
 668		struct sk_buff *skb = urb->context;
 669
 670		pr_debug("%s: Tx timed out, urb->status=%d, urb->transfer_flags=0x%04X\n",
 671			 netdev->name, urb->status, urb->transfer_flags);
 672
 673		/* Increase error count */
 674		netdev->stats.tx_errors++;
 675
 676#ifdef IU_BUG_KICK_TIMEOUT
 677		/* Can't be a bad idea to reset the speed ;-) - Jean II */
 678		if(self->new_speed == -1)
 679			self->new_speed = self->speed;
 680		if(self->new_xbofs == -1)
 681			self->new_xbofs = self->xbofs;
 682		irda_usb_change_speed_xbofs(self);
 683#endif /* IU_BUG_KICK_TIMEOUT */
 684
 685		switch (urb->status) {
 686		case -EINPROGRESS:
 687			usb_unlink_urb(urb);
 688			/* Note : above will  *NOT* call netif_wake_queue()
 689			 * in completion handler, because urb->status will
 690			 * be -ENOENT. We will fix that at the next watchdog,
 691			 * leaving more time to USB to recover...
 692			 * Jean II */
 693			done = 1;
 694			break;
 695		case -ECONNRESET:
 696		case -ENOENT:			/* urb unlinked by us */
 697		default:			/* ??? - Play safe */
 698			if(skb != NULL) {
 699				dev_kfree_skb_any(skb);
 700				urb->context = NULL;
 701			}
 702			urb->status = 0;
 703			netif_wake_queue(self->netdev);
 704			done = 1;
 705			break;
 706		}
 707	}
 708	spin_unlock_irqrestore(&self->lock, flags);
 709
 710	/* Maybe we need a reset */
 711	/* Note : Some drivers seem to use a usb_set_interface() when they
 712	 * need to reset the hardware. Hum...
 713	 */
 714
 715	/* if(done == 0) */
 716}
 717
 718/************************* RECEIVE ROUTINES *************************/
 719/*
 720 * Receive packets from the USB layer stack and pass them to the IrDA stack.
 721 * Try to work around USB failures...
 722 */
 723
 724/*
 725 * Note :
 726 * Some of you may have noticed that most dongle have an interrupt in pipe
 727 * that we don't use. Here is the little secret...
 728 * When we hang a Rx URB on the bulk in pipe, it generates some USB traffic
 729 * in every USB frame. This is unnecessary overhead.
 730 * The interrupt in pipe will generate an event every time a packet is
 731 * received. Reading an interrupt pipe adds minimal overhead, but has some
 732 * latency (~1ms).
 733 * If we are connected (speed != 9600), we want to minimise latency, so
 734 * we just always hang the Rx URB and ignore the interrupt.
 735 * If we are not connected (speed == 9600), there is usually no Rx traffic,
 736 * and we want to minimise the USB overhead. In this case we should wait
 737 * on the interrupt pipe and hang the Rx URB only when an interrupt is
 738 * received.
 739 * Jean II
 740 *
 741 * Note : don't read the above as what we are currently doing, but as
 742 * something we could do with KC dongle. Also don't forget that the
 743 * interrupt pipe is not part of the original standard, so this would
 744 * need to be optional...
 745 * Jean II
 746 */
 747
 748/*------------------------------------------------------------------*/
 749/*
 750 * Submit a Rx URB to the USB layer to handle reception of a frame
 751 * Mostly called by the completion callback of the previous URB.
 752 *
 753 * Jean II
 754 */
 755static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struct urb *urb)
 756{
 757	struct irda_skb_cb *cb;
 758	int ret;
 759
 760	/* This should never happen */
 761	IRDA_ASSERT(skb != NULL, return;);
 762	IRDA_ASSERT(urb != NULL, return;);
 763
 764	/* Save ourselves in the skb */
 765	cb = (struct irda_skb_cb *) skb->cb;
 766	cb->context = self;
 767
 768	/* Reinitialize URB */
 769	usb_fill_bulk_urb(urb, self->usbdev, 
 770		      usb_rcvbulkpipe(self->usbdev, self->bulk_in_ep), 
 771		      skb->data, IRDA_SKB_MAX_MTU,
 772                      irda_usb_receive, skb);
 773	urb->status = 0;
 774
 775	/* Can be called from irda_usb_receive (irq handler) -> GFP_ATOMIC */
 776	ret = usb_submit_urb(urb, GFP_ATOMIC);
 777	if (ret) {
 778		/* If this ever happen, we are in deep s***.
 779		 * Basically, the Rx path will stop... */
 780		net_warn_ratelimited("%s(), Failed to submit Rx URB %d\n",
 781				     __func__, ret);
 782	}
 783}
 784
 785/*------------------------------------------------------------------*/
 786/*
 787 * Function irda_usb_receive(urb)
 788 *
 789 *     Called by the USB subsystem when a frame has been received
 790 *
 791 */
 792static void irda_usb_receive(struct urb *urb)
 793{
 794	struct sk_buff *skb = (struct sk_buff *) urb->context;
 795	struct irda_usb_cb *self; 
 796	struct irda_skb_cb *cb;
 797	struct sk_buff *newskb;
 798	struct sk_buff *dataskb;
 799	struct urb *next_urb;
 800	unsigned int len, docopy;
 801
 802	pr_debug("%s(), len=%d\n", __func__, urb->actual_length);
 803	
 804	/* Find ourselves */
 805	cb = (struct irda_skb_cb *) skb->cb;
 806	IRDA_ASSERT(cb != NULL, return;);
 807	self = (struct irda_usb_cb *) cb->context;
 808	IRDA_ASSERT(self != NULL, return;);
 809
 810	/* If the network is closed or the device gone, stop everything */
 811	if ((!self->netopen) || (!self->present)) {
 812		pr_debug("%s(), Network is gone!\n", __func__);
 813		/* Don't re-submit the URB : will stall the Rx path */
 814		return;
 815	}
 816	
 817	/* Check the status */
 818	if (urb->status != 0) {
 819		switch (urb->status) {
 820		case -EILSEQ:
 821			self->netdev->stats.rx_crc_errors++;
 822			/* Also precursor to a hot-unplug on UHCI. */
 823			/* Fallthrough... */
 824		case -ECONNRESET:
 825			/* Random error, if I remember correctly */
 826			/* uhci_cleanup_unlink() is going to kill the Rx
 827			 * URB just after we return. No problem, at this
 828			 * point the URB will be idle ;-) - Jean II */
 829		case -ESHUTDOWN:
 830			/* That's usually a hot-unplug. Submit will fail... */
 831		case -ETIME:
 832			/* Usually precursor to a hot-unplug on OHCI. */
 833		default:
 834			self->netdev->stats.rx_errors++;
 835			pr_debug("%s(), RX status %d, transfer_flags 0x%04X\n",
 836				 __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,
 852			  jiffies + msecs_to_jiffies(10));
 853
 854		return;
 855	}
 856	
 857	/* Check for empty frames */
 858	if (urb->actual_length <= self->header_length) {
 859		net_warn_ratelimited("%s(), empty frame!\n", __func__);
 860		goto done;
 861	}
 862
 863	/*  
 864	 * Remember the time we received this frame, so we can
 865	 * reduce the min turn time a bit since we will know
 866	 * how much time we have used for protocol processing
 867	 */
 868	self->stamp = ktime_get();
 869
 870	/* Check if we need to copy the data to a new skb or not.
 871	 * For most frames, we use ZeroCopy and pass the already
 872	 * allocated skb up the stack.
 873	 * If the frame is small, it is more efficient to copy it
 874	 * to save memory (copy will be fast anyway - that's
 875	 * called Rx-copy-break). Jean II */
 876	docopy = (urb->actual_length < IRDA_RX_COPY_THRESHOLD);
 877
 878	/* Allocate a new skb */
 879	if (self->capability & IUC_STIR421X)
 880		newskb = dev_alloc_skb(docopy ? urb->actual_length :
 881				       IRDA_SKB_MAX_MTU +
 882				       USB_IRDA_STIR421X_HEADER);
 883	else
 884		newskb = dev_alloc_skb(docopy ? urb->actual_length :
 885				       IRDA_SKB_MAX_MTU);
 886
 887	if (!newskb)  {
 888		self->netdev->stats.rx_dropped++;
 889		/* We could deliver the current skb, but this would stall
 890		 * the Rx path. Better drop the packet... Jean II */
 891		goto done;  
 892	}
 893
 894	/* Make sure IP header get aligned (IrDA header is 5 bytes) */
 895	/* But IrDA-USB header is 1 byte. Jean II */
 896	//skb_reserve(newskb, USB_IRDA_HEADER - 1);
 897
 898	if(docopy) {
 899		/* Copy packet, so we can recycle the original */
 900		skb_copy_from_linear_data(skb, newskb->data, urb->actual_length);
 901		/* Deliver this new skb */
 902		dataskb = newskb;
 903		/* And hook the old skb to the URB
 904		 * Note : we don't need to "clean up" the old skb,
 905		 * as we never touched it. Jean II */
 906	} else {
 907		/* We are using ZeroCopy. Deliver old skb */
 908		dataskb = skb;
 909		/* And hook the new skb to the URB */
 910		skb = newskb;
 911	}
 912
 913	/* Set proper length on skb & remove USB-IrDA header */
 914	skb_put(dataskb, urb->actual_length);
 915	skb_pull(dataskb, self->header_length);
 916
 917	/* Ask the networking layer to queue the packet for the IrDA stack */
 918	dataskb->dev = self->netdev;
 919	skb_reset_mac_header(dataskb);
 920	dataskb->protocol = htons(ETH_P_IRDA);
 921	len = dataskb->len;
 922	netif_rx(dataskb);
 923
 924	/* Keep stats up to date */
 925	self->netdev->stats.rx_bytes += len;
 926	self->netdev->stats.rx_packets++;
 927
 928done:
 929	/* Note : at this point, the URB we've just received (urb)
 930	 * is still referenced by the USB layer. For example, if we
 931	 * have received a -ECONNRESET, uhci_cleanup_unlink() will
 932	 * continue to process it (in fact, cleaning it up).
 933	 * If we were to submit this URB, disaster would ensue.
 934	 * Therefore, we submit our idle URB, and put this URB in our
 935	 * idle slot....
 936	 * Jean II */
 937	/* Note : with this scheme, we could submit the idle URB before
 938	 * processing the Rx URB. I don't think it would buy us anything as
 939	 * we are running in the USB thread context. Jean II */
 940	next_urb = self->idle_rx_urb;
 941
 942	/* Recycle Rx URB : Now, the idle URB is the present one */
 943	urb->context = NULL;
 944	self->idle_rx_urb = urb;
 945
 946	/* Submit the idle URB to replace the URB we've just received.
 947	 * Do it last to avoid race conditions... Jean II */
 948	irda_usb_submit(self, skb, next_urb);
 949}
 950
 951/*------------------------------------------------------------------*/
 952/*
 953 * In case of errors, we want the USB layer to have time to recover.
 954 * Now, it is time to resubmit ouur Rx URB...
 955 */
 956static void irda_usb_rx_defer_expired(unsigned long data)
 957{
 958	struct urb *urb = (struct urb *) data;
 959	struct sk_buff *skb = (struct sk_buff *) urb->context;
 960	struct irda_usb_cb *self; 
 961	struct irda_skb_cb *cb;
 962	struct urb *next_urb;
 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		pr_debug("%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	net_info_ratelimited("%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			pr_debug("%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; i < fw->size && fw->data[i] !=
1122			     STIR421X_PATCH_END_OF_HDR_TAG; i++) ;
1123                /* here we check for the out of buffer case */
1124                if (i < STIR421X_PATCH_CODE_OFFSET && i < fw->size &&
1125				STIR421X_PATCH_END_OF_HDR_TAG == fw->data[i]) {
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_ASSERT(netdev != NULL, return -1;);
1168	self = netdev_priv(netdev);
1169	IRDA_ASSERT(self != NULL, return -1;);
1170
1171	spin_lock_irqsave(&self->lock, flags);
1172	/* Can only open the device if it's there */
1173	if(!self->present) {
1174		spin_unlock_irqrestore(&self->lock, flags);
1175		net_warn_ratelimited("%s(), device not present!\n", __func__);
1176		return -1;
1177	}
1178
1179	if(self->needspatch) {
1180		spin_unlock_irqrestore(&self->lock, flags);
1181		net_warn_ratelimited("%s(), device needs patch\n", __func__);
1182		return -EIO ;
1183	}
1184
1185	/* Initialise default speed and xbofs value
1186	 * (IrLAP will change that soon) */
1187	self->speed = -1;
1188	self->xbofs = -1;
1189	self->new_speed = -1;
1190	self->new_xbofs = -1;
1191
1192	/* To do *before* submitting Rx urbs and starting net Tx queue
1193	 * Jean II */
1194	self->netopen = 1;
1195	spin_unlock_irqrestore(&self->lock, flags);
1196
1197	/* 
1198	 * Now that everything should be initialized properly,
1199	 * Open new IrLAP layer instance to take care of us...
1200	 * Note : will send immediately a speed change...
1201	 */
1202	sprintf(hwname, "usb#%d", self->usbdev->devnum);
1203	self->irlap = irlap_open(netdev, &self->qos, hwname);
1204	IRDA_ASSERT(self->irlap != NULL, return -1;);
1205
1206	/* Allow IrLAP to send data to us */
1207	netif_start_queue(netdev);
1208
1209	/* We submit all the Rx URB except for one that we keep idle.
1210	 * Need to be initialised before submitting other USBs, because
1211	 * in some cases as soon as we submit the URBs the USB layer
1212	 * will trigger a dummy receive - Jean II */
1213	self->idle_rx_urb = self->rx_urb[IU_MAX_ACTIVE_RX_URBS];
1214	self->idle_rx_urb->context = NULL;
1215
1216	/* Now that we can pass data to IrLAP, allow the USB layer
1217	 * to send us some data... */
1218	for (i = 0; i < IU_MAX_ACTIVE_RX_URBS; i++) {
1219		struct sk_buff *skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
1220		if (!skb) {
1221			/* If this ever happen, we are in deep s***.
1222			 * Basically, we can't start the Rx path... */
1223			return -1;
1224		}
1225		//skb_reserve(newskb, USB_IRDA_HEADER - 1);
1226		irda_usb_submit(self, skb, self->rx_urb[i]);
1227	}
1228
1229	/* Ready to play !!! */
1230	return 0;
1231}
1232
1233/*------------------------------------------------------------------*/
1234/*
1235 * Function irda_usb_net_close (self)
1236 *
1237 *    Network device is taken down. Usually this is done by 
1238 *    "ifconfig irda0 down" 
1239 */
1240static int irda_usb_net_close(struct net_device *netdev)
1241{
1242	struct irda_usb_cb *self;
1243	int	i;
1244
1245	IRDA_ASSERT(netdev != NULL, return -1;);
1246	self = netdev_priv(netdev);
1247	IRDA_ASSERT(self != NULL, return -1;);
1248
1249	/* Clear this flag *before* unlinking the urbs and *before*
1250	 * stopping the network Tx queue - Jean II */
1251	self->netopen = 0;
1252
1253	/* Stop network Tx queue */
1254	netif_stop_queue(netdev);
1255
1256	/* Kill defered Rx URB */
1257	del_timer(&self->rx_defer_timer);
1258
1259	/* Deallocate all the Rx path buffers (URBs and skb) */
1260	for (i = 0; i < self->max_rx_urb; i++) {
1261		struct urb *urb = self->rx_urb[i];
1262		struct sk_buff *skb = (struct sk_buff *) urb->context;
1263		/* Cancel the receive command */
1264		usb_kill_urb(urb);
1265		/* The skb is ours, free it */
1266		if(skb) {
1267			dev_kfree_skb(skb);
1268			urb->context = NULL;
1269		}
1270	}
1271	/* Cancel Tx and speed URB - need to be synchronous to avoid races */
1272	usb_kill_urb(self->tx_urb);
1273	usb_kill_urb(self->speed_urb);
1274
1275	/* Stop and remove instance of IrLAP */
1276	if (self->irlap)
1277		irlap_close(self->irlap);
1278	self->irlap = NULL;
1279
1280	return 0;
1281}
1282
1283/*------------------------------------------------------------------*/
1284/*
1285 * IOCTLs : Extra out-of-band network commands...
1286 */
1287static int irda_usb_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1288{
1289	unsigned long flags;
1290	struct if_irda_req *irq = (struct if_irda_req *) rq;
1291	struct irda_usb_cb *self;
1292	int ret = 0;
1293
1294	IRDA_ASSERT(dev != NULL, return -1;);
1295	self = netdev_priv(dev);
1296	IRDA_ASSERT(self != NULL, return -1;);
1297
1298	pr_debug("%s(), %s, (cmd=0x%X)\n", __func__, dev->name, cmd);
1299
1300	switch (cmd) {
1301	case SIOCSBANDWIDTH: /* Set bandwidth */
1302		if (!capable(CAP_NET_ADMIN))
1303			return -EPERM;
1304		/* Protect us from USB callbacks, net watchdog and else. */
1305		spin_lock_irqsave(&self->lock, flags);
1306		/* Check if the device is still there */
1307		if(self->present) {
1308			/* Set the desired speed */
1309			self->new_speed = irq->ifr_baudrate;
1310			irda_usb_change_speed_xbofs(self);
1311		}
1312		spin_unlock_irqrestore(&self->lock, flags);
1313		break;
1314	case SIOCSMEDIABUSY: /* Set media busy */
1315		if (!capable(CAP_NET_ADMIN))
1316			return -EPERM;
1317		/* Check if the IrDA stack is still there */
1318		if(self->netopen)
1319			irda_device_set_media_busy(self->netdev, TRUE);
1320		break;
1321	case SIOCGRECEIVING: /* Check if we are receiving right now */
1322		irq->ifr_receiving = irda_usb_is_receiving(self);
1323		break;
1324	default:
1325		ret = -EOPNOTSUPP;
1326	}
1327	
1328	return ret;
1329}
1330
1331/*------------------------------------------------------------------*/
1332
1333/********************* IRDA CONFIG SUBROUTINES *********************/
1334/*
1335 * Various subroutines dealing with IrDA and network stuff we use to
1336 * configure and initialise each irda-usb instance.
1337 * These functions are used below in the main calls of the driver...
1338 */
1339
1340/*------------------------------------------------------------------*/
1341/*
1342 * Set proper values in the IrDA QOS structure
1343 */
1344static inline void irda_usb_init_qos(struct irda_usb_cb *self)
1345{
1346	struct irda_class_desc *desc;
1347
1348	
1349	desc = self->irda_desc;
1350	
1351	/* Initialize QoS for this device */
1352	irda_init_max_qos_capabilies(&self->qos);
1353
1354	/* See spec section 7.2 for meaning.
1355	 * Values are little endian (as most USB stuff), the IrDA stack
1356	 * use it in native order (see parameters.c). - Jean II */
1357	self->qos.baud_rate.bits       = le16_to_cpu(desc->wBaudRate);
1358	self->qos.min_turn_time.bits   = desc->bmMinTurnaroundTime;
1359	self->qos.additional_bofs.bits = desc->bmAdditionalBOFs;
1360	self->qos.window_size.bits     = desc->bmWindowSize;
1361	self->qos.data_size.bits       = desc->bmDataSize;
1362
1363	pr_debug("%s(), dongle says speed=0x%X, size=0x%X, window=0x%X, bofs=0x%X, turn=0x%X\n",
1364		 __func__, self->qos.baud_rate.bits, self->qos.data_size.bits,
1365		 self->qos.window_size.bits, self->qos.additional_bofs.bits,
1366		 self->qos.min_turn_time.bits);
1367
1368	/* Don't always trust what the dongle tell us */
1369	if(self->capability & IUC_SIR_ONLY)
1370		self->qos.baud_rate.bits	&= 0x00ff;
1371	if(self->capability & IUC_SMALL_PKT)
1372		self->qos.data_size.bits	 = 0x07;
1373	if(self->capability & IUC_NO_WINDOW)
1374		self->qos.window_size.bits	 = 0x01;
1375	if(self->capability & IUC_MAX_WINDOW)
1376		self->qos.window_size.bits	 = 0x7f;
1377	if(self->capability & IUC_MAX_XBOFS)
1378		self->qos.additional_bofs.bits	 = 0x01;
1379
1380#if 1
1381	/* Module parameter can override the rx window size */
1382	if (qos_mtt_bits)
1383		self->qos.min_turn_time.bits = qos_mtt_bits;
1384#endif	    
1385	/* 
1386	 * Note : most of those values apply only for the receive path,
1387	 * the transmit path will be set differently - Jean II 
1388	 */
1389	irda_qos_bits_to_value(&self->qos);
1390}
1391
1392/*------------------------------------------------------------------*/
1393static const struct net_device_ops irda_usb_netdev_ops = {
1394	.ndo_open       = irda_usb_net_open,
1395	.ndo_stop       = irda_usb_net_close,
1396	.ndo_do_ioctl   = irda_usb_net_ioctl,
1397	.ndo_start_xmit = irda_usb_hard_xmit,
1398	.ndo_tx_timeout	= irda_usb_net_timeout,
1399};
1400
1401/*
1402 * Initialise the network side of the irda-usb instance
1403 * Called when a new USB instance is registered in irda_usb_probe()
1404 */
1405static inline int irda_usb_open(struct irda_usb_cb *self)
1406{
1407	struct net_device *netdev = self->netdev;
1408
1409	netdev->netdev_ops = &irda_usb_netdev_ops;
1410
1411	irda_usb_init_qos(self);
1412
1413	return register_netdev(netdev);
1414}
1415
1416/*------------------------------------------------------------------*/
1417/*
1418 * Cleanup the network side of the irda-usb instance
1419 * Called when a USB instance is removed in irda_usb_disconnect()
1420 */
1421static inline void irda_usb_close(struct irda_usb_cb *self)
1422{
1423	/* Remove netdevice */
1424	unregister_netdev(self->netdev);
1425
1426	/* Remove the speed buffer */
1427	kfree(self->speed_buff);
1428	self->speed_buff = NULL;
1429
1430	kfree(self->tx_buff);
1431	self->tx_buff = NULL;
1432}
1433
1434/********************** USB CONFIG SUBROUTINES **********************/
1435/*
1436 * Various subroutines dealing with USB stuff we use to configure and
1437 * initialise each irda-usb instance.
1438 * These functions are used below in the main calls of the driver...
1439 */
1440
1441/*------------------------------------------------------------------*/
1442/*
1443 * Function irda_usb_parse_endpoints(dev, ifnum)
1444 *
1445 *    Parse the various endpoints and find the one we need.
1446 *
1447 * The endpoint are the pipes used to communicate with the USB device.
1448 * The spec defines 2 endpoints of type bulk transfer, one in, and one out.
1449 * These are used to pass frames back and forth with the dongle.
1450 * Most dongle have also an interrupt endpoint, that will be probably
1451 * documented in the next spec...
1452 */
1453static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_host_endpoint *endpoint, int ennum)
1454{
1455	int i;		/* Endpoint index in table */
1456		
1457	/* Init : no endpoints */
1458	self->bulk_in_ep = 0;
1459	self->bulk_out_ep = 0;
1460	self->bulk_int_ep = 0;
1461
1462	/* Let's look at all those endpoints */
1463	for(i = 0; i < ennum; i++) {
1464		/* All those variables will get optimised by the compiler,
1465		 * so let's aim for clarity... - Jean II */
1466		__u8 ep;	/* Endpoint address */
1467		__u8 dir;	/* Endpoint direction */
1468		__u8 attr;	/* Endpoint attribute */
1469		__u16 psize;	/* Endpoint max packet size in bytes */
1470
1471		/* Get endpoint address, direction and attribute */
1472		ep = endpoint[i].desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
1473		dir = endpoint[i].desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK;
1474		attr = endpoint[i].desc.bmAttributes;
1475		psize = le16_to_cpu(endpoint[i].desc.wMaxPacketSize);
1476
1477		/* Is it a bulk endpoint ??? */
1478		if(attr == USB_ENDPOINT_XFER_BULK) {
1479			/* We need to find an IN and an OUT */
1480			if(dir == USB_DIR_IN) {
1481				/* This is our Rx endpoint */
1482				self->bulk_in_ep = ep;
1483			} else {
1484				/* This is our Tx endpoint */
1485				self->bulk_out_ep = ep;
1486				self->bulk_out_mtu = psize;
1487			}
1488		} else {
1489			if((attr == USB_ENDPOINT_XFER_INT) &&
1490			   (dir == USB_DIR_IN)) {
1491				/* This is our interrupt endpoint */
1492				self->bulk_int_ep = ep;
1493			} else {
1494				net_err_ratelimited("%s(), Unrecognised endpoint %02X\n",
1495						    __func__, ep);
1496			}
1497		}
1498	}
1499
1500	pr_debug("%s(), And our endpoints are : in=%02X, out=%02X (%d), int=%02X\n",
1501		 __func__, self->bulk_in_ep, self->bulk_out_ep,
1502		 self->bulk_out_mtu, self->bulk_int_ep);
1503
1504	return (self->bulk_in_ep != 0) && (self->bulk_out_ep != 0);
1505}
1506
1507#ifdef IU_DUMP_CLASS_DESC
1508/*------------------------------------------------------------------*/
1509/*
1510 * Function usb_irda_dump_class_desc(desc)
1511 *
1512 *    Prints out the contents of the IrDA class descriptor
1513 *
1514 */
1515static inline void irda_usb_dump_class_desc(struct irda_class_desc *desc)
1516{
1517	/* Values are little endian */
1518	printk("bLength=%x\n", desc->bLength);
1519	printk("bDescriptorType=%x\n", desc->bDescriptorType);
1520	printk("bcdSpecRevision=%x\n", le16_to_cpu(desc->bcdSpecRevision)); 
1521	printk("bmDataSize=%x\n", desc->bmDataSize);
1522	printk("bmWindowSize=%x\n", desc->bmWindowSize);
1523	printk("bmMinTurnaroundTime=%d\n", desc->bmMinTurnaroundTime);
1524	printk("wBaudRate=%x\n", le16_to_cpu(desc->wBaudRate));
1525	printk("bmAdditionalBOFs=%x\n", desc->bmAdditionalBOFs);
1526	printk("bIrdaRateSniff=%x\n", desc->bIrdaRateSniff);
1527	printk("bMaxUnicastList=%x\n", desc->bMaxUnicastList);
1528}
1529#endif /* IU_DUMP_CLASS_DESC */
1530
1531/*------------------------------------------------------------------*/
1532/*
1533 * Function irda_usb_find_class_desc(intf)
1534 *
1535 *    Returns instance of IrDA class descriptor, or NULL if not found
1536 *
1537 * The class descriptor is some extra info that IrDA USB devices will
1538 * offer to us, describing their IrDA characteristics. We will use that in
1539 * irda_usb_init_qos()
1540 */
1541static inline struct irda_class_desc *irda_usb_find_class_desc(struct usb_interface *intf)
1542{
1543	struct usb_device *dev = interface_to_usbdev (intf);
1544	struct irda_class_desc *desc;
1545	int ret;
1546
1547	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
1548	if (!desc)
1549		return NULL;
1550
1551	/* USB-IrDA class spec 1.0:
1552	 *	6.1.3: Standard "Get Descriptor" Device Request is not
1553	 *	       appropriate to retrieve class-specific descriptor
1554	 *	6.2.5: Class Specific "Get Class Descriptor" Interface Request
1555	 *	       is mandatory and returns the USB-IrDA class descriptor
1556	 */
1557
1558	ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0),
1559		IU_REQ_GET_CLASS_DESC,
1560		USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1561		0, intf->altsetting->desc.bInterfaceNumber, desc,
1562		sizeof(*desc), 500);
1563	
1564	pr_debug("%s(), ret=%d\n", __func__, ret);
1565	if (ret < sizeof(*desc)) {
1566		net_warn_ratelimited("usb-irda: class_descriptor read %s (%d)\n",
1567				     ret < 0 ? "failed" : "too short", ret);
1568	}
1569	else if (desc->bDescriptorType != USB_DT_IRDA) {
1570		net_warn_ratelimited("usb-irda: bad class_descriptor type\n");
1571	}
1572	else {
1573#ifdef IU_DUMP_CLASS_DESC
1574		irda_usb_dump_class_desc(desc);
1575#endif	/* IU_DUMP_CLASS_DESC */
1576
1577		return desc;
1578	}
1579	kfree(desc);
1580	return NULL;
1581}
1582
1583/*********************** USB DEVICE CALLBACKS ***********************/
1584/*
1585 * Main calls from the USB subsystem.
1586 * Mostly registering a new irda-usb device and removing it....
1587 */
1588
1589/*------------------------------------------------------------------*/
1590/*
1591 * This routine is called by the USB subsystem for each new device
1592 * in the system. We need to check if the device is ours, and in
1593 * this case start handling it.
1594 * The USB layer protect us from reentrancy (via BKL), so we don't need
1595 * to spinlock in there... Jean II…

Large files files are truncated, but you can click here to view the full file