PageRenderTime 78ms CodeModel.GetById 15ms app.highlight 51ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/isdn/gigaset/bas-gigaset.c

https://bitbucket.org/ndreys/linux-sunxi
C | 2657 lines | 1921 code | 275 blank | 461 comment | 267 complexity | 3983f5f734c9ecaf9102d8ce2f8cdbd4 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

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

   1/*
   2 * USB driver for Gigaset 307x base via direct USB connection.
   3 *
   4 * Copyright (c) 2001 by Hansjoerg Lipp <hjlipp@web.de>,
   5 *                       Tilman Schmidt <tilman@imap.cc>,
   6 *                       Stefan Eilers.
   7 *
   8 * =====================================================================
   9 *	This program is free software; you can redistribute it and/or
  10 *	modify it under the terms of the GNU General Public License as
  11 *	published by the Free Software Foundation; either version 2 of
  12 *	the License, or (at your option) any later version.
  13 * =====================================================================
  14 */
  15
  16#include "gigaset.h"
  17#include <linux/usb.h>
  18#include <linux/module.h>
  19#include <linux/moduleparam.h>
  20
  21/* Version Information */
  22#define DRIVER_AUTHOR "Tilman Schmidt <tilman@imap.cc>, Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers"
  23#define DRIVER_DESC "USB Driver for Gigaset 307x"
  24
  25
  26/* Module parameters */
  27
  28static int startmode = SM_ISDN;
  29static int cidmode = 1;
  30
  31module_param(startmode, int, S_IRUGO);
  32module_param(cidmode, int, S_IRUGO);
  33MODULE_PARM_DESC(startmode, "start in isdn4linux mode");
  34MODULE_PARM_DESC(cidmode, "Call-ID mode");
  35
  36#define GIGASET_MINORS     1
  37#define GIGASET_MINOR      16
  38#define GIGASET_MODULENAME "bas_gigaset"
  39#define GIGASET_DEVNAME    "ttyGB"
  40
  41/* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
  42#define IF_WRITEBUF 264
  43
  44/* interrupt pipe message size according to ibid. ch. 2.2 */
  45#define IP_MSGSIZE 3
  46
  47/* Values for the Gigaset 307x */
  48#define USB_GIGA_VENDOR_ID      0x0681
  49#define USB_3070_PRODUCT_ID     0x0001
  50#define USB_3075_PRODUCT_ID     0x0002
  51#define USB_SX303_PRODUCT_ID    0x0021
  52#define USB_SX353_PRODUCT_ID    0x0022
  53
  54/* table of devices that work with this driver */
  55static const struct usb_device_id gigaset_table[] = {
  56	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3070_PRODUCT_ID) },
  57	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3075_PRODUCT_ID) },
  58	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_SX303_PRODUCT_ID) },
  59	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_SX353_PRODUCT_ID) },
  60	{ } /* Terminating entry */
  61};
  62
  63MODULE_DEVICE_TABLE(usb, gigaset_table);
  64
  65/*======================= local function prototypes ==========================*/
  66
  67/* function called if a new device belonging to this driver is connected */
  68static int gigaset_probe(struct usb_interface *interface,
  69			 const struct usb_device_id *id);
  70
  71/* Function will be called if the device is unplugged */
  72static void gigaset_disconnect(struct usb_interface *interface);
  73
  74/* functions called before/after suspend */
  75static int gigaset_suspend(struct usb_interface *intf, pm_message_t message);
  76static int gigaset_resume(struct usb_interface *intf);
  77
  78/* functions called before/after device reset */
  79static int gigaset_pre_reset(struct usb_interface *intf);
  80static int gigaset_post_reset(struct usb_interface *intf);
  81
  82static int atread_submit(struct cardstate *, int);
  83static void stopurbs(struct bas_bc_state *);
  84static int req_submit(struct bc_state *, int, int, int);
  85static int atwrite_submit(struct cardstate *, unsigned char *, int);
  86static int start_cbsend(struct cardstate *);
  87
  88/*============================================================================*/
  89
  90struct bas_cardstate {
  91	struct usb_device	*udev;		/* USB device pointer */
  92	struct usb_interface	*interface;	/* interface for this device */
  93	unsigned char		minor;		/* starting minor number */
  94
  95	struct urb		*urb_ctrl;	/* control pipe default URB */
  96	struct usb_ctrlrequest	dr_ctrl;
  97	struct timer_list	timer_ctrl;	/* control request timeout */
  98	int			retry_ctrl;
  99
 100	struct timer_list	timer_atrdy;	/* AT command ready timeout */
 101	struct urb		*urb_cmd_out;	/* for sending AT commands */
 102	struct usb_ctrlrequest	dr_cmd_out;
 103	int			retry_cmd_out;
 104
 105	struct urb		*urb_cmd_in;	/* for receiving AT replies */
 106	struct usb_ctrlrequest	dr_cmd_in;
 107	struct timer_list	timer_cmd_in;	/* receive request timeout */
 108	unsigned char		*rcvbuf;	/* AT reply receive buffer */
 109
 110	struct urb		*urb_int_in;	/* URB for interrupt pipe */
 111	unsigned char		*int_in_buf;
 112	struct work_struct	int_in_wq;	/* for usb_clear_halt() */
 113	struct timer_list	timer_int_in;	/* int read retry delay */
 114	int			retry_int_in;
 115
 116	spinlock_t		lock;		/* locks all following */
 117	int			basstate;	/* bitmap (BS_*) */
 118	int			pending;	/* uncompleted base request */
 119	wait_queue_head_t	waitqueue;
 120	int			rcvbuf_size;	/* size of AT receive buffer */
 121						/* 0: no receive in progress */
 122	int			retry_cmd_in;	/* receive req retry count */
 123};
 124
 125/* status of direct USB connection to 307x base (bits in basstate) */
 126#define BS_ATOPEN	0x001	/* AT channel open */
 127#define BS_B1OPEN	0x002	/* B channel 1 open */
 128#define BS_B2OPEN	0x004	/* B channel 2 open */
 129#define BS_ATREADY	0x008	/* base ready for AT command */
 130#define BS_INIT		0x010	/* base has signalled INIT_OK */
 131#define BS_ATTIMER	0x020	/* waiting for HD_READY_SEND_ATDATA */
 132#define BS_ATRDPEND	0x040	/* urb_cmd_in in use */
 133#define BS_ATWRPEND	0x080	/* urb_cmd_out in use */
 134#define BS_SUSPEND	0x100	/* USB port suspended */
 135#define BS_RESETTING	0x200	/* waiting for HD_RESET_INTERRUPT_PIPE_ACK */
 136
 137
 138static struct gigaset_driver *driver;
 139
 140/* usb specific object needed to register this driver with the usb subsystem */
 141static struct usb_driver gigaset_usb_driver = {
 142	.name =         GIGASET_MODULENAME,
 143	.probe =        gigaset_probe,
 144	.disconnect =   gigaset_disconnect,
 145	.id_table =     gigaset_table,
 146	.suspend =	gigaset_suspend,
 147	.resume =	gigaset_resume,
 148	.reset_resume =	gigaset_post_reset,
 149	.pre_reset =	gigaset_pre_reset,
 150	.post_reset =	gigaset_post_reset,
 151};
 152
 153/* get message text for usb_submit_urb return code
 154 */
 155static char *get_usb_rcmsg(int rc)
 156{
 157	static char unkmsg[28];
 158
 159	switch (rc) {
 160	case 0:
 161		return "success";
 162	case -ENOMEM:
 163		return "out of memory";
 164	case -ENODEV:
 165		return "device not present";
 166	case -ENOENT:
 167		return "endpoint not present";
 168	case -ENXIO:
 169		return "URB type not supported";
 170	case -EINVAL:
 171		return "invalid argument";
 172	case -EAGAIN:
 173		return "start frame too early or too much scheduled";
 174	case -EFBIG:
 175		return "too many isoc frames requested";
 176	case -EPIPE:
 177		return "endpoint stalled";
 178	case -EMSGSIZE:
 179		return "invalid packet size";
 180	case -ENOSPC:
 181		return "would overcommit USB bandwidth";
 182	case -ESHUTDOWN:
 183		return "device shut down";
 184	case -EPERM:
 185		return "reject flag set";
 186	case -EHOSTUNREACH:
 187		return "device suspended";
 188	default:
 189		snprintf(unkmsg, sizeof(unkmsg), "unknown error %d", rc);
 190		return unkmsg;
 191	}
 192}
 193
 194/* get message text for USB status code
 195 */
 196static char *get_usb_statmsg(int status)
 197{
 198	static char unkmsg[28];
 199
 200	switch (status) {
 201	case 0:
 202		return "success";
 203	case -ENOENT:
 204		return "unlinked (sync)";
 205	case -EINPROGRESS:
 206		return "URB still pending";
 207	case -EPROTO:
 208		return "bitstuff error, timeout, or unknown USB error";
 209	case -EILSEQ:
 210		return "CRC mismatch, timeout, or unknown USB error";
 211	case -ETIME:
 212		return "USB response timeout";
 213	case -EPIPE:
 214		return "endpoint stalled";
 215	case -ECOMM:
 216		return "IN buffer overrun";
 217	case -ENOSR:
 218		return "OUT buffer underrun";
 219	case -EOVERFLOW:
 220		return "endpoint babble";
 221	case -EREMOTEIO:
 222		return "short packet";
 223	case -ENODEV:
 224		return "device removed";
 225	case -EXDEV:
 226		return "partial isoc transfer";
 227	case -EINVAL:
 228		return "ISO madness";
 229	case -ECONNRESET:
 230		return "unlinked (async)";
 231	case -ESHUTDOWN:
 232		return "device shut down";
 233	default:
 234		snprintf(unkmsg, sizeof(unkmsg), "unknown status %d", status);
 235		return unkmsg;
 236	}
 237}
 238
 239/* usb_pipetype_str
 240 * retrieve string representation of USB pipe type
 241 */
 242static inline char *usb_pipetype_str(int pipe)
 243{
 244	if (usb_pipeisoc(pipe))
 245		return "Isoc";
 246	if (usb_pipeint(pipe))
 247		return "Int";
 248	if (usb_pipecontrol(pipe))
 249		return "Ctrl";
 250	if (usb_pipebulk(pipe))
 251		return "Bulk";
 252	return "?";
 253}
 254
 255/* dump_urb
 256 * write content of URB to syslog for debugging
 257 */
 258static inline void dump_urb(enum debuglevel level, const char *tag,
 259			    struct urb *urb)
 260{
 261#ifdef CONFIG_GIGASET_DEBUG
 262	int i;
 263	gig_dbg(level, "%s urb(0x%08lx)->{", tag, (unsigned long) urb);
 264	if (urb) {
 265		gig_dbg(level,
 266			"  dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, "
 267			"hcpriv=0x%08lx, transfer_flags=0x%x,",
 268			(unsigned long) urb->dev,
 269			usb_pipetype_str(urb->pipe),
 270			usb_pipeendpoint(urb->pipe), usb_pipedevice(urb->pipe),
 271			usb_pipein(urb->pipe) ? "in" : "out",
 272			(unsigned long) urb->hcpriv,
 273			urb->transfer_flags);
 274		gig_dbg(level,
 275			"  transfer_buffer=0x%08lx[%d], actual_length=%d, "
 276			"setup_packet=0x%08lx,",
 277			(unsigned long) urb->transfer_buffer,
 278			urb->transfer_buffer_length, urb->actual_length,
 279			(unsigned long) urb->setup_packet);
 280		gig_dbg(level,
 281			"  start_frame=%d, number_of_packets=%d, interval=%d, "
 282			"error_count=%d,",
 283			urb->start_frame, urb->number_of_packets, urb->interval,
 284			urb->error_count);
 285		gig_dbg(level,
 286			"  context=0x%08lx, complete=0x%08lx, "
 287			"iso_frame_desc[]={",
 288			(unsigned long) urb->context,
 289			(unsigned long) urb->complete);
 290		for (i = 0; i < urb->number_of_packets; i++) {
 291			struct usb_iso_packet_descriptor *pifd
 292				= &urb->iso_frame_desc[i];
 293			gig_dbg(level,
 294				"    {offset=%u, length=%u, actual_length=%u, "
 295				"status=%u}",
 296				pifd->offset, pifd->length, pifd->actual_length,
 297				pifd->status);
 298		}
 299	}
 300	gig_dbg(level, "}}");
 301#endif
 302}
 303
 304/* read/set modem control bits etc. (m10x only) */
 305static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
 306				  unsigned new_state)
 307{
 308	return -EINVAL;
 309}
 310
 311static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
 312{
 313	return -EINVAL;
 314}
 315
 316static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
 317{
 318	return -EINVAL;
 319}
 320
 321/* set/clear bits in base connection state, return previous state
 322 */
 323static inline int update_basstate(struct bas_cardstate *ucs,
 324				  int set, int clear)
 325{
 326	unsigned long flags;
 327	int state;
 328
 329	spin_lock_irqsave(&ucs->lock, flags);
 330	state = ucs->basstate;
 331	ucs->basstate = (state & ~clear) | set;
 332	spin_unlock_irqrestore(&ucs->lock, flags);
 333	return state;
 334}
 335
 336/* error_hangup
 337 * hang up any existing connection because of an unrecoverable error
 338 * This function may be called from any context and takes care of scheduling
 339 * the necessary actions for execution outside of interrupt context.
 340 * cs->lock must not be held.
 341 * argument:
 342 *	B channel control structure
 343 */
 344static inline void error_hangup(struct bc_state *bcs)
 345{
 346	struct cardstate *cs = bcs->cs;
 347
 348	gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL);
 349	gigaset_schedule_event(cs);
 350}
 351
 352/* error_reset
 353 * reset Gigaset device because of an unrecoverable error
 354 * This function may be called from any context, and takes care of
 355 * scheduling the necessary actions for execution outside of interrupt context.
 356 * cs->hw.bas->lock must not be held.
 357 * argument:
 358 *	controller state structure
 359 */
 360static inline void error_reset(struct cardstate *cs)
 361{
 362	/* reset interrupt pipe to recover (ignore errors) */
 363	update_basstate(cs->hw.bas, BS_RESETTING, 0);
 364	if (req_submit(cs->bcs, HD_RESET_INTERRUPT_PIPE, 0, BAS_TIMEOUT))
 365		/* submission failed, escalate to USB port reset */
 366		usb_queue_reset_device(cs->hw.bas->interface);
 367}
 368
 369/* check_pending
 370 * check for completion of pending control request
 371 * parameter:
 372 *	ucs	hardware specific controller state structure
 373 */
 374static void check_pending(struct bas_cardstate *ucs)
 375{
 376	unsigned long flags;
 377
 378	spin_lock_irqsave(&ucs->lock, flags);
 379	switch (ucs->pending) {
 380	case 0:
 381		break;
 382	case HD_OPEN_ATCHANNEL:
 383		if (ucs->basstate & BS_ATOPEN)
 384			ucs->pending = 0;
 385		break;
 386	case HD_OPEN_B1CHANNEL:
 387		if (ucs->basstate & BS_B1OPEN)
 388			ucs->pending = 0;
 389		break;
 390	case HD_OPEN_B2CHANNEL:
 391		if (ucs->basstate & BS_B2OPEN)
 392			ucs->pending = 0;
 393		break;
 394	case HD_CLOSE_ATCHANNEL:
 395		if (!(ucs->basstate & BS_ATOPEN))
 396			ucs->pending = 0;
 397		break;
 398	case HD_CLOSE_B1CHANNEL:
 399		if (!(ucs->basstate & BS_B1OPEN))
 400			ucs->pending = 0;
 401		break;
 402	case HD_CLOSE_B2CHANNEL:
 403		if (!(ucs->basstate & BS_B2OPEN))
 404			ucs->pending = 0;
 405		break;
 406	case HD_DEVICE_INIT_ACK:		/* no reply expected */
 407		ucs->pending = 0;
 408		break;
 409	case HD_RESET_INTERRUPT_PIPE:
 410		if (!(ucs->basstate & BS_RESETTING))
 411			ucs->pending = 0;
 412		break;
 413	/*
 414	 * HD_READ_ATMESSAGE and HD_WRITE_ATMESSAGE are handled separately
 415	 * and should never end up here
 416	 */
 417	default:
 418		dev_warn(&ucs->interface->dev,
 419			 "unknown pending request 0x%02x cleared\n",
 420			 ucs->pending);
 421		ucs->pending = 0;
 422	}
 423
 424	if (!ucs->pending)
 425		del_timer(&ucs->timer_ctrl);
 426
 427	spin_unlock_irqrestore(&ucs->lock, flags);
 428}
 429
 430/* cmd_in_timeout
 431 * timeout routine for command input request
 432 * argument:
 433 *	controller state structure
 434 */
 435static void cmd_in_timeout(unsigned long data)
 436{
 437	struct cardstate *cs = (struct cardstate *) data;
 438	struct bas_cardstate *ucs = cs->hw.bas;
 439	int rc;
 440
 441	if (!ucs->rcvbuf_size) {
 442		gig_dbg(DEBUG_USBREQ, "%s: no receive in progress", __func__);
 443		return;
 444	}
 445
 446	if (ucs->retry_cmd_in++ >= BAS_RETRY) {
 447		dev_err(cs->dev,
 448			"control read: timeout, giving up after %d tries\n",
 449			ucs->retry_cmd_in);
 450		kfree(ucs->rcvbuf);
 451		ucs->rcvbuf = NULL;
 452		ucs->rcvbuf_size = 0;
 453		error_reset(cs);
 454		return;
 455	}
 456
 457	gig_dbg(DEBUG_USBREQ, "%s: timeout, retry %d",
 458		__func__, ucs->retry_cmd_in);
 459	rc = atread_submit(cs, BAS_TIMEOUT);
 460	if (rc < 0) {
 461		kfree(ucs->rcvbuf);
 462		ucs->rcvbuf = NULL;
 463		ucs->rcvbuf_size = 0;
 464		if (rc != -ENODEV)
 465			error_reset(cs);
 466	}
 467}
 468
 469/* read_ctrl_callback
 470 * USB completion handler for control pipe input
 471 * called by the USB subsystem in interrupt context
 472 * parameter:
 473 *	urb	USB request block
 474 *		urb->context = inbuf structure for controller state
 475 */
 476static void read_ctrl_callback(struct urb *urb)
 477{
 478	struct inbuf_t *inbuf = urb->context;
 479	struct cardstate *cs = inbuf->cs;
 480	struct bas_cardstate *ucs = cs->hw.bas;
 481	int status = urb->status;
 482	unsigned numbytes;
 483	int rc;
 484
 485	update_basstate(ucs, 0, BS_ATRDPEND);
 486	wake_up(&ucs->waitqueue);
 487	del_timer(&ucs->timer_cmd_in);
 488
 489	switch (status) {
 490	case 0:				/* normal completion */
 491		numbytes = urb->actual_length;
 492		if (unlikely(numbytes != ucs->rcvbuf_size)) {
 493			dev_warn(cs->dev,
 494			       "control read: received %d chars, expected %d\n",
 495				 numbytes, ucs->rcvbuf_size);
 496			if (numbytes > ucs->rcvbuf_size)
 497				numbytes = ucs->rcvbuf_size;
 498		}
 499
 500		/* copy received bytes to inbuf, notify event layer */
 501		if (gigaset_fill_inbuf(inbuf, ucs->rcvbuf, numbytes)) {
 502			gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
 503			gigaset_schedule_event(cs);
 504		}
 505		break;
 506
 507	case -ENOENT:			/* cancelled */
 508	case -ECONNRESET:		/* cancelled (async) */
 509	case -EINPROGRESS:		/* pending */
 510	case -ENODEV:			/* device removed */
 511	case -ESHUTDOWN:		/* device shut down */
 512		/* no further action necessary */
 513		gig_dbg(DEBUG_USBREQ, "%s: %s",
 514			__func__, get_usb_statmsg(status));
 515		break;
 516
 517	default:			/* other errors: retry */
 518		if (ucs->retry_cmd_in++ < BAS_RETRY) {
 519			gig_dbg(DEBUG_USBREQ, "%s: %s, retry %d", __func__,
 520				get_usb_statmsg(status), ucs->retry_cmd_in);
 521			rc = atread_submit(cs, BAS_TIMEOUT);
 522			if (rc >= 0)
 523				/* successfully resubmitted, skip freeing */
 524				return;
 525			if (rc == -ENODEV)
 526				/* disconnect, no further action necessary */
 527				break;
 528		}
 529		dev_err(cs->dev, "control read: %s, giving up after %d tries\n",
 530			get_usb_statmsg(status), ucs->retry_cmd_in);
 531		error_reset(cs);
 532	}
 533
 534	/* read finished, free buffer */
 535	kfree(ucs->rcvbuf);
 536	ucs->rcvbuf = NULL;
 537	ucs->rcvbuf_size = 0;
 538}
 539
 540/* atread_submit
 541 * submit an HD_READ_ATMESSAGE command URB and optionally start a timeout
 542 * parameters:
 543 *	cs	controller state structure
 544 *	timeout	timeout in 1/10 sec., 0: none
 545 * return value:
 546 *	0 on success
 547 *	-EBUSY if another request is pending
 548 *	any URB submission error code
 549 */
 550static int atread_submit(struct cardstate *cs, int timeout)
 551{
 552	struct bas_cardstate *ucs = cs->hw.bas;
 553	int basstate;
 554	int ret;
 555
 556	gig_dbg(DEBUG_USBREQ, "-------> HD_READ_ATMESSAGE (%d)",
 557		ucs->rcvbuf_size);
 558
 559	basstate = update_basstate(ucs, BS_ATRDPEND, 0);
 560	if (basstate & BS_ATRDPEND) {
 561		dev_err(cs->dev,
 562			"could not submit HD_READ_ATMESSAGE: URB busy\n");
 563		return -EBUSY;
 564	}
 565
 566	if (basstate & BS_SUSPEND) {
 567		dev_notice(cs->dev,
 568			   "HD_READ_ATMESSAGE not submitted, "
 569			   "suspend in progress\n");
 570		update_basstate(ucs, 0, BS_ATRDPEND);
 571		/* treat like disconnect */
 572		return -ENODEV;
 573	}
 574
 575	ucs->dr_cmd_in.bRequestType = IN_VENDOR_REQ;
 576	ucs->dr_cmd_in.bRequest = HD_READ_ATMESSAGE;
 577	ucs->dr_cmd_in.wValue = 0;
 578	ucs->dr_cmd_in.wIndex = 0;
 579	ucs->dr_cmd_in.wLength = cpu_to_le16(ucs->rcvbuf_size);
 580	usb_fill_control_urb(ucs->urb_cmd_in, ucs->udev,
 581			     usb_rcvctrlpipe(ucs->udev, 0),
 582			     (unsigned char *) &ucs->dr_cmd_in,
 583			     ucs->rcvbuf, ucs->rcvbuf_size,
 584			     read_ctrl_callback, cs->inbuf);
 585
 586	ret = usb_submit_urb(ucs->urb_cmd_in, GFP_ATOMIC);
 587	if (ret != 0) {
 588		update_basstate(ucs, 0, BS_ATRDPEND);
 589		dev_err(cs->dev, "could not submit HD_READ_ATMESSAGE: %s\n",
 590			get_usb_rcmsg(ret));
 591		return ret;
 592	}
 593
 594	if (timeout > 0) {
 595		gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
 596		mod_timer(&ucs->timer_cmd_in, jiffies + timeout * HZ / 10);
 597	}
 598	return 0;
 599}
 600
 601/* int_in_work
 602 * workqueue routine to clear halt on interrupt in endpoint
 603 */
 604
 605static void int_in_work(struct work_struct *work)
 606{
 607	struct bas_cardstate *ucs =
 608		container_of(work, struct bas_cardstate, int_in_wq);
 609	struct urb *urb = ucs->urb_int_in;
 610	struct cardstate *cs = urb->context;
 611	int rc;
 612
 613	/* clear halt condition */
 614	rc = usb_clear_halt(ucs->udev, urb->pipe);
 615	gig_dbg(DEBUG_USBREQ, "clear_halt: %s", get_usb_rcmsg(rc));
 616	if (rc == 0)
 617		/* success, resubmit interrupt read URB */
 618		rc = usb_submit_urb(urb, GFP_ATOMIC);
 619	if (rc != 0 && rc != -ENODEV) {
 620		dev_err(cs->dev, "clear halt failed: %s\n", get_usb_rcmsg(rc));
 621		rc = usb_lock_device_for_reset(ucs->udev, ucs->interface);
 622		if (rc == 0) {
 623			rc = usb_reset_device(ucs->udev);
 624			usb_unlock_device(ucs->udev);
 625		}
 626	}
 627	ucs->retry_int_in = 0;
 628}
 629
 630/* int_in_resubmit
 631 * timer routine for interrupt read delayed resubmit
 632 * argument:
 633 *	controller state structure
 634 */
 635static void int_in_resubmit(unsigned long data)
 636{
 637	struct cardstate *cs = (struct cardstate *) data;
 638	struct bas_cardstate *ucs = cs->hw.bas;
 639	int rc;
 640
 641	if (ucs->retry_int_in++ >= BAS_RETRY) {
 642		dev_err(cs->dev, "interrupt read: giving up after %d tries\n",
 643			ucs->retry_int_in);
 644		usb_queue_reset_device(ucs->interface);
 645		return;
 646	}
 647
 648	gig_dbg(DEBUG_USBREQ, "%s: retry %d", __func__, ucs->retry_int_in);
 649	rc = usb_submit_urb(ucs->urb_int_in, GFP_ATOMIC);
 650	if (rc != 0 && rc != -ENODEV) {
 651		dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
 652			get_usb_rcmsg(rc));
 653		usb_queue_reset_device(ucs->interface);
 654	}
 655}
 656
 657/* read_int_callback
 658 * USB completion handler for interrupt pipe input
 659 * called by the USB subsystem in interrupt context
 660 * parameter:
 661 *	urb	USB request block
 662 *		urb->context = controller state structure
 663 */
 664static void read_int_callback(struct urb *urb)
 665{
 666	struct cardstate *cs = urb->context;
 667	struct bas_cardstate *ucs = cs->hw.bas;
 668	struct bc_state *bcs;
 669	int status = urb->status;
 670	unsigned long flags;
 671	int rc;
 672	unsigned l;
 673	int channel;
 674
 675	switch (status) {
 676	case 0:			/* success */
 677		ucs->retry_int_in = 0;
 678		break;
 679	case -EPIPE:			/* endpoint stalled */
 680		schedule_work(&ucs->int_in_wq);
 681		/* fall through */
 682	case -ENOENT:			/* cancelled */
 683	case -ECONNRESET:		/* cancelled (async) */
 684	case -EINPROGRESS:		/* pending */
 685	case -ENODEV:			/* device removed */
 686	case -ESHUTDOWN:		/* device shut down */
 687		/* no further action necessary */
 688		gig_dbg(DEBUG_USBREQ, "%s: %s",
 689			__func__, get_usb_statmsg(status));
 690		return;
 691	case -EPROTO:			/* protocol error or unplug */
 692	case -EILSEQ:
 693	case -ETIME:
 694		/* resubmit after delay */
 695		gig_dbg(DEBUG_USBREQ, "%s: %s",
 696			__func__, get_usb_statmsg(status));
 697		mod_timer(&ucs->timer_int_in, jiffies + HZ / 10);
 698		return;
 699	default:		/* other errors: just resubmit */
 700		dev_warn(cs->dev, "interrupt read: %s\n",
 701			 get_usb_statmsg(status));
 702		goto resubmit;
 703	}
 704
 705	/* drop incomplete packets even if the missing bytes wouldn't matter */
 706	if (unlikely(urb->actual_length < IP_MSGSIZE)) {
 707		dev_warn(cs->dev, "incomplete interrupt packet (%d bytes)\n",
 708			 urb->actual_length);
 709		goto resubmit;
 710	}
 711
 712	l = (unsigned) ucs->int_in_buf[1] +
 713	    (((unsigned) ucs->int_in_buf[2]) << 8);
 714
 715	gig_dbg(DEBUG_USBREQ, "<-------%d: 0x%02x (%u [0x%02x 0x%02x])",
 716		urb->actual_length, (int)ucs->int_in_buf[0], l,
 717		(int)ucs->int_in_buf[1], (int)ucs->int_in_buf[2]);
 718
 719	channel = 0;
 720
 721	switch (ucs->int_in_buf[0]) {
 722	case HD_DEVICE_INIT_OK:
 723		update_basstate(ucs, BS_INIT, 0);
 724		break;
 725
 726	case HD_READY_SEND_ATDATA:
 727		del_timer(&ucs->timer_atrdy);
 728		update_basstate(ucs, BS_ATREADY, BS_ATTIMER);
 729		start_cbsend(cs);
 730		break;
 731
 732	case HD_OPEN_B2CHANNEL_ACK:
 733		++channel;
 734	case HD_OPEN_B1CHANNEL_ACK:
 735		bcs = cs->bcs + channel;
 736		update_basstate(ucs, BS_B1OPEN << channel, 0);
 737		gigaset_bchannel_up(bcs);
 738		break;
 739
 740	case HD_OPEN_ATCHANNEL_ACK:
 741		update_basstate(ucs, BS_ATOPEN, 0);
 742		start_cbsend(cs);
 743		break;
 744
 745	case HD_CLOSE_B2CHANNEL_ACK:
 746		++channel;
 747	case HD_CLOSE_B1CHANNEL_ACK:
 748		bcs = cs->bcs + channel;
 749		update_basstate(ucs, 0, BS_B1OPEN << channel);
 750		stopurbs(bcs->hw.bas);
 751		gigaset_bchannel_down(bcs);
 752		break;
 753
 754	case HD_CLOSE_ATCHANNEL_ACK:
 755		update_basstate(ucs, 0, BS_ATOPEN);
 756		break;
 757
 758	case HD_B2_FLOW_CONTROL:
 759		++channel;
 760	case HD_B1_FLOW_CONTROL:
 761		bcs = cs->bcs + channel;
 762		atomic_add((l - BAS_NORMFRAME) * BAS_CORRFRAMES,
 763			   &bcs->hw.bas->corrbytes);
 764		gig_dbg(DEBUG_ISO,
 765			"Flow control (channel %d, sub %d): 0x%02x => %d",
 766			channel, bcs->hw.bas->numsub, l,
 767			atomic_read(&bcs->hw.bas->corrbytes));
 768		break;
 769
 770	case HD_RECEIVEATDATA_ACK:	/* AT response ready to be received */
 771		if (!l) {
 772			dev_warn(cs->dev,
 773				"HD_RECEIVEATDATA_ACK with length 0 ignored\n");
 774			break;
 775		}
 776		spin_lock_irqsave(&cs->lock, flags);
 777		if (ucs->basstate & BS_ATRDPEND) {
 778			spin_unlock_irqrestore(&cs->lock, flags);
 779			dev_warn(cs->dev,
 780	"HD_RECEIVEATDATA_ACK(%d) during HD_READ_ATMESSAGE(%d) ignored\n",
 781				 l, ucs->rcvbuf_size);
 782			break;
 783		}
 784		if (ucs->rcvbuf_size) {
 785			/* throw away previous buffer - we have no queue */
 786			dev_err(cs->dev,
 787				"receive AT data overrun, %d bytes lost\n",
 788				ucs->rcvbuf_size);
 789			kfree(ucs->rcvbuf);
 790			ucs->rcvbuf_size = 0;
 791		}
 792		ucs->rcvbuf = kmalloc(l, GFP_ATOMIC);
 793		if (ucs->rcvbuf == NULL) {
 794			spin_unlock_irqrestore(&cs->lock, flags);
 795			dev_err(cs->dev, "out of memory receiving AT data\n");
 796			break;
 797		}
 798		ucs->rcvbuf_size = l;
 799		ucs->retry_cmd_in = 0;
 800		rc = atread_submit(cs, BAS_TIMEOUT);
 801		if (rc < 0) {
 802			kfree(ucs->rcvbuf);
 803			ucs->rcvbuf = NULL;
 804			ucs->rcvbuf_size = 0;
 805		}
 806		spin_unlock_irqrestore(&cs->lock, flags);
 807		if (rc < 0 && rc != -ENODEV)
 808			error_reset(cs);
 809		break;
 810
 811	case HD_RESET_INTERRUPT_PIPE_ACK:
 812		update_basstate(ucs, 0, BS_RESETTING);
 813		dev_notice(cs->dev, "interrupt pipe reset\n");
 814		break;
 815
 816	case HD_SUSPEND_END:
 817		gig_dbg(DEBUG_USBREQ, "HD_SUSPEND_END");
 818		break;
 819
 820	default:
 821		dev_warn(cs->dev,
 822			 "unknown Gigaset signal 0x%02x (%u) ignored\n",
 823			 (int) ucs->int_in_buf[0], l);
 824	}
 825
 826	check_pending(ucs);
 827	wake_up(&ucs->waitqueue);
 828
 829resubmit:
 830	rc = usb_submit_urb(urb, GFP_ATOMIC);
 831	if (unlikely(rc != 0 && rc != -ENODEV)) {
 832		dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
 833			get_usb_rcmsg(rc));
 834		error_reset(cs);
 835	}
 836}
 837
 838/* read_iso_callback
 839 * USB completion handler for B channel isochronous input
 840 * called by the USB subsystem in interrupt context
 841 * parameter:
 842 *	urb	USB request block of completed request
 843 *		urb->context = bc_state structure
 844 */
 845static void read_iso_callback(struct urb *urb)
 846{
 847	struct bc_state *bcs;
 848	struct bas_bc_state *ubc;
 849	int status = urb->status;
 850	unsigned long flags;
 851	int i, rc;
 852
 853	/* status codes not worth bothering the tasklet with */
 854	if (unlikely(status == -ENOENT ||
 855		     status == -ECONNRESET ||
 856		     status == -EINPROGRESS ||
 857		     status == -ENODEV ||
 858		     status == -ESHUTDOWN)) {
 859		gig_dbg(DEBUG_ISO, "%s: %s",
 860			__func__, get_usb_statmsg(status));
 861		return;
 862	}
 863
 864	bcs = urb->context;
 865	ubc = bcs->hw.bas;
 866
 867	spin_lock_irqsave(&ubc->isoinlock, flags);
 868	if (likely(ubc->isoindone == NULL)) {
 869		/* pass URB to tasklet */
 870		ubc->isoindone = urb;
 871		ubc->isoinstatus = status;
 872		tasklet_hi_schedule(&ubc->rcvd_tasklet);
 873	} else {
 874		/* tasklet still busy, drop data and resubmit URB */
 875		gig_dbg(DEBUG_ISO, "%s: overrun", __func__);
 876		ubc->loststatus = status;
 877		for (i = 0; i < BAS_NUMFRAMES; i++) {
 878			ubc->isoinlost += urb->iso_frame_desc[i].actual_length;
 879			if (unlikely(urb->iso_frame_desc[i].status != 0 &&
 880				     urb->iso_frame_desc[i].status !=
 881								-EINPROGRESS))
 882				ubc->loststatus = urb->iso_frame_desc[i].status;
 883			urb->iso_frame_desc[i].status = 0;
 884			urb->iso_frame_desc[i].actual_length = 0;
 885		}
 886		if (likely(ubc->running)) {
 887			/* urb->dev is clobbered by USB subsystem */
 888			urb->dev = bcs->cs->hw.bas->udev;
 889			urb->transfer_flags = URB_ISO_ASAP;
 890			urb->number_of_packets = BAS_NUMFRAMES;
 891			rc = usb_submit_urb(urb, GFP_ATOMIC);
 892			if (unlikely(rc != 0 && rc != -ENODEV)) {
 893				dev_err(bcs->cs->dev,
 894				       "could not resubmit isoc read URB: %s\n",
 895					get_usb_rcmsg(rc));
 896				dump_urb(DEBUG_ISO, "isoc read", urb);
 897				error_hangup(bcs);
 898			}
 899		}
 900	}
 901	spin_unlock_irqrestore(&ubc->isoinlock, flags);
 902}
 903
 904/* write_iso_callback
 905 * USB completion handler for B channel isochronous output
 906 * called by the USB subsystem in interrupt context
 907 * parameter:
 908 *	urb	USB request block of completed request
 909 *		urb->context = isow_urbctx_t structure
 910 */
 911static void write_iso_callback(struct urb *urb)
 912{
 913	struct isow_urbctx_t *ucx;
 914	struct bas_bc_state *ubc;
 915	int status = urb->status;
 916	unsigned long flags;
 917
 918	/* status codes not worth bothering the tasklet with */
 919	if (unlikely(status == -ENOENT ||
 920		     status == -ECONNRESET ||
 921		     status == -EINPROGRESS ||
 922		     status == -ENODEV ||
 923		     status == -ESHUTDOWN)) {
 924		gig_dbg(DEBUG_ISO, "%s: %s",
 925			__func__, get_usb_statmsg(status));
 926		return;
 927	}
 928
 929	/* pass URB context to tasklet */
 930	ucx = urb->context;
 931	ubc = ucx->bcs->hw.bas;
 932	ucx->status = status;
 933
 934	spin_lock_irqsave(&ubc->isooutlock, flags);
 935	ubc->isooutovfl = ubc->isooutdone;
 936	ubc->isooutdone = ucx;
 937	spin_unlock_irqrestore(&ubc->isooutlock, flags);
 938	tasklet_hi_schedule(&ubc->sent_tasklet);
 939}
 940
 941/* starturbs
 942 * prepare and submit USB request blocks for isochronous input and output
 943 * argument:
 944 *	B channel control structure
 945 * return value:
 946 *	0 on success
 947 *	< 0 on error (no URBs submitted)
 948 */
 949static int starturbs(struct bc_state *bcs)
 950{
 951	struct bas_bc_state *ubc = bcs->hw.bas;
 952	struct urb *urb;
 953	int j, k;
 954	int rc;
 955
 956	/* initialize L2 reception */
 957	if (bcs->proto2 == L2_HDLC)
 958		bcs->inputstate |= INS_flag_hunt;
 959
 960	/* submit all isochronous input URBs */
 961	ubc->running = 1;
 962	for (k = 0; k < BAS_INURBS; k++) {
 963		urb = ubc->isoinurbs[k];
 964		if (!urb) {
 965			rc = -EFAULT;
 966			goto error;
 967		}
 968
 969		urb->dev = bcs->cs->hw.bas->udev;
 970		urb->pipe = usb_rcvisocpipe(urb->dev, 3 + 2 * bcs->channel);
 971		urb->transfer_flags = URB_ISO_ASAP;
 972		urb->transfer_buffer = ubc->isoinbuf + k * BAS_INBUFSIZE;
 973		urb->transfer_buffer_length = BAS_INBUFSIZE;
 974		urb->number_of_packets = BAS_NUMFRAMES;
 975		urb->interval = BAS_FRAMETIME;
 976		urb->complete = read_iso_callback;
 977		urb->context = bcs;
 978		for (j = 0; j < BAS_NUMFRAMES; j++) {
 979			urb->iso_frame_desc[j].offset = j * BAS_MAXFRAME;
 980			urb->iso_frame_desc[j].length = BAS_MAXFRAME;
 981			urb->iso_frame_desc[j].status = 0;
 982			urb->iso_frame_desc[j].actual_length = 0;
 983		}
 984
 985		dump_urb(DEBUG_ISO, "Initial isoc read", urb);
 986		rc = usb_submit_urb(urb, GFP_ATOMIC);
 987		if (rc != 0)
 988			goto error;
 989	}
 990
 991	/* initialize L2 transmission */
 992	gigaset_isowbuf_init(ubc->isooutbuf, PPP_FLAG);
 993
 994	/* set up isochronous output URBs for flag idling */
 995	for (k = 0; k < BAS_OUTURBS; ++k) {
 996		urb = ubc->isoouturbs[k].urb;
 997		if (!urb) {
 998			rc = -EFAULT;
 999			goto error;
1000		}
1001		urb->dev = bcs->cs->hw.bas->udev;
1002		urb->pipe = usb_sndisocpipe(urb->dev, 4 + 2 * bcs->channel);
1003		urb->transfer_flags = URB_ISO_ASAP;
1004		urb->transfer_buffer = ubc->isooutbuf->data;
1005		urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data);
1006		urb->number_of_packets = BAS_NUMFRAMES;
1007		urb->interval = BAS_FRAMETIME;
1008		urb->complete = write_iso_callback;
1009		urb->context = &ubc->isoouturbs[k];
1010		for (j = 0; j < BAS_NUMFRAMES; ++j) {
1011			urb->iso_frame_desc[j].offset = BAS_OUTBUFSIZE;
1012			urb->iso_frame_desc[j].length = BAS_NORMFRAME;
1013			urb->iso_frame_desc[j].status = 0;
1014			urb->iso_frame_desc[j].actual_length = 0;
1015		}
1016		ubc->isoouturbs[k].limit = -1;
1017	}
1018
1019	/* keep one URB free, submit the others */
1020	for (k = 0; k < BAS_OUTURBS-1; ++k) {
1021		dump_urb(DEBUG_ISO, "Initial isoc write", urb);
1022		rc = usb_submit_urb(ubc->isoouturbs[k].urb, GFP_ATOMIC);
1023		if (rc != 0)
1024			goto error;
1025	}
1026	dump_urb(DEBUG_ISO, "Initial isoc write (free)", urb);
1027	ubc->isooutfree = &ubc->isoouturbs[BAS_OUTURBS-1];
1028	ubc->isooutdone = ubc->isooutovfl = NULL;
1029	return 0;
1030 error:
1031	stopurbs(ubc);
1032	return rc;
1033}
1034
1035/* stopurbs
1036 * cancel the USB request blocks for isochronous input and output
1037 * errors are silently ignored
1038 * argument:
1039 *	B channel control structure
1040 */
1041static void stopurbs(struct bas_bc_state *ubc)
1042{
1043	int k, rc;
1044
1045	ubc->running = 0;
1046
1047	for (k = 0; k < BAS_INURBS; ++k) {
1048		rc = usb_unlink_urb(ubc->isoinurbs[k]);
1049		gig_dbg(DEBUG_ISO,
1050			"%s: isoc input URB %d unlinked, result = %s",
1051			__func__, k, get_usb_rcmsg(rc));
1052	}
1053
1054	for (k = 0; k < BAS_OUTURBS; ++k) {
1055		rc = usb_unlink_urb(ubc->isoouturbs[k].urb);
1056		gig_dbg(DEBUG_ISO,
1057			"%s: isoc output URB %d unlinked, result = %s",
1058			__func__, k, get_usb_rcmsg(rc));
1059	}
1060}
1061
1062/* Isochronous Write - Bottom Half */
1063/* =============================== */
1064
1065/* submit_iso_write_urb
1066 * fill and submit the next isochronous write URB
1067 * parameters:
1068 *	ucx	context structure containing URB
1069 * return value:
1070 *	number of frames submitted in URB
1071 *	0 if URB not submitted because no data available (isooutbuf busy)
1072 *	error code < 0 on error
1073 */
1074static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
1075{
1076	struct urb *urb = ucx->urb;
1077	struct bas_bc_state *ubc = ucx->bcs->hw.bas;
1078	struct usb_iso_packet_descriptor *ifd;
1079	int corrbytes, nframe, rc;
1080
1081	/* urb->dev is clobbered by USB subsystem */
1082	urb->dev = ucx->bcs->cs->hw.bas->udev;
1083	urb->transfer_flags = URB_ISO_ASAP;
1084	urb->transfer_buffer = ubc->isooutbuf->data;
1085	urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data);
1086
1087	for (nframe = 0; nframe < BAS_NUMFRAMES; nframe++) {
1088		ifd = &urb->iso_frame_desc[nframe];
1089
1090		/* compute frame length according to flow control */
1091		ifd->length = BAS_NORMFRAME;
1092		corrbytes = atomic_read(&ubc->corrbytes);
1093		if (corrbytes != 0) {
1094			gig_dbg(DEBUG_ISO, "%s: corrbytes=%d",
1095				__func__, corrbytes);
1096			if (corrbytes > BAS_HIGHFRAME - BAS_NORMFRAME)
1097				corrbytes = BAS_HIGHFRAME - BAS_NORMFRAME;
1098			else if (corrbytes < BAS_LOWFRAME - BAS_NORMFRAME)
1099				corrbytes = BAS_LOWFRAME - BAS_NORMFRAME;
1100			ifd->length += corrbytes;
1101			atomic_add(-corrbytes, &ubc->corrbytes);
1102		}
1103
1104		/* retrieve block of data to send */
1105		rc = gigaset_isowbuf_getbytes(ubc->isooutbuf, ifd->length);
1106		if (rc < 0) {
1107			if (rc == -EBUSY) {
1108				gig_dbg(DEBUG_ISO,
1109					"%s: buffer busy at frame %d",
1110					__func__, nframe);
1111				/* tasklet will be restarted from
1112				   gigaset_isoc_send_skb() */
1113			} else {
1114				dev_err(ucx->bcs->cs->dev,
1115					"%s: buffer error %d at frame %d\n",
1116					__func__, rc, nframe);
1117				return rc;
1118			}
1119			break;
1120		}
1121		ifd->offset = rc;
1122		ucx->limit = ubc->isooutbuf->nextread;
1123		ifd->status = 0;
1124		ifd->actual_length = 0;
1125	}
1126	if (unlikely(nframe == 0))
1127		return 0;	/* no data to send */
1128	urb->number_of_packets = nframe;
1129
1130	rc = usb_submit_urb(urb, GFP_ATOMIC);
1131	if (unlikely(rc)) {
1132		if (rc == -ENODEV)
1133			/* device removed - give up silently */
1134			gig_dbg(DEBUG_ISO, "%s: disconnected", __func__);
1135		else
1136			dev_err(ucx->bcs->cs->dev,
1137				"could not submit isoc write URB: %s\n",
1138				get_usb_rcmsg(rc));
1139		return rc;
1140	}
1141	++ubc->numsub;
1142	return nframe;
1143}
1144
1145/* write_iso_tasklet
1146 * tasklet scheduled when an isochronous output URB from the Gigaset device
1147 * has completed
1148 * parameter:
1149 *	data	B channel state structure
1150 */
1151static void write_iso_tasklet(unsigned long data)
1152{
1153	struct bc_state *bcs = (struct bc_state *) data;
1154	struct bas_bc_state *ubc = bcs->hw.bas;
1155	struct cardstate *cs = bcs->cs;
1156	struct isow_urbctx_t *done, *next, *ovfl;
1157	struct urb *urb;
1158	int status;
1159	struct usb_iso_packet_descriptor *ifd;
1160	unsigned long flags;
1161	int i;
1162	struct sk_buff *skb;
1163	int len;
1164	int rc;
1165
1166	/* loop while completed URBs arrive in time */
1167	for (;;) {
1168		if (unlikely(!(ubc->running))) {
1169			gig_dbg(DEBUG_ISO, "%s: not running", __func__);
1170			return;
1171		}
1172
1173		/* retrieve completed URBs */
1174		spin_lock_irqsave(&ubc->isooutlock, flags);
1175		done = ubc->isooutdone;
1176		ubc->isooutdone = NULL;
1177		ovfl = ubc->isooutovfl;
1178		ubc->isooutovfl = NULL;
1179		spin_unlock_irqrestore(&ubc->isooutlock, flags);
1180		if (ovfl) {
1181			dev_err(cs->dev, "isoc write underrun\n");
1182			error_hangup(bcs);
1183			break;
1184		}
1185		if (!done)
1186			break;
1187
1188		/* submit free URB if available */
1189		spin_lock_irqsave(&ubc->isooutlock, flags);
1190		next = ubc->isooutfree;
1191		ubc->isooutfree = NULL;
1192		spin_unlock_irqrestore(&ubc->isooutlock, flags);
1193		if (next) {
1194			rc = submit_iso_write_urb(next);
1195			if (unlikely(rc <= 0 && rc != -ENODEV)) {
1196				/* could not submit URB, put it back */
1197				spin_lock_irqsave(&ubc->isooutlock, flags);
1198				if (ubc->isooutfree == NULL) {
1199					ubc->isooutfree = next;
1200					next = NULL;
1201				}
1202				spin_unlock_irqrestore(&ubc->isooutlock, flags);
1203				if (next) {
1204					/* couldn't put it back */
1205					dev_err(cs->dev,
1206						"losing isoc write URB\n");
1207					error_hangup(bcs);
1208				}
1209			}
1210		}
1211
1212		/* process completed URB */
1213		urb = done->urb;
1214		status = done->status;
1215		switch (status) {
1216		case -EXDEV:			/* partial completion */
1217			gig_dbg(DEBUG_ISO, "%s: URB partially completed",
1218				__func__);
1219			/* fall through - what's the difference anyway? */
1220		case 0:				/* normal completion */
1221			/* inspect individual frames
1222			 * assumptions (for lack of documentation):
1223			 * - actual_length bytes of first frame in error are
1224			 *   successfully sent
1225			 * - all following frames are not sent at all
1226			 */
1227			for (i = 0; i < BAS_NUMFRAMES; i++) {
1228				ifd = &urb->iso_frame_desc[i];
1229				if (ifd->status ||
1230				    ifd->actual_length != ifd->length) {
1231					dev_warn(cs->dev,
1232					    "isoc write: frame %d[%d/%d]: %s\n",
1233						 i, ifd->actual_length,
1234						 ifd->length,
1235						 get_usb_statmsg(ifd->status));
1236					break;
1237				}
1238			}
1239			break;
1240		case -EPIPE:			/* stall - probably underrun */
1241			dev_err(cs->dev, "isoc write: stalled\n");
1242			error_hangup(bcs);
1243			break;
1244		default:			/* other errors */
1245			dev_warn(cs->dev, "isoc write: %s\n",
1246				 get_usb_statmsg(status));
1247		}
1248
1249		/* mark the write buffer area covered by this URB as free */
1250		if (done->limit >= 0)
1251			ubc->isooutbuf->read = done->limit;
1252
1253		/* mark URB as free */
1254		spin_lock_irqsave(&ubc->isooutlock, flags);
1255		next = ubc->isooutfree;
1256		ubc->isooutfree = done;
1257		spin_unlock_irqrestore(&ubc->isooutlock, flags);
1258		if (next) {
1259			/* only one URB still active - resubmit one */
1260			rc = submit_iso_write_urb(next);
1261			if (unlikely(rc <= 0 && rc != -ENODEV)) {
1262				/* couldn't submit */
1263				error_hangup(bcs);
1264			}
1265		}
1266	}
1267
1268	/* process queued SKBs */
1269	while ((skb = skb_dequeue(&bcs->squeue))) {
1270		/* copy to output buffer, doing L2 encapsulation */
1271		len = skb->len;
1272		if (gigaset_isoc_buildframe(bcs, skb->data, len) == -EAGAIN) {
1273			/* insufficient buffer space, push back onto queue */
1274			skb_queue_head(&bcs->squeue, skb);
1275			gig_dbg(DEBUG_ISO, "%s: skb requeued, qlen=%d",
1276				__func__, skb_queue_len(&bcs->squeue));
1277			break;
1278		}
1279		skb_pull(skb, len);
1280		gigaset_skb_sent(bcs, skb);
1281		dev_kfree_skb_any(skb);
1282	}
1283}
1284
1285/* Isochronous Read - Bottom Half */
1286/* ============================== */
1287
1288/* read_iso_tasklet
1289 * tasklet scheduled when an isochronous input URB from the Gigaset device
1290 * has completed
1291 * parameter:
1292 *	data	B channel state structure
1293 */
1294static void read_iso_tasklet(unsigned long data)
1295{
1296	struct bc_state *bcs = (struct bc_state *) data;
1297	struct bas_bc_state *ubc = bcs->hw.bas;
1298	struct cardstate *cs = bcs->cs;
1299	struct urb *urb;
1300	int status;
1301	struct usb_iso_packet_descriptor *ifd;
1302	char *rcvbuf;
1303	unsigned long flags;
1304	int totleft, numbytes, offset, frame, rc;
1305
1306	/* loop while more completed URBs arrive in the meantime */
1307	for (;;) {
1308		/* retrieve URB */
1309		spin_lock_irqsave(&ubc->isoinlock, flags);
1310		urb = ubc->isoindone;
1311		if (!urb) {
1312			spin_unlock_irqrestore(&ubc->isoinlock, flags);
1313			return;
1314		}
1315		status = ubc->isoinstatus;
1316		ubc->isoindone = NULL;
1317		if (unlikely(ubc->loststatus != -EINPROGRESS)) {
1318			dev_warn(cs->dev,
1319		"isoc read overrun, URB dropped (status: %s, %d bytes)\n",
1320				 get_usb_statmsg(ubc->loststatus),
1321				 ubc->isoinlost);
1322			ubc->loststatus = -EINPROGRESS;
1323		}
1324		spin_unlock_irqrestore(&ubc->isoinlock, flags);
1325
1326		if (unlikely(!(ubc->running))) {
1327			gig_dbg(DEBUG_ISO,
1328				"%s: channel not running, "
1329				"dropped URB with status: %s",
1330				__func__, get_usb_statmsg(status));
1331			return;
1332		}
1333
1334		switch (status) {
1335		case 0:				/* normal completion */
1336			break;
1337		case -EXDEV:			/* inspect individual frames
1338						   (we do that anyway) */
1339			gig_dbg(DEBUG_ISO, "%s: URB partially completed",
1340				__func__);
1341			break;
1342		case -ENOENT:
1343		case -ECONNRESET:
1344		case -EINPROGRESS:
1345			gig_dbg(DEBUG_ISO, "%s: %s",
1346				__func__, get_usb_statmsg(status));
1347			continue;		/* -> skip */
1348		case -EPIPE:
1349			dev_err(cs->dev, "isoc read: stalled\n");
1350			error_hangup(bcs);
1351			continue;		/* -> skip */
1352		default:			/* other error */
1353			dev_warn(cs->dev, "isoc read: %s\n",
1354				 get_usb_statmsg(status));
1355			goto error;
1356		}
1357
1358		rcvbuf = urb->transfer_buffer;
1359		totleft = urb->actual_length;
1360		for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) {
1361			ifd = &urb->iso_frame_desc[frame];
1362			numbytes = ifd->actual_length;
1363			switch (ifd->status) {
1364			case 0:			/* success */
1365				break;
1366			case -EPROTO:		/* protocol error or unplug */
1367			case -EILSEQ:
1368			case -ETIME:
1369				/* probably just disconnected, ignore */
1370				gig_dbg(DEBUG_ISO,
1371					"isoc read: frame %d[%d]: %s\n",
1372					frame, numbytes,
1373					get_usb_statmsg(ifd->status));
1374				break;
1375			default:		/* other error */
1376				/* report, assume transferred bytes are ok */
1377				dev_warn(cs->dev,
1378					 "isoc read: frame %d[%d]: %s\n",
1379					 frame, numbytes,
1380					 get_usb_statmsg(ifd->status));
1381			}
1382			if (unlikely(numbytes > BAS_MAXFRAME))
1383				dev_warn(cs->dev,
1384					 "isoc read: frame %d[%d]: %s\n",
1385					 frame, numbytes,
1386					 "exceeds max frame size");
1387			if (unlikely(numbytes > totleft)) {
1388				dev_warn(cs->dev,
1389					 "isoc read: frame %d[%d]: %s\n",
1390					 frame, numbytes,
1391					 "exceeds total transfer length");
1392				numbytes = totleft;
1393			}
1394			offset = ifd->offset;
1395			if (unlikely(offset + numbytes > BAS_INBUFSIZE)) {
1396				dev_warn(cs->dev,
1397					 "isoc read: frame %d[%d]: %s\n",
1398					 frame, numbytes,
1399					 "exceeds end of buffer");
1400				numbytes = BAS_INBUFSIZE - offset;
1401			}
1402			gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs);
1403			totleft -= numbytes;
1404		}
1405		if (unlikely(totleft > 0))
1406			dev_warn(cs->dev, "isoc read: %d data bytes missing\n",
1407				 totleft);
1408
1409error:
1410		/* URB processed, resubmit */
1411		for (frame = 0; frame < BAS_NUMFRAMES; frame++) {
1412			urb->iso_frame_desc[frame].status = 0;
1413			urb->iso_frame_desc[frame].actual_length = 0;
1414		}
1415		/* urb->dev is clobbered by USB subsystem */
1416		urb->dev = bcs->cs->hw.bas->udev;
1417		urb->transfer_flags = URB_ISO_ASAP;
1418		urb->number_of_packets = BAS_NUMFRAMES;
1419		rc = usb_submit_urb(urb, GFP_ATOMIC);
1420		if (unlikely(rc != 0 && rc != -ENODEV)) {
1421			dev_err(cs->dev,
1422				"could not resubmit isoc read URB: %s\n",
1423				get_usb_rcmsg(rc));
1424			dump_urb(DEBUG_ISO, "resubmit isoc read", urb);
1425			error_hangup(bcs);
1426		}
1427	}
1428}
1429
1430/* Channel Operations */
1431/* ================== */
1432
1433/* req_timeout
1434 * timeout routine for control output request
1435 * argument:
1436 *	controller state structure
1437 */
1438static void req_timeout(unsigned long data)
1439{
1440	struct cardstate *cs = (struct cardstate *) data;
1441	struct bas_cardstate *ucs = cs->hw.bas;
1442	int pending;
1443	unsigned long flags;
1444
1445	check_pending(ucs);
1446
1447	spin_lock_irqsave(&ucs->lock, flags);
1448	pending = ucs->pending;
1449	ucs->pending = 0;
1450	spin_unlock_irqrestore(&ucs->lock, flags);
1451
1452	switch (pending) {
1453	case 0:					/* no pending request */
1454		gig_dbg(DEBUG_USBREQ, "%s: no request pending", __func__);
1455		break;
1456
1457	case HD_OPEN_ATCHANNEL:
1458		dev_err(cs->dev, "timeout opening AT channel\n");
1459		error_reset(cs);
1460		break;
1461
1462	case HD_OPEN_B1CHANNEL:
1463		dev_err(cs->dev, "timeout opening channel 1\n");
1464		error_hangup(&cs->bcs[0]);
1465		break;
1466
1467	case HD_OPEN_B2CHANNEL:
1468		dev_err(cs->dev, "timeout opening channel 2\n");
1469		error_hangup(&cs->bcs[1]);
1470		break;
1471
1472	case HD_CLOSE_ATCHANNEL:
1473		dev_err(cs->dev, "timeout closing AT channel\n");
1474		error_reset(cs);
1475		break;
1476
1477	case HD_CLOSE_B1CHANNEL:
1478		dev_err(cs->dev, "timeout closing channel 1\n");
1479		error_reset(cs);
1480		break;
1481
1482	case HD_CLOSE_B2CHANNEL:
1483		dev_err(cs->dev, "timeout closing channel 2\n");
1484		error_reset(cs);
1485		break;
1486
1487	case HD_RESET_INTERRUPT_PIPE:
1488		/* error recovery escalation */
1489		dev_err(cs->dev,
1490			"reset interrupt pipe timeout, attempting USB reset\n");
1491		usb_queue_reset_device(ucs->interface);
1492		break;
1493
1494	default:
1495		dev_warn(cs->dev, "request 0x%02x timed out, clearing\n",
1496			 pending);
1497	}
1498
1499	wake_up(&ucs->waitqueue);
1500}
1501
1502/* write_ctrl_callback
1503 * USB completion handler for control pipe output
1504 * called by the USB subsystem in interrupt context
1505 * parameter:
1506 *	urb	USB request block of completed request
1507 *		urb->context = hardware specific controller state structure
1508 */
1509static void write_ctrl_callback(struct urb *urb)
1510{
1511	struct bas_cardstate *ucs = urb->context;
1512	int status = urb->status;
1513	int rc;
1514	unsigned long flags;
1515
1516	/* check status */
1517	switch (status) {
1518	case 0:					/* normal completion */
1519		spin_lock_irqsave(&ucs->lock, flags);
1520		switch (ucs->pending) {
1521		case HD_DEVICE_INIT_ACK:	/* no reply expected */
1522			del_timer(&ucs->timer_ctrl);
1523			ucs->pending = 0;
1524			break;
1525		}
1526		spin_unlock_irqrestore(&ucs->lock, flags);
1527		return;
1528
1529	case -ENOENT:			/* cancelled */
1530	case -ECONNRESET:		/* cancelled (async) */
1531	case -EINPROGRESS:		/* pending */
1532	case -ENODEV:			/* device removed */
1533	case -ESHUTDOWN:		/* device shut down */
1534		/* ignore silently */
1535		gig_dbg(DEBUG_USBREQ, "%s: %s",
1536			__func__, get_usb_statmsg(status));
1537		break;
1538
1539	default:				/* any failure */
1540		/* don't retry if suspend requested */
1541		if (++ucs->retry_ctrl > BAS_RETRY ||
1542		    (ucs->basstate & BS_SUSPEND)) {
1543			dev_err(&ucs->interface->dev,
1544				"control request 0x%02x failed: %s\n",
1545				ucs->dr_ctrl.bRequest,
1546				get_usb_statmsg(status));
1547			break;		/* give up */
1548		}
1549		dev_notice(&ucs->interface->dev,
1550			   "control request 0x%02x: %s, retry %d\n",
1551			   ucs->dr_ctrl.bRequest, get_usb_statmsg(status),
1552			   ucs->retry_ctrl);
1553		/* urb->dev is clobbered by USB subsystem */
1554		urb->dev = ucs->udev;
1555		rc = usb_submit_urb(urb, GFP_ATOMIC);
1556		if (unlikely(rc)) {
1557			dev_err(&ucs->interface->dev,
1558				"could not resubmit request 0x%02x: %s\n",
1559				ucs->dr_ctrl.bRequest, get_usb_rcmsg(rc));
1560			break;
1561		}
1562		/* resubmitted */
1563		return;
1564	}
1565
1566	/* failed, clear pending request */
1567	spin_lock_irqsave(&ucs->lock, flags);
1568	del_timer(&ucs->timer_ctrl);
1569	ucs->pending = 0;
1570	spin_unlock_irqrestore(&ucs->lock, flags);
1571	wake_up(&ucs->waitqueue);
1572}
1573
1574/* req_submit
1575 * submit a control output request without message buffer to the Gigaset base
1576 * and optionally start a timeout
1577 * parameters:
1578 *	bcs	B channel control structure
1579 *	req	control request code (HD_*)
1580 *	val	control request parameter value (set to 0 if unused)
1581 *	timeout	timeout in seconds (0: no timeout)
1582 * return value:
1583 *	0 on success
1584 *	-EBUSY if another request is pending
1585 *	any URB submission error code
1586 */
1587static int req_submit(struct bc_state *bcs, int req, int val, int timeout)
1588{
1589	struct bas_cardstate *ucs = bcs->cs->hw.bas;
1590	int ret;
1591	unsigned long flags;
1592
1593	gig_dbg(DEBUG_USBREQ, "-------> 0x%02x (%d)", req, val);
1594
1595	spin_lock_irqsave(&ucs->lock, flags);
1596	if (ucs->pending) {
1597		spin_unlock_irqrestore(&ucs->lock, flags);
1598		dev_err(bcs->cs->dev,
1599			"submission of request 0x%02x failed: "
1600			"request 0x%02x still pending\n",
1601			req, ucs->pending);
1602		return -EBUSY;
1603	}
1604
1605	ucs->dr_ctrl.bRequestType = OUT_VENDOR_REQ;
1606	ucs->dr_ctrl.bRequest = req;
1607	ucs->dr_ctrl.wValue = cpu_to_le16(val);
1608	ucs->dr_ctrl.wIndex = 0;
1609	ucs->dr_ctrl.wLength = 0;
1610	usb_fill_control_urb(ucs->urb_ctrl, ucs->udev,
1611			     usb_sndctrlpipe(ucs->udev, 0),
1612			     (unsigned char *) &ucs->dr_ctrl, NULL, 0,
1613			     write_ctrl_callback, ucs);
1614	ucs->retry_ctrl = 0;
1615	ret = usb_submit_urb(ucs->urb_ctrl, GFP_ATOMIC);
1616	if (unlikely(ret)) {
1617		dev_err(bcs->cs->dev, "could not submit request 0x%02x: %s\n",
1618			req, get_usb_rcmsg(ret));
1619		spin_unlock_irqrestore(&ucs->lock, flags);
1620		return ret;
1621	}
1622	ucs->pending = req;
1623
1624	if (timeout > 0) {
1625		gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
1626		mod_timer(&ucs->timer_ctrl, jiffies + timeout * HZ / 10);
1627	}
1628
1629	spin_unlock_irqrestore(&ucs->lock, flags);
1630	return 0;
1631}
1632
1633/* gigaset_init_bchannel
1634 * called by common.c to connect a B channel
1635 * initialize isochronous I/O and tell the Gigaset base to open the channel
1636 * argument:
1637 *	B channel control structure
1638 * return value:
1639 *	0 on success, error code < 0 on error
1640 */
1641static int gigaset_init_bchannel(struct bc_state *bcs)
1642{
1643	struct cardstate *cs = bcs->cs;
1644	int req, ret;
1645	unsigned long flags;
1646
1647	spin_lock_irqsave(&cs->lock, flags);
1648	if (unlikely(!cs->connected)) {
1649		gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
1650		spin_unlock_irqrestore(&cs->lock, flags);
1651		return -ENODEV;
1652	}
1653
1654	if (cs->hw.bas->basstate & BS_SUSPEND) {
1655		dev_notice(cs->dev,
1656			   "not starting isoc I/O, suspend in progress\n");
1657		spin_unlock_irqrestore(&cs->lock, flags);
1658		return -EHOSTUNREACH;
1659	}
1660
1661	ret = starturbs(bcs);
1662	if (ret < 0) {
1663		spin_unlock_irqrestore(&cs->lock, flags);
1664		dev_err(cs->dev,
1665			"could not start isoc I/O for channel B%d: %s\n",
1666			bcs->channel + 1,
1667			ret == -EFAULT ? "null URB" : get_usb_rcmsg(ret));
1668		if (ret != -ENODEV)
1669			error_hangup(bcs);
1670		return ret;
1671	}
1672
1673	req = bcs->channel ? HD_OPEN_B2CHANNEL : HD_OPEN_B1CHANNEL;
1674	ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
1675	if (ret < 0) {
1676		dev_err(cs->dev, "could not open channel B%d\n",
1677			bcs->channel + 1);
1678		stopurbs(bcs->hw.bas);
1679	}
1680
1681	spin_unlock_irqrestore(&cs->lock, flags);
1682	if (ret < 0 && ret != -ENODEV)
1683		error_hangup(bcs);
1684	return ret;
1685}
1686
1687/* gigaset_close_bchannel
1688 * called by common.c to disconnect a B channel
1689 * tell the Gigaset base to close the channel
1690 * stopping isochronous I/O and LL notification will be done when the
1691 * acknowledgement for the close arrives
1692 * argument:
1693 *	B channel control structure
1694 * return value:
1695 *	0 on success, error code < 0 on error
1696 */
1697static int gigaset_close_bchannel(struct bc_state *bcs)
1698{
1699	struct cardstate *cs = bcs->cs;
1700	int req, ret;
1701	unsigned long flags;
1702
1703	spin_lock_irqsave(&cs->lock, flags);
1704	if (unlikely(!cs->connected)) {
1705		spin_unlock_irqrestore(&cs->lock, flags);
1706		gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
1707		return -ENODEV;
1708	}
1709
1710	if (!(cs->hw.bas->basstate & (bcs->channel ? BS_B2OPEN : BS_B1OPEN))) {
1711		/* channel not running: just signal common.c */
1712		spin_unlock_irqrestore(&cs->lock, flags);
1713		gigaset_bchannel_down(bcs);
1714		return 0;
1715	}
1716
1717	/* channel running: tell device to close it */
1718	req = bcs->channel ? HD_CLOSE_B2CHANNEL : HD_CLOSE_B1CHANNEL;
1719	ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
1720	if (ret < 0)
1721		dev_err(cs->dev, "closing channel B%d failed\n",
1722			bcs->channel + 1);
1723
1724	spin_unlock_irqrestore(&cs->lock, flags);
1725	return ret;
1726}
1727
1728/* Device Operations */
1729/* ================= */
1730
1731/* complete_cb
1732 * unqueue first command buffer from queue, waking any sleepers
1733 * must be called with cs->cmdlock held
1734 * parameter:
1735 *	cs	controller state structure
1736 */
1737static void complete_cb(struct cardstate *cs)
1738{
1739	struct cmdbuf_t *cb = cs->cmdbuf;
1740
1741	/* unqueue completed buffer */
1742	cs->cmdbytes -= cs->curlen;
1743	gig_dbg(DEBUG_OUTPUT, "write_command: sent %u bytes, %u left",
1744		cs->curlen, cs->cmdbytes);
1745	if (cb->next != NULL) {
1746		cs->cmdbuf = cb->next;
1747		cs->cmdbuf->prev = NULL;
1748		cs->curlen = cs->cmdbuf->len;
1749	} else {
1750		cs->cmdbuf = NULL;
1751		cs->lastcmdbuf = NULL;
1752		cs->curlen = 0;
1753	}
1754
1755	if (cb->wake_tasklet)
1756		tasklet_schedule(cb->wake_tasklet);
1757
1758	kfree(cb);
1759}
1760
1761/* write_command_callback
1762 * USB completion handler for AT command transmission
1763 * called by the USB subsystem in interrupt context
1764 * parameter:
1765 *	urb	USB request block of completed request
1766 *		urb->context = controller state structure
1767 */
1768static void write_command_callback(struct urb *urb)
1769{
1770	struct cardstate *cs = urb->context;
1771	struct bas_cardstate *ucs = cs->hw.bas;
1772	int status = urb->status;
1773	unsigned long flags;
1774
1775	update_basstate(ucs, 0, BS_ATWRPEND);
1776	wake_up(&ucs->waitqueue);
1777
1778	/* check status */
1779	switch (status) {
1780	case 0:					/* normal completion */
1781		break;
1782	case -ENOENT:			/* cancelled */
1783	case -ECONNRESET:		/* cancelled (async) */
1784	case -EINPROGRESS:		/* pending */
1785	case -ENODEV:			/* device removed */
1786	case -ESHUTDOWN:		/* device shut down */
1787		/* ignore silently */
1788		gig_dbg(DEBUG_USBREQ, "%s: %s",
1789			__func__, get_usb_statmsg(status));
1790		return;
1791	default:				/* any failure */
1792		if (++ucs->retry_cmd_out > BAS_RETRY) {
1793			dev_warn(cs->dev,
1794				 "command write: %s, "
1795				 "giving up after %d retries\n",
1796				 get_usb_statmsg(status),
1797				 ucs->retry_cmd_out);
1798			break;
1799		}
1800		if (ucs->basstate & BS_SUSPEND) {
1801			dev_warn(cs->dev,
1802				 "command write: %s, "
1803				 "won't retry - suspend requested\n",
1804				 get_usb_statmsg(status));
1805			break;
1806		}
1807		if (cs->cmdbuf == NULL) {
1808			dev_warn(cs->dev,
1809				 "command write: %s, "
1810				 "cannot retry - cmdbuf gone\n",
1811				 get_usb_statmsg(status));
1812			break;
1813		}
1814		dev_notice(cs->dev, "command write: %s, retry %d\n",
1815			   get_usb_statmsg(status), ucs->retry_cmd_out);
1816		if (atwrite_submit(cs, cs->cmdbuf->buf, cs->cmdbuf->len) >= 0)
1817			/* resubmitted - bypass regular exit block */
1818			return;
1819		/* command send failed, assume base still waiting */
1820	

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