bas-gigaset.c 67.5 KB
Newer Older
1 2 3 4 5
/*
 * USB driver for Gigaset 307x base via direct USB connection.
 *
 * Copyright (c) 2001 by Hansjoerg Lipp <hjlipp@web.de>,
 *                       Tilman Schmidt <tilman@imap.cc>,
6
 *                       Stefan Eilers.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * =====================================================================
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License as
 *	published by the Free Software Foundation; either version 2 of
 *	the License, or (at your option) any later version.
 * =====================================================================
 */

#include "gigaset.h"
#include <linux/usb.h>
#include <linux/module.h>
#include <linux/moduleparam.h>

/* Version Information */
22
#define DRIVER_AUTHOR "Tilman Schmidt <tilman@imap.cc>, Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers"
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
#define DRIVER_DESC "USB Driver for Gigaset 307x"


/* Module parameters */

static int startmode = SM_ISDN;
static int cidmode = 1;

module_param(startmode, int, S_IRUGO);
module_param(cidmode, int, S_IRUGO);
MODULE_PARM_DESC(startmode, "start in isdn4linux mode");
MODULE_PARM_DESC(cidmode, "Call-ID mode");

#define GIGASET_MINORS     1
#define GIGASET_MINOR      16
#define GIGASET_MODULENAME "bas_gigaset"
#define GIGASET_DEVNAME    "ttyGB"

41 42
/* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
#define IF_WRITEBUF 264
43

44 45 46
/* interrupt pipe message size according to ibid. ch. 2.2 */
#define IP_MSGSIZE 3

47 48
/* Values for the Gigaset 307x */
#define USB_GIGA_VENDOR_ID      0x0681
49 50
#define USB_3070_PRODUCT_ID     0x0001
#define USB_3075_PRODUCT_ID     0x0002
51 52 53 54
#define USB_SX303_PRODUCT_ID    0x0021
#define USB_SX353_PRODUCT_ID    0x0022

/* table of devices that work with this driver */
T
Tilman Schmidt 已提交
55
static const struct usb_device_id gigaset_table[] = {
56 57
	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3070_PRODUCT_ID) },
	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3075_PRODUCT_ID) },
58 59 60 61 62 63 64
	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_SX303_PRODUCT_ID) },
	{ USB_DEVICE(USB_GIGA_VENDOR_ID, USB_SX353_PRODUCT_ID) },
	{ } /* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, gigaset_table);

65
/*======================= local function prototypes ==========================*/
66

67
/* function called if a new device belonging to this driver is connected */
68 69 70 71 72 73
static int gigaset_probe(struct usb_interface *interface,
			 const struct usb_device_id *id);

/* Function will be called if the device is unplugged */
static void gigaset_disconnect(struct usb_interface *interface);

T
Tilman Schmidt 已提交
74 75 76 77 78 79 80 81
/* functions called before/after suspend */
static int gigaset_suspend(struct usb_interface *intf, pm_message_t message);
static int gigaset_resume(struct usb_interface *intf);

/* functions called before/after device reset */
static int gigaset_pre_reset(struct usb_interface *intf);
static int gigaset_post_reset(struct usb_interface *intf);

82
static int atread_submit(struct cardstate *, int);
83
static void stopurbs(struct bas_bc_state *);
84
static int req_submit(struct bc_state *, int, int, int);
85 86
static int atwrite_submit(struct cardstate *, unsigned char *, int);
static int start_cbsend(struct cardstate *);
87

88
/*============================================================================*/
89 90

struct bas_cardstate {
91 92
	struct usb_device	*udev;		/* USB device pointer */
	struct usb_interface	*interface;	/* interface for this device */
93 94
	unsigned char		minor;		/* starting minor number */

95
	struct urb		*urb_ctrl;	/* control pipe default URB */
96 97
	struct usb_ctrlrequest	dr_ctrl;
	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 103 104
	struct usb_ctrlrequest	dr_cmd_out;
	int			retry_cmd_out;

105
	struct urb		*urb_cmd_in;	/* for receiving AT replies */
106 107
	struct usb_ctrlrequest	dr_cmd_in;
	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 113

	spinlock_t		lock;		/* locks all following */
T
Tilman Schmidt 已提交
114
	int			basstate;	/* bitmap (BS_*) */
115
	int			pending;	/* uncompleted base request */
T
Tilman Schmidt 已提交
116
	wait_queue_head_t	waitqueue;
117 118 119 120 121 122
	int			rcvbuf_size;	/* size of AT receive buffer */
						/* 0: no receive in progress */
	int			retry_cmd_in;	/* receive req retry count */
};

/* status of direct USB connection to 307x base (bits in basstate) */
123 124 125 126 127 128 129 130
#define BS_ATOPEN	0x001	/* AT channel open */
#define BS_B1OPEN	0x002	/* B channel 1 open */
#define BS_B2OPEN	0x004	/* B channel 2 open */
#define BS_ATREADY	0x008	/* base ready for AT command */
#define BS_INIT		0x010	/* base has signalled INIT_OK */
#define BS_ATTIMER	0x020	/* waiting for HD_READY_SEND_ATDATA */
#define BS_ATRDPEND	0x040	/* urb_cmd_in in use */
#define BS_ATWRPEND	0x080	/* urb_cmd_out in use */
T
Tilman Schmidt 已提交
131
#define BS_SUSPEND	0x100	/* USB port suspended */
T
Tilman Schmidt 已提交
132
#define BS_RESETTING	0x200	/* waiting for HD_RESET_INTERRUPT_PIPE_ACK */
133 134


T
Tilman Schmidt 已提交
135
static struct gigaset_driver *driver;
136 137 138 139 140 141 142

/* usb specific object needed to register this driver with the usb subsystem */
static struct usb_driver gigaset_usb_driver = {
	.name =         GIGASET_MODULENAME,
	.probe =        gigaset_probe,
	.disconnect =   gigaset_disconnect,
	.id_table =     gigaset_table,
T
Tilman Schmidt 已提交
143 144 145 146 147
	.suspend =	gigaset_suspend,
	.resume =	gigaset_resume,
	.reset_resume =	gigaset_post_reset,
	.pre_reset =	gigaset_pre_reset,
	.post_reset =	gigaset_post_reset,
148 149
};

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
/* get message text for usb_submit_urb return code
 */
static char *get_usb_rcmsg(int rc)
{
	static char unkmsg[28];

	switch (rc) {
	case 0:
		return "success";
	case -ENOMEM:
		return "out of memory";
	case -ENODEV:
		return "device not present";
	case -ENOENT:
		return "endpoint not present";
	case -ENXIO:
		return "URB type not supported";
	case -EINVAL:
		return "invalid argument";
	case -EAGAIN:
		return "start frame too early or too much scheduled";
	case -EFBIG:
		return "too many isochronous frames requested";
	case -EPIPE:
		return "endpoint stalled";
	case -EMSGSIZE:
		return "invalid packet size";
	case -ENOSPC:
		return "would overcommit USB bandwidth";
	case -ESHUTDOWN:
		return "device shut down";
	case -EPERM:
		return "reject flag set";
	case -EHOSTUNREACH:
		return "device suspended";
	default:
		snprintf(unkmsg, sizeof(unkmsg), "unknown error %d", rc);
		return unkmsg;
	}
}

191 192 193 194 195 196 197 198 199 200
/* get message text for USB status code
 */
static char *get_usb_statmsg(int status)
{
	static char unkmsg[28];

	switch (status) {
	case 0:
		return "success";
	case -ENOENT:
201
		return "unlinked (sync)";
202 203 204
	case -EINPROGRESS:
		return "pending";
	case -EPROTO:
205
		return "bit stuffing error, timeout, or unknown USB error";
206
	case -EILSEQ:
207
		return "CRC mismatch, timeout, or unknown USB error";
208
	case -ETIME:
209
		return "timed out";
210 211 212 213 214 215 216 217
	case -EPIPE:
		return "endpoint stalled";
	case -ECOMM:
		return "IN buffer overrun";
	case -ENOSR:
		return "OUT buffer underrun";
	case -EOVERFLOW:
		return "too much data";
218 219
	case -EREMOTEIO:
		return "short packet detected";
220 221
	case -ENODEV:
		return "device removed";
222 223 224 225
	case -EXDEV:
		return "partial isochronous transfer";
	case -EINVAL:
		return "invalid argument";
226 227
	case -ECONNRESET:
		return "unlinked (async)";
228
	case -ESHUTDOWN:
229
		return "device shut down";
230
	default:
231
		snprintf(unkmsg, sizeof(unkmsg), "unknown status %d", status);
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
		return unkmsg;
	}
}

/* usb_pipetype_str
 * retrieve string representation of USB pipe type
 */
static inline char *usb_pipetype_str(int pipe)
{
	if (usb_pipeisoc(pipe))
		return "Isoc";
	if (usb_pipeint(pipe))
		return "Int";
	if (usb_pipecontrol(pipe))
		return "Ctrl";
	if (usb_pipebulk(pipe))
		return "Bulk";
	return "?";
}

/* dump_urb
 * write content of URB to syslog for debugging
 */
static inline void dump_urb(enum debuglevel level, const char *tag,
256
			    struct urb *urb)
257 258 259
{
#ifdef CONFIG_GIGASET_DEBUG
	int i;
260
	gig_dbg(level, "%s urb(0x%08lx)->{", tag, (unsigned long) urb);
261
	if (urb) {
262 263
		gig_dbg(level,
			"  dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, "
264
			"hcpriv=0x%08lx, transfer_flags=0x%x,",
265 266 267 268
			(unsigned long) urb->dev,
			usb_pipetype_str(urb->pipe),
			usb_pipeendpoint(urb->pipe), usb_pipedevice(urb->pipe),
			usb_pipein(urb->pipe) ? "in" : "out",
269
			(unsigned long) urb->hcpriv,
270 271 272
			urb->transfer_flags);
		gig_dbg(level,
			"  transfer_buffer=0x%08lx[%d], actual_length=%d, "
273
			"setup_packet=0x%08lx,",
274 275
			(unsigned long) urb->transfer_buffer,
			urb->transfer_buffer_length, urb->actual_length,
276
			(unsigned long) urb->setup_packet);
277 278 279 280 281 282 283 284 285 286
		gig_dbg(level,
			"  start_frame=%d, number_of_packets=%d, interval=%d, "
			"error_count=%d,",
			urb->start_frame, urb->number_of_packets, urb->interval,
			urb->error_count);
		gig_dbg(level,
			"  context=0x%08lx, complete=0x%08lx, "
			"iso_frame_desc[]={",
			(unsigned long) urb->context,
			(unsigned long) urb->complete);
287
		for (i = 0; i < urb->number_of_packets; i++) {
288 289
			struct usb_iso_packet_descriptor *pifd
				= &urb->iso_frame_desc[i];
290 291 292 293 294
			gig_dbg(level,
				"    {offset=%u, length=%u, actual_length=%u, "
				"status=%u}",
				pifd->offset, pifd->length, pifd->actual_length,
				pifd->status);
295 296
		}
	}
297
	gig_dbg(level, "}}");
298 299 300 301 302
#endif
}

/* read/set modem control bits etc. (m10x only) */
static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
303
				  unsigned new_state)
304 305 306 307 308 309 310 311 312 313 314 315 316 317
{
	return -EINVAL;
}

static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
{
	return -EINVAL;
}

static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
{
	return -EINVAL;
}

T
Tilman Schmidt 已提交
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
/* set/clear bits in base connection state, return previous state
 */
static inline int update_basstate(struct bas_cardstate *ucs,
				  int set, int clear)
{
	unsigned long flags;
	int state;

	spin_lock_irqsave(&ucs->lock, flags);
	state = ucs->basstate;
	ucs->basstate = (state & ~clear) | set;
	spin_unlock_irqrestore(&ucs->lock, flags);
	return state;
}

333 334 335 336
/* error_hangup
 * hang up any existing connection because of an unrecoverable error
 * This function may be called from any context and takes care of scheduling
 * the necessary actions for execution outside of interrupt context.
337
 * cs->lock must not be held.
338 339 340 341 342 343 344
 * argument:
 *	B channel control structure
 */
static inline void error_hangup(struct bc_state *bcs)
{
	struct cardstate *cs = bcs->cs;

T
Tilman Schmidt 已提交
345
	gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL);
346 347 348 349 350
	gigaset_schedule_event(cs);
}

/* error_reset
 * reset Gigaset device because of an unrecoverable error
351
 * This function may be called from any context, and takes care of
352
 * scheduling the necessary actions for execution outside of interrupt context.
353
 * cs->hw.bas->lock must not be held.
354 355 356 357 358
 * argument:
 *	controller state structure
 */
static inline void error_reset(struct cardstate *cs)
{
T
Tilman Schmidt 已提交
359 360
	/* reset interrupt pipe to recover (ignore errors) */
	update_basstate(cs->hw.bas, BS_RESETTING, 0);
361 362 363
	if (req_submit(cs->bcs, HD_RESET_INTERRUPT_PIPE, 0, BAS_TIMEOUT))
		/* submission failed, escalate to USB port reset */
		usb_queue_reset_device(cs->hw.bas->interface);
364 365 366 367 368
}

/* check_pending
 * check for completion of pending control request
 * parameter:
369
 *	ucs	hardware specific controller state structure
370 371 372 373 374 375 376 377 378 379
 */
static void check_pending(struct bas_cardstate *ucs)
{
	unsigned long flags;

	spin_lock_irqsave(&ucs->lock, flags);
	switch (ucs->pending) {
	case 0:
		break;
	case HD_OPEN_ATCHANNEL:
T
Tilman Schmidt 已提交
380
		if (ucs->basstate & BS_ATOPEN)
381 382 383
			ucs->pending = 0;
		break;
	case HD_OPEN_B1CHANNEL:
T
Tilman Schmidt 已提交
384
		if (ucs->basstate & BS_B1OPEN)
385 386 387
			ucs->pending = 0;
		break;
	case HD_OPEN_B2CHANNEL:
T
Tilman Schmidt 已提交
388
		if (ucs->basstate & BS_B2OPEN)
389 390 391
			ucs->pending = 0;
		break;
	case HD_CLOSE_ATCHANNEL:
T
Tilman Schmidt 已提交
392
		if (!(ucs->basstate & BS_ATOPEN))
393 394 395
			ucs->pending = 0;
		break;
	case HD_CLOSE_B1CHANNEL:
T
Tilman Schmidt 已提交
396
		if (!(ucs->basstate & BS_B1OPEN))
397 398 399
			ucs->pending = 0;
		break;
	case HD_CLOSE_B2CHANNEL:
T
Tilman Schmidt 已提交
400
		if (!(ucs->basstate & BS_B2OPEN))
401 402 403 404 405
			ucs->pending = 0;
		break;
	case HD_DEVICE_INIT_ACK:		/* no reply expected */
		ucs->pending = 0;
		break;
T
Tilman Schmidt 已提交
406 407 408 409 410 411 412
	case HD_RESET_INTERRUPT_PIPE:
		if (!(ucs->basstate & BS_RESETTING))
			ucs->pending = 0;
		break;
	/*
	 * HD_READ_ATMESSAGE and HD_WRITE_ATMESSAGE are handled separately
	 * and should never end up here
413 414
	 */
	default:
415 416 417
		dev_warn(&ucs->interface->dev,
			 "unknown pending request 0x%02x cleared\n",
			 ucs->pending);
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
		ucs->pending = 0;
	}

	if (!ucs->pending)
		del_timer(&ucs->timer_ctrl);

	spin_unlock_irqrestore(&ucs->lock, flags);
}

/* cmd_in_timeout
 * timeout routine for command input request
 * argument:
 *	controller state structure
 */
static void cmd_in_timeout(unsigned long data)
{
	struct cardstate *cs = (struct cardstate *) data;
435
	struct bas_cardstate *ucs = cs->hw.bas;
436
	int rc;
437 438

	if (!ucs->rcvbuf_size) {
439
		gig_dbg(DEBUG_USBREQ, "%s: no receive in progress", __func__);
440 441 442
		return;
	}

443
	if (ucs->retry_cmd_in++ >= BAS_RETRY) {
444 445 446
		dev_err(cs->dev,
			"control read: timeout, giving up after %d tries\n",
			ucs->retry_cmd_in);
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
		kfree(ucs->rcvbuf);
		ucs->rcvbuf = NULL;
		ucs->rcvbuf_size = 0;
		error_reset(cs);
		return;
	}

	gig_dbg(DEBUG_USBREQ, "%s: timeout, retry %d",
		__func__, ucs->retry_cmd_in);
	rc = atread_submit(cs, BAS_TIMEOUT);
	if (rc < 0) {
		kfree(ucs->rcvbuf);
		ucs->rcvbuf = NULL;
		ucs->rcvbuf_size = 0;
		if (rc != -ENODEV)
			error_reset(cs);
463
	}
464 465
}

466 467 468 469 470 471 472
/* read_ctrl_callback
 * USB completion handler for control pipe input
 * called by the USB subsystem in interrupt context
 * parameter:
 *	urb	USB request block
 *		urb->context = inbuf structure for controller state
 */
473
static void read_ctrl_callback(struct urb *urb)
474 475 476 477
{
	struct inbuf_t *inbuf = urb->context;
	struct cardstate *cs = inbuf->cs;
	struct bas_cardstate *ucs = cs->hw.bas;
478
	int status = urb->status;
479 480 481 482
	unsigned numbytes;
	int rc;

	update_basstate(ucs, 0, BS_ATRDPEND);
T
Tilman Schmidt 已提交
483
	wake_up(&ucs->waitqueue);
484 485
	del_timer(&ucs->timer_cmd_in);

486
	switch (status) {
487 488 489 490 491 492 493 494 495 496
	case 0:				/* normal completion */
		numbytes = urb->actual_length;
		if (unlikely(numbytes != ucs->rcvbuf_size)) {
			dev_warn(cs->dev,
			       "control read: received %d chars, expected %d\n",
				 numbytes, ucs->rcvbuf_size);
			if (numbytes > ucs->rcvbuf_size)
				numbytes = ucs->rcvbuf_size;
		}

497 498 499 500
		/* copy received bytes to inbuf, notify event layer */
		if (gigaset_fill_inbuf(inbuf, ucs->rcvbuf, numbytes)) {
			gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
			gigaset_schedule_event(cs);
501 502 503 504 505 506 507 508
		}
		break;

	case -ENOENT:			/* cancelled */
	case -ECONNRESET:		/* cancelled (async) */
	case -EINPROGRESS:		/* pending */
	case -ENODEV:			/* device removed */
	case -ESHUTDOWN:		/* device shut down */
509
		/* no further action necessary */
510
		gig_dbg(DEBUG_USBREQ, "%s: %s",
511
			__func__, get_usb_statmsg(status));
512 513
		break;

514
	default:			/* other errors: retry */
515
		if (ucs->retry_cmd_in++ < BAS_RETRY) {
516 517
			gig_dbg(DEBUG_USBREQ, "%s: %s, retry %d", __func__,
				get_usb_statmsg(status), ucs->retry_cmd_in);
518
			rc = atread_submit(cs, BAS_TIMEOUT);
519 520
			if (rc >= 0)
				/* successfully resubmitted, skip freeing */
521
				return;
522 523 524
			if (rc == -ENODEV)
				/* disconnect, no further action necessary */
				break;
525
		}
526 527
		dev_err(cs->dev, "control read: %s, giving up after %d tries\n",
			get_usb_statmsg(status), ucs->retry_cmd_in);
528 529 530
		error_reset(cs);
	}

531
	/* read finished, free buffer */
532 533 534 535 536
	kfree(ucs->rcvbuf);
	ucs->rcvbuf = NULL;
	ucs->rcvbuf_size = 0;
}

537
/* atread_submit
538
 * submit an HD_READ_ATMESSAGE command URB and optionally start a timeout
539 540 541 542 543 544 545 546 547 548
 * parameters:
 *	cs	controller state structure
 *	timeout	timeout in 1/10 sec., 0: none
 * return value:
 *	0 on success
 *	-EBUSY if another request is pending
 *	any URB submission error code
 */
static int atread_submit(struct cardstate *cs, int timeout)
{
549
	struct bas_cardstate *ucs = cs->hw.bas;
T
Tilman Schmidt 已提交
550
	int basstate;
551 552
	int ret;

553 554
	gig_dbg(DEBUG_USBREQ, "-------> HD_READ_ATMESSAGE (%d)",
		ucs->rcvbuf_size);
555

T
Tilman Schmidt 已提交
556 557
	basstate = update_basstate(ucs, BS_ATRDPEND, 0);
	if (basstate & BS_ATRDPEND) {
558 559
		dev_err(cs->dev,
			"could not submit HD_READ_ATMESSAGE: URB busy\n");
560 561 562
		return -EBUSY;
	}

T
Tilman Schmidt 已提交
563 564 565 566 567 568 569 570 571
	if (basstate & BS_SUSPEND) {
		dev_notice(cs->dev,
			   "HD_READ_ATMESSAGE not submitted, "
			   "suspend in progress\n");
		update_basstate(ucs, 0, BS_ATRDPEND);
		/* treat like disconnect */
		return -ENODEV;
	}

572 573 574 575 576 577
	ucs->dr_cmd_in.bRequestType = IN_VENDOR_REQ;
	ucs->dr_cmd_in.bRequest = HD_READ_ATMESSAGE;
	ucs->dr_cmd_in.wValue = 0;
	ucs->dr_cmd_in.wIndex = 0;
	ucs->dr_cmd_in.wLength = cpu_to_le16(ucs->rcvbuf_size);
	usb_fill_control_urb(ucs->urb_cmd_in, ucs->udev,
578
			     usb_rcvctrlpipe(ucs->udev, 0),
T
Tilman Schmidt 已提交
579
			     (unsigned char *) &ucs->dr_cmd_in,
580 581
			     ucs->rcvbuf, ucs->rcvbuf_size,
			     read_ctrl_callback, cs->inbuf);
582

T
Tilman Schmidt 已提交
583 584
	ret = usb_submit_urb(ucs->urb_cmd_in, GFP_ATOMIC);
	if (ret != 0) {
585
		update_basstate(ucs, 0, BS_ATRDPEND);
586
		dev_err(cs->dev, "could not submit HD_READ_ATMESSAGE: %s\n",
587
			get_usb_rcmsg(ret));
588 589 590 591
		return ret;
	}

	if (timeout > 0) {
592
		gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
593
		mod_timer(&ucs->timer_cmd_in, jiffies + timeout * HZ / 10);
594 595 596 597 598 599 600 601 602 603 604
	}
	return 0;
}

/* read_int_callback
 * USB completion handler for interrupt pipe input
 * called by the USB subsystem in interrupt context
 * parameter:
 *	urb	USB request block
 *		urb->context = controller state structure
 */
605
static void read_int_callback(struct urb *urb)
606
{
607 608
	struct cardstate *cs = urb->context;
	struct bas_cardstate *ucs = cs->hw.bas;
609
	struct bc_state *bcs;
610
	int status = urb->status;
611
	unsigned long flags;
612
	int rc;
613 614 615
	unsigned l;
	int channel;

616
	switch (status) {
617 618
	case 0:			/* success */
		break;
619 620
	case -ENOENT:			/* cancelled */
	case -ECONNRESET:		/* cancelled (async) */
621 622
	case -EINPROGRESS:		/* pending */
		/* ignore silently */
623
		gig_dbg(DEBUG_USBREQ, "%s: %s",
624
			__func__, get_usb_statmsg(status));
625
		return;
626 627 628 629
	case -ENODEV:			/* device removed */
	case -ESHUTDOWN:		/* device shut down */
		gig_dbg(DEBUG_USBREQ, "%s: device disconnected", __func__);
		return;
630
	default:		/* severe trouble */
631
		dev_warn(cs->dev, "interrupt read: %s\n",
632
			 get_usb_statmsg(status));
633 634 635
		goto resubmit;
	}

636
	/* drop incomplete packets even if the missing bytes wouldn't matter */
637
	if (unlikely(urb->actual_length < IP_MSGSIZE)) {
638 639 640 641 642
		dev_warn(cs->dev, "incomplete interrupt packet (%d bytes)\n",
			 urb->actual_length);
		goto resubmit;
	}

643 644 645
	l = (unsigned) ucs->int_in_buf[1] +
	    (((unsigned) ucs->int_in_buf[2]) << 8);

646 647 648
	gig_dbg(DEBUG_USBREQ, "<-------%d: 0x%02x (%u [0x%02x 0x%02x])",
		urb->actual_length, (int)ucs->int_in_buf[0], l,
		(int)ucs->int_in_buf[1], (int)ucs->int_in_buf[2]);
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693

	channel = 0;

	switch (ucs->int_in_buf[0]) {
	case HD_DEVICE_INIT_OK:
		update_basstate(ucs, BS_INIT, 0);
		break;

	case HD_READY_SEND_ATDATA:
		del_timer(&ucs->timer_atrdy);
		update_basstate(ucs, BS_ATREADY, BS_ATTIMER);
		start_cbsend(cs);
		break;

	case HD_OPEN_B2CHANNEL_ACK:
		++channel;
	case HD_OPEN_B1CHANNEL_ACK:
		bcs = cs->bcs + channel;
		update_basstate(ucs, BS_B1OPEN << channel, 0);
		gigaset_bchannel_up(bcs);
		break;

	case HD_OPEN_ATCHANNEL_ACK:
		update_basstate(ucs, BS_ATOPEN, 0);
		start_cbsend(cs);
		break;

	case HD_CLOSE_B2CHANNEL_ACK:
		++channel;
	case HD_CLOSE_B1CHANNEL_ACK:
		bcs = cs->bcs + channel;
		update_basstate(ucs, 0, BS_B1OPEN << channel);
		stopurbs(bcs->hw.bas);
		gigaset_bchannel_down(bcs);
		break;

	case HD_CLOSE_ATCHANNEL_ACK:
		update_basstate(ucs, 0, BS_ATOPEN);
		break;

	case HD_B2_FLOW_CONTROL:
		++channel;
	case HD_B1_FLOW_CONTROL:
		bcs = cs->bcs + channel;
		atomic_add((l - BAS_NORMFRAME) * BAS_CORRFRAMES,
694 695 696 697 698
			   &bcs->hw.bas->corrbytes);
		gig_dbg(DEBUG_ISO,
			"Flow control (channel %d, sub %d): 0x%02x => %d",
			channel, bcs->hw.bas->numsub, l,
			atomic_read(&bcs->hw.bas->corrbytes));
699 700 701 702
		break;

	case HD_RECEIVEATDATA_ACK:	/* AT response ready to be received */
		if (!l) {
703 704
			dev_warn(cs->dev,
				"HD_RECEIVEATDATA_ACK with length 0 ignored\n");
705 706 707 708
			break;
		}
		spin_lock_irqsave(&cs->lock, flags);
		if (ucs->rcvbuf_size) {
709
			/* throw away previous buffer - we have no queue */
710
			dev_err(cs->dev,
711 712 713 714
				"receive AT data overrun, %d bytes lost\n",
				ucs->rcvbuf_size);
			kfree(ucs->rcvbuf);
			ucs->rcvbuf_size = 0;
715
		}
T
Tilman Schmidt 已提交
716 717
		ucs->rcvbuf = kmalloc(l, GFP_ATOMIC);
		if (ucs->rcvbuf == NULL) {
718
			spin_unlock_irqrestore(&cs->lock, flags);
719 720
			dev_err(cs->dev, "out of memory receiving AT data\n");
			error_reset(cs);
721 722 723 724
			break;
		}
		ucs->rcvbuf_size = l;
		ucs->retry_cmd_in = 0;
T
Tilman Schmidt 已提交
725 726
		rc = atread_submit(cs, BAS_TIMEOUT);
		if (rc < 0) {
727 728 729
			kfree(ucs->rcvbuf);
			ucs->rcvbuf = NULL;
			ucs->rcvbuf_size = 0;
730 731
			if (rc != -ENODEV) {
				spin_unlock_irqrestore(&cs->lock, flags);
732
				error_reset(cs);
733 734
				break;
			}
735 736 737 738 739
		}
		spin_unlock_irqrestore(&cs->lock, flags);
		break;

	case HD_RESET_INTERRUPT_PIPE_ACK:
T
Tilman Schmidt 已提交
740 741
		update_basstate(ucs, 0, BS_RESETTING);
		dev_notice(cs->dev, "interrupt pipe reset\n");
742 743 744
		break;

	case HD_SUSPEND_END:
745
		gig_dbg(DEBUG_USBREQ, "HD_SUSPEND_END");
746 747 748
		break;

	default:
749 750 751
		dev_warn(cs->dev,
			 "unknown Gigaset signal 0x%02x (%u) ignored\n",
			 (int) ucs->int_in_buf[0], l);
752 753 754
	}

	check_pending(ucs);
T
Tilman Schmidt 已提交
755
	wake_up(&ucs->waitqueue);
756 757

resubmit:
758
	rc = usb_submit_urb(urb, GFP_ATOMIC);
759
	if (unlikely(rc != 0 && rc != -ENODEV)) {
760
		dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
761
			get_usb_rcmsg(rc));
762 763 764 765 766 767 768 769 770 771 772
		error_reset(cs);
	}
}

/* read_iso_callback
 * USB completion handler for B channel isochronous input
 * called by the USB subsystem in interrupt context
 * parameter:
 *	urb	USB request block of completed request
 *		urb->context = bc_state structure
 */
773
static void read_iso_callback(struct urb *urb)
774 775 776
{
	struct bc_state *bcs;
	struct bas_bc_state *ubc;
777
	int status = urb->status;
778 779 780 781
	unsigned long flags;
	int i, rc;

	/* status codes not worth bothering the tasklet with */
782 783 784 785 786
	if (unlikely(status == -ENOENT ||
		     status == -ECONNRESET ||
		     status == -EINPROGRESS ||
		     status == -ENODEV ||
		     status == -ESHUTDOWN)) {
787
		gig_dbg(DEBUG_ISO, "%s: %s",
788
			__func__, get_usb_statmsg(status));
789 790 791
		return;
	}

792
	bcs = urb->context;
793 794 795 796 797 798
	ubc = bcs->hw.bas;

	spin_lock_irqsave(&ubc->isoinlock, flags);
	if (likely(ubc->isoindone == NULL)) {
		/* pass URB to tasklet */
		ubc->isoindone = urb;
799
		ubc->isoinstatus = status;
800
		tasklet_hi_schedule(&ubc->rcvd_tasklet);
801 802
	} else {
		/* tasklet still busy, drop data and resubmit URB */
803
		ubc->loststatus = status;
804 805 806
		for (i = 0; i < BAS_NUMFRAMES; i++) {
			ubc->isoinlost += urb->iso_frame_desc[i].actual_length;
			if (unlikely(urb->iso_frame_desc[i].status != 0 &&
807 808
				     urb->iso_frame_desc[i].status !=
								-EINPROGRESS))
809 810 811 812
				ubc->loststatus = urb->iso_frame_desc[i].status;
			urb->iso_frame_desc[i].status = 0;
			urb->iso_frame_desc[i].actual_length = 0;
		}
T
Tilman Schmidt 已提交
813
		if (likely(ubc->running)) {
814 815
			/* urb->dev is clobbered by USB subsystem */
			urb->dev = bcs->cs->hw.bas->udev;
816 817
			urb->transfer_flags = URB_ISO_ASAP;
			urb->number_of_packets = BAS_NUMFRAMES;
818 819
			gig_dbg(DEBUG_ISO, "%s: isoc read overrun/resubmit",
				__func__);
820
			rc = usb_submit_urb(urb, GFP_ATOMIC);
821
			if (unlikely(rc != 0 && rc != -ENODEV)) {
822 823
				dev_err(bcs->cs->dev,
					"could not resubmit isochronous read "
824
					"URB: %s\n", get_usb_rcmsg(rc));
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
				dump_urb(DEBUG_ISO, "isoc read", urb);
				error_hangup(bcs);
			}
		}
	}
	spin_unlock_irqrestore(&ubc->isoinlock, flags);
}

/* write_iso_callback
 * USB completion handler for B channel isochronous output
 * called by the USB subsystem in interrupt context
 * parameter:
 *	urb	USB request block of completed request
 *		urb->context = isow_urbctx_t structure
 */
840
static void write_iso_callback(struct urb *urb)
841 842 843
{
	struct isow_urbctx_t *ucx;
	struct bas_bc_state *ubc;
844
	int status = urb->status;
845 846 847
	unsigned long flags;

	/* status codes not worth bothering the tasklet with */
848 849 850 851 852
	if (unlikely(status == -ENOENT ||
		     status == -ECONNRESET ||
		     status == -EINPROGRESS ||
		     status == -ENODEV ||
		     status == -ESHUTDOWN)) {
853
		gig_dbg(DEBUG_ISO, "%s: %s",
854
			__func__, get_usb_statmsg(status));
855 856 857 858
		return;
	}

	/* pass URB context to tasklet */
859
	ucx = urb->context;
860
	ubc = ucx->bcs->hw.bas;
861
	ucx->status = status;
862 863 864 865 866

	spin_lock_irqsave(&ubc->isooutlock, flags);
	ubc->isooutovfl = ubc->isooutdone;
	ubc->isooutdone = ucx;
	spin_unlock_irqrestore(&ubc->isooutlock, flags);
867
	tasklet_hi_schedule(&ubc->sent_tasklet);
868 869 870 871 872 873 874 875 876 877 878 879
}

/* starturbs
 * prepare and submit USB request blocks for isochronous input and output
 * argument:
 *	B channel control structure
 * return value:
 *	0 on success
 *	< 0 on error (no URBs submitted)
 */
static int starturbs(struct bc_state *bcs)
{
880
	struct bas_bc_state *ubc = bcs->hw.bas;
881 882 883 884 885
	struct urb *urb;
	int j, k;
	int rc;

	/* initialize L2 reception */
886
	if (bcs->proto2 == L2_HDLC)
887 888 889
		bcs->inputstate |= INS_flag_hunt;

	/* submit all isochronous input URBs */
T
Tilman Schmidt 已提交
890
	ubc->running = 1;
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
	for (k = 0; k < BAS_INURBS; k++) {
		urb = ubc->isoinurbs[k];
		if (!urb) {
			rc = -EFAULT;
			goto error;
		}

		urb->dev = bcs->cs->hw.bas->udev;
		urb->pipe = usb_rcvisocpipe(urb->dev, 3 + 2 * bcs->channel);
		urb->transfer_flags = URB_ISO_ASAP;
		urb->transfer_buffer = ubc->isoinbuf + k * BAS_INBUFSIZE;
		urb->transfer_buffer_length = BAS_INBUFSIZE;
		urb->number_of_packets = BAS_NUMFRAMES;
		urb->interval = BAS_FRAMETIME;
		urb->complete = read_iso_callback;
		urb->context = bcs;
		for (j = 0; j < BAS_NUMFRAMES; j++) {
			urb->iso_frame_desc[j].offset = j * BAS_MAXFRAME;
			urb->iso_frame_desc[j].length = BAS_MAXFRAME;
			urb->iso_frame_desc[j].status = 0;
			urb->iso_frame_desc[j].actual_length = 0;
		}

		dump_urb(DEBUG_ISO, "Initial isoc read", urb);
T
Tilman Schmidt 已提交
915 916
		rc = usb_submit_urb(urb, GFP_ATOMIC);
		if (rc != 0)
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947
			goto error;
	}

	/* initialize L2 transmission */
	gigaset_isowbuf_init(ubc->isooutbuf, PPP_FLAG);

	/* set up isochronous output URBs for flag idling */
	for (k = 0; k < BAS_OUTURBS; ++k) {
		urb = ubc->isoouturbs[k].urb;
		if (!urb) {
			rc = -EFAULT;
			goto error;
		}
		urb->dev = bcs->cs->hw.bas->udev;
		urb->pipe = usb_sndisocpipe(urb->dev, 4 + 2 * bcs->channel);
		urb->transfer_flags = URB_ISO_ASAP;
		urb->transfer_buffer = ubc->isooutbuf->data;
		urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data);
		urb->number_of_packets = BAS_NUMFRAMES;
		urb->interval = BAS_FRAMETIME;
		urb->complete = write_iso_callback;
		urb->context = &ubc->isoouturbs[k];
		for (j = 0; j < BAS_NUMFRAMES; ++j) {
			urb->iso_frame_desc[j].offset = BAS_OUTBUFSIZE;
			urb->iso_frame_desc[j].length = BAS_NORMFRAME;
			urb->iso_frame_desc[j].status = 0;
			urb->iso_frame_desc[j].actual_length = 0;
		}
		ubc->isoouturbs[k].limit = -1;
	}

T
Tilman Schmidt 已提交
948 949
	/* keep one URB free, submit the others */
	for (k = 0; k < BAS_OUTURBS-1; ++k) {
950
		dump_urb(DEBUG_ISO, "Initial isoc write", urb);
951
		rc = usb_submit_urb(ubc->isoouturbs[k].urb, GFP_ATOMIC);
952
		if (rc != 0)
953 954 955
			goto error;
	}
	dump_urb(DEBUG_ISO, "Initial isoc write (free)", urb);
T
Tilman Schmidt 已提交
956
	ubc->isooutfree = &ubc->isoouturbs[BAS_OUTURBS-1];
957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
	ubc->isooutdone = ubc->isooutovfl = NULL;
	return 0;
 error:
	stopurbs(ubc);
	return rc;
}

/* stopurbs
 * cancel the USB request blocks for isochronous input and output
 * errors are silently ignored
 * argument:
 *	B channel control structure
 */
static void stopurbs(struct bas_bc_state *ubc)
{
	int k, rc;

T
Tilman Schmidt 已提交
974
	ubc->running = 0;
975 976 977

	for (k = 0; k < BAS_INURBS; ++k) {
		rc = usb_unlink_urb(ubc->isoinurbs[k]);
978
		gig_dbg(DEBUG_ISO,
979 980
			"%s: isoc input URB %d unlinked, result = %s",
			__func__, k, get_usb_rcmsg(rc));
981 982 983 984
	}

	for (k = 0; k < BAS_OUTURBS; ++k) {
		rc = usb_unlink_urb(ubc->isoouturbs[k].urb);
985
		gig_dbg(DEBUG_ISO,
986 987
			"%s: isoc output URB %d unlinked, result = %s",
			__func__, k, get_usb_rcmsg(rc));
988 989 990 991 992 993 994 995 996
	}
}

/* Isochronous Write - Bottom Half */
/* =============================== */

/* submit_iso_write_urb
 * fill and submit the next isochronous write URB
 * parameters:
997
 *	ucx	context structure containing URB
998 999 1000 1001 1002 1003 1004
 * return value:
 *	number of frames submitted in URB
 *	0 if URB not submitted because no data available (isooutbuf busy)
 *	error code < 0 on error
 */
static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
{
1005 1006
	struct urb *urb = ucx->urb;
	struct bas_bc_state *ubc = ucx->bcs->hw.bas;
1007 1008 1009
	struct usb_iso_packet_descriptor *ifd;
	int corrbytes, nframe, rc;

1010 1011
	/* urb->dev is clobbered by USB subsystem */
	urb->dev = ucx->bcs->cs->hw.bas->udev;
1012 1013 1014 1015 1016 1017 1018 1019 1020
	urb->transfer_flags = URB_ISO_ASAP;
	urb->transfer_buffer = ubc->isooutbuf->data;
	urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data);

	for (nframe = 0; nframe < BAS_NUMFRAMES; nframe++) {
		ifd = &urb->iso_frame_desc[nframe];

		/* compute frame length according to flow control */
		ifd->length = BAS_NORMFRAME;
T
Tilman Schmidt 已提交
1021 1022
		corrbytes = atomic_read(&ubc->corrbytes);
		if (corrbytes != 0) {
1023 1024
			gig_dbg(DEBUG_ISO, "%s: corrbytes=%d",
				__func__, corrbytes);
1025 1026 1027 1028 1029 1030 1031 1032 1033
			if (corrbytes > BAS_HIGHFRAME - BAS_NORMFRAME)
				corrbytes = BAS_HIGHFRAME - BAS_NORMFRAME;
			else if (corrbytes < BAS_LOWFRAME - BAS_NORMFRAME)
				corrbytes = BAS_LOWFRAME - BAS_NORMFRAME;
			ifd->length += corrbytes;
			atomic_add(-corrbytes, &ubc->corrbytes);
		}

		/* retrieve block of data to send */
1034 1035 1036
		rc = gigaset_isowbuf_getbytes(ubc->isooutbuf, ifd->length);
		if (rc < 0) {
			if (rc == -EBUSY) {
1037 1038 1039 1040
				gig_dbg(DEBUG_ISO,
					"%s: buffer busy at frame %d",
					__func__, nframe);
				/* tasklet will be restarted from
1041
				   gigaset_isoc_send_skb() */
1042
			} else {
1043 1044
				dev_err(ucx->bcs->cs->dev,
					"%s: buffer error %d at frame %d\n",
1045 1046
					__func__, rc, nframe);
				return rc;
1047 1048 1049
			}
			break;
		}
1050
		ifd->offset = rc;
T
Tilman Schmidt 已提交
1051
		ucx->limit = ubc->isooutbuf->nextread;
1052 1053 1054
		ifd->status = 0;
		ifd->actual_length = 0;
	}
1055 1056 1057
	if (unlikely(nframe == 0))
		return 0;	/* no data to send */
	urb->number_of_packets = nframe;
1058

1059
	rc = usb_submit_urb(urb, GFP_ATOMIC);
1060 1061 1062 1063 1064
	if (unlikely(rc)) {
		if (rc == -ENODEV)
			/* device removed - give up silently */
			gig_dbg(DEBUG_ISO, "%s: disconnected", __func__);
		else
1065 1066
			dev_err(ucx->bcs->cs->dev,
				"could not submit isochronous write URB: %s\n",
1067 1068
				get_usb_rcmsg(rc));
		return rc;
1069
	}
1070
	++ubc->numsub;
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
	return nframe;
}

/* write_iso_tasklet
 * tasklet scheduled when an isochronous output URB from the Gigaset device
 * has completed
 * parameter:
 *	data	B channel state structure
 */
static void write_iso_tasklet(unsigned long data)
{
1082 1083 1084
	struct bc_state *bcs = (struct bc_state *) data;
	struct bas_bc_state *ubc = bcs->hw.bas;
	struct cardstate *cs = bcs->cs;
1085 1086
	struct isow_urbctx_t *done, *next, *ovfl;
	struct urb *urb;
1087
	int status;
1088 1089 1090 1091 1092 1093
	struct usb_iso_packet_descriptor *ifd;
	int offset;
	unsigned long flags;
	int i;
	struct sk_buff *skb;
	int len;
1094
	int rc;
1095 1096 1097

	/* loop while completed URBs arrive in time */
	for (;;) {
T
Tilman Schmidt 已提交
1098
		if (unlikely(!(ubc->running))) {
1099
			gig_dbg(DEBUG_ISO, "%s: not running", __func__);
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
			return;
		}

		/* retrieve completed URBs */
		spin_lock_irqsave(&ubc->isooutlock, flags);
		done = ubc->isooutdone;
		ubc->isooutdone = NULL;
		ovfl = ubc->isooutovfl;
		ubc->isooutovfl = NULL;
		spin_unlock_irqrestore(&ubc->isooutlock, flags);
		if (ovfl) {
1111
			dev_err(cs->dev, "isochronous write buffer underrun\n");
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
			error_hangup(bcs);
			break;
		}
		if (!done)
			break;

		/* submit free URB if available */
		spin_lock_irqsave(&ubc->isooutlock, flags);
		next = ubc->isooutfree;
		ubc->isooutfree = NULL;
		spin_unlock_irqrestore(&ubc->isooutlock, flags);
		if (next) {
1124 1125
			rc = submit_iso_write_urb(next);
			if (unlikely(rc <= 0 && rc != -ENODEV)) {
1126 1127 1128 1129 1130 1131 1132 1133 1134
				/* could not submit URB, put it back */
				spin_lock_irqsave(&ubc->isooutlock, flags);
				if (ubc->isooutfree == NULL) {
					ubc->isooutfree = next;
					next = NULL;
				}
				spin_unlock_irqrestore(&ubc->isooutlock, flags);
				if (next) {
					/* couldn't put it back */
1135 1136
					dev_err(cs->dev,
					      "losing isochronous write URB\n");
1137 1138 1139 1140 1141 1142 1143
					error_hangup(bcs);
				}
			}
		}

		/* process completed URB */
		urb = done->urb;
1144 1145
		status = done->status;
		switch (status) {
1146 1147 1148 1149
		case -EXDEV:			/* partial completion */
			gig_dbg(DEBUG_ISO, "%s: URB partially completed",
				__func__);
			/* fall through - what's the difference anyway? */
1150
		case 0:				/* normal completion */
1151 1152 1153
			/* inspect individual frames
			 * assumptions (for lack of documentation):
			 * - actual_length bytes of first frame in error are
1154
			 *   successfully sent
1155 1156
			 * - all following frames are not sent at all
			 */
1157
			offset = done->limit;	/* default (no error) */
1158 1159 1160 1161
			for (i = 0; i < BAS_NUMFRAMES; i++) {
				ifd = &urb->iso_frame_desc[i];
				if (ifd->status ||
				    ifd->actual_length != ifd->length) {
1162 1163 1164
					dev_warn(cs->dev,
					     "isochronous write: frame %d: %s, "
					     "only %d of %d bytes sent\n",
1165 1166 1167
					     i, get_usb_statmsg(ifd->status),
					     ifd->actual_length, ifd->length);
					offset = (ifd->offset +
1168 1169
						  ifd->actual_length)
						 % BAS_OUTBUFSIZE;
1170 1171 1172 1173
					break;
				}
			}
			break;
1174
		case -EPIPE:			/* stall - probably underrun */
1175
			dev_err(cs->dev, "isochronous write stalled\n");
1176 1177 1178
			error_hangup(bcs);
			break;
		default:			/* severe trouble */
1179
			dev_warn(cs->dev, "isochronous write: %s\n",
1180
				 get_usb_statmsg(status));
1181 1182 1183 1184
		}

		/* mark the write buffer area covered by this URB as free */
		if (done->limit >= 0)
T
Tilman Schmidt 已提交
1185
			ubc->isooutbuf->read = done->limit;
1186 1187 1188 1189 1190 1191 1192 1193

		/* mark URB as free */
		spin_lock_irqsave(&ubc->isooutlock, flags);
		next = ubc->isooutfree;
		ubc->isooutfree = done;
		spin_unlock_irqrestore(&ubc->isooutlock, flags);
		if (next) {
			/* only one URB still active - resubmit one */
1194 1195
			rc = submit_iso_write_urb(next);
			if (unlikely(rc <= 0 && rc != -ENODEV)) {
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
				/* couldn't submit */
				error_hangup(bcs);
			}
		}
	}

	/* process queued SKBs */
	while ((skb = skb_dequeue(&bcs->squeue))) {
		/* copy to output buffer, doing L2 encapsulation */
		len = skb->len;
		if (gigaset_isoc_buildframe(bcs, skb->data, len) == -EAGAIN) {
			/* insufficient buffer space, push back onto queue */
			skb_queue_head(&bcs->squeue, skb);
1209 1210
			gig_dbg(DEBUG_ISO, "%s: skb requeued, qlen=%d",
				__func__, skb_queue_len(&bcs->squeue));
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
			break;
		}
		skb_pull(skb, len);
		gigaset_skb_sent(bcs, skb);
		dev_kfree_skb_any(skb);
	}
}

/* Isochronous Read - Bottom Half */
/* ============================== */

/* read_iso_tasklet
 * tasklet scheduled when an isochronous input URB from the Gigaset device
 * has completed
 * parameter:
 *	data	B channel state structure
 */
static void read_iso_tasklet(unsigned long data)
{
1230 1231 1232
	struct bc_state *bcs = (struct bc_state *) data;
	struct bas_bc_state *ubc = bcs->hw.bas;
	struct cardstate *cs = bcs->cs;
1233
	struct urb *urb;
1234
	int status;
1235 1236 1237 1238 1239 1240 1241 1242
	char *rcvbuf;
	unsigned long flags;
	int totleft, numbytes, offset, frame, rc;

	/* loop while more completed URBs arrive in the meantime */
	for (;;) {
		/* retrieve URB */
		spin_lock_irqsave(&ubc->isoinlock, flags);
T
Tilman Schmidt 已提交
1243 1244
		urb = ubc->isoindone;
		if (!urb) {
1245 1246 1247
			spin_unlock_irqrestore(&ubc->isoinlock, flags);
			return;
		}
1248
		status = ubc->isoinstatus;
1249 1250
		ubc->isoindone = NULL;
		if (unlikely(ubc->loststatus != -EINPROGRESS)) {
1251 1252 1253 1254 1255
			dev_warn(cs->dev,
				 "isochronous read overrun, "
				 "dropped URB with status: %s, %d bytes lost\n",
				 get_usb_statmsg(ubc->loststatus),
				 ubc->isoinlost);
1256 1257 1258 1259
			ubc->loststatus = -EINPROGRESS;
		}
		spin_unlock_irqrestore(&ubc->isoinlock, flags);

T
Tilman Schmidt 已提交
1260
		if (unlikely(!(ubc->running))) {
1261 1262 1263
			gig_dbg(DEBUG_ISO,
				"%s: channel not running, "
				"dropped URB with status: %s",
1264
				__func__, get_usb_statmsg(status));
1265 1266 1267
			return;
		}

1268
		switch (status) {
1269 1270
		case 0:				/* normal completion */
			break;
1271 1272
		case -EXDEV:			/* inspect individual frames
						   (we do that anyway) */
1273 1274
			gig_dbg(DEBUG_ISO, "%s: URB partially completed",
				__func__);
1275 1276 1277
			break;
		case -ENOENT:
		case -ECONNRESET:
1278 1279
		case -EINPROGRESS:
			gig_dbg(DEBUG_ISO, "%s: %s",
1280
				__func__, get_usb_statmsg(status));
1281 1282
			continue;		/* -> skip */
		case -EPIPE:
1283
			dev_err(cs->dev, "isochronous read stalled\n");
1284 1285 1286
			error_hangup(bcs);
			continue;		/* -> skip */
		default:			/* severe trouble */
1287
			dev_warn(cs->dev, "isochronous read: %s\n",
1288
				 get_usb_statmsg(status));
1289 1290 1291 1292 1293 1294
			goto error;
		}

		rcvbuf = urb->transfer_buffer;
		totleft = urb->actual_length;
		for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) {
1295 1296
			numbytes = urb->iso_frame_desc[frame].actual_length;
			if (unlikely(urb->iso_frame_desc[frame].status))
1297
				dev_warn(cs->dev,
1298 1299
					 "isochronous read: frame %d[%d]: %s\n",
					 frame, numbytes,
1300 1301
					 get_usb_statmsg(
					    urb->iso_frame_desc[frame].status));
1302
			if (unlikely(numbytes > BAS_MAXFRAME))
1303 1304 1305 1306
				dev_warn(cs->dev,
					 "isochronous read: frame %d: "
					 "numbytes (%d) > BAS_MAXFRAME\n",
					 frame, numbytes);
1307
			if (unlikely(numbytes > totleft)) {
1308 1309 1310 1311
				dev_warn(cs->dev,
					 "isochronous read: frame %d: "
					 "numbytes (%d) > totleft (%d)\n",
					 frame, numbytes, totleft);
1312
				numbytes = totleft;
1313 1314 1315
			}
			offset = urb->iso_frame_desc[frame].offset;
			if (unlikely(offset + numbytes > BAS_INBUFSIZE)) {
1316 1317 1318 1319 1320
				dev_warn(cs->dev,
					 "isochronous read: frame %d: "
					 "offset (%d) + numbytes (%d) "
					 "> BAS_INBUFSIZE\n",
					 frame, offset, numbytes);
1321
				numbytes = BAS_INBUFSIZE - offset;
1322 1323 1324 1325 1326
			}
			gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs);
			totleft -= numbytes;
		}
		if (unlikely(totleft > 0))
1327 1328 1329
			dev_warn(cs->dev,
				 "isochronous read: %d data bytes missing\n",
				 totleft);
1330

T
Tilman Schmidt 已提交
1331
error:
1332 1333 1334 1335 1336
		/* URB processed, resubmit */
		for (frame = 0; frame < BAS_NUMFRAMES; frame++) {
			urb->iso_frame_desc[frame].status = 0;
			urb->iso_frame_desc[frame].actual_length = 0;
		}
1337 1338
		/* urb->dev is clobbered by USB subsystem */
		urb->dev = bcs->cs->hw.bas->udev;
1339 1340
		urb->transfer_flags = URB_ISO_ASAP;
		urb->number_of_packets = BAS_NUMFRAMES;
1341
		rc = usb_submit_urb(urb, GFP_ATOMIC);
1342
		if (unlikely(rc != 0 && rc != -ENODEV)) {
1343 1344
			dev_err(cs->dev,
				"could not resubmit isochronous read URB: %s\n",
1345
				get_usb_rcmsg(rc));
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
			dump_urb(DEBUG_ISO, "resubmit iso read", urb);
			error_hangup(bcs);
		}
	}
}

/* Channel Operations */
/* ================== */

/* req_timeout
 * timeout routine for control output request
 * argument:
1358
 *	controller state structure
1359 1360 1361
 */
static void req_timeout(unsigned long data)
{
1362 1363
	struct cardstate *cs = (struct cardstate *) data;
	struct bas_cardstate *ucs = cs->hw.bas;
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
	int pending;
	unsigned long flags;

	check_pending(ucs);

	spin_lock_irqsave(&ucs->lock, flags);
	pending = ucs->pending;
	ucs->pending = 0;
	spin_unlock_irqrestore(&ucs->lock, flags);

	switch (pending) {
	case 0:					/* no pending request */
1376
		gig_dbg(DEBUG_USBREQ, "%s: no request pending", __func__);
1377 1378 1379
		break;

	case HD_OPEN_ATCHANNEL:
1380 1381
		dev_err(cs->dev, "timeout opening AT channel\n");
		error_reset(cs);
1382 1383 1384
		break;

	case HD_OPEN_B1CHANNEL:
1385 1386 1387 1388 1389 1390 1391
		dev_err(cs->dev, "timeout opening channel 1\n");
		error_hangup(&cs->bcs[0]);
		break;

	case HD_OPEN_B2CHANNEL:
		dev_err(cs->dev, "timeout opening channel 2\n");
		error_hangup(&cs->bcs[1]);
1392 1393 1394
		break;

	case HD_CLOSE_ATCHANNEL:
1395 1396
		dev_err(cs->dev, "timeout closing AT channel\n");
		error_reset(cs);
1397 1398 1399
		break;

	case HD_CLOSE_B1CHANNEL:
1400 1401 1402 1403 1404 1405 1406
		dev_err(cs->dev, "timeout closing channel 1\n");
		error_reset(cs);
		break;

	case HD_CLOSE_B2CHANNEL:
		dev_err(cs->dev, "timeout closing channel 2\n");
		error_reset(cs);
1407 1408
		break;

T
Tilman Schmidt 已提交
1409 1410
	case HD_RESET_INTERRUPT_PIPE:
		/* error recovery escalation */
1411
		dev_err(cs->dev,
T
Tilman Schmidt 已提交
1412
			"reset interrupt pipe timeout, attempting USB reset\n");
1413
		usb_queue_reset_device(ucs->interface);
T
Tilman Schmidt 已提交
1414 1415
		break;

1416
	default:
1417
		dev_warn(cs->dev, "request 0x%02x timed out, clearing\n",
1418
			 pending);
1419
	}
T
Tilman Schmidt 已提交
1420 1421

	wake_up(&ucs->waitqueue);
1422 1423 1424 1425 1426 1427 1428 1429 1430
}

/* write_ctrl_callback
 * USB completion handler for control pipe output
 * called by the USB subsystem in interrupt context
 * parameter:
 *	urb	USB request block of completed request
 *		urb->context = hardware specific controller state structure
 */
1431
static void write_ctrl_callback(struct urb *urb)
1432
{
1433
	struct bas_cardstate *ucs = urb->context;
1434
	int status = urb->status;
1435
	int rc;
1436 1437
	unsigned long flags;

1438
	/* check status */
1439
	switch (status) {
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
	case 0:					/* normal completion */
		spin_lock_irqsave(&ucs->lock, flags);
		switch (ucs->pending) {
		case HD_DEVICE_INIT_ACK:	/* no reply expected */
			del_timer(&ucs->timer_ctrl);
			ucs->pending = 0;
			break;
		}
		spin_unlock_irqrestore(&ucs->lock, flags);
		return;

	case -ENOENT:			/* cancelled */
	case -ECONNRESET:		/* cancelled (async) */
	case -EINPROGRESS:		/* pending */
	case -ENODEV:			/* device removed */
	case -ESHUTDOWN:		/* device shut down */
		/* ignore silently */
		gig_dbg(DEBUG_USBREQ, "%s: %s",
1458
			__func__, get_usb_statmsg(status));
1459
		break;
1460 1461

	default:				/* any failure */
T
Tilman Schmidt 已提交
1462 1463
		/* don't retry if suspend requested */
		if (++ucs->retry_ctrl > BAS_RETRY ||
T
Tilman Schmidt 已提交
1464
		    (ucs->basstate & BS_SUSPEND)) {
1465 1466 1467
			dev_err(&ucs->interface->dev,
				"control request 0x%02x failed: %s\n",
				ucs->dr_ctrl.bRequest,
1468
				get_usb_statmsg(status));
1469 1470 1471 1472
			break;		/* give up */
		}
		dev_notice(&ucs->interface->dev,
			   "control request 0x%02x: %s, retry %d\n",
1473
			   ucs->dr_ctrl.bRequest, get_usb_statmsg(status),
1474 1475 1476
			   ucs->retry_ctrl);
		/* urb->dev is clobbered by USB subsystem */
		urb->dev = ucs->udev;
1477
		rc = usb_submit_urb(urb, GFP_ATOMIC);
1478 1479 1480 1481 1482 1483 1484 1485
		if (unlikely(rc)) {
			dev_err(&ucs->interface->dev,
				"could not resubmit request 0x%02x: %s\n",
				ucs->dr_ctrl.bRequest, get_usb_rcmsg(rc));
			break;
		}
		/* resubmitted */
		return;
1486
	}
1487 1488 1489 1490 1491

	/* failed, clear pending request */
	spin_lock_irqsave(&ucs->lock, flags);
	del_timer(&ucs->timer_ctrl);
	ucs->pending = 0;
1492
	spin_unlock_irqrestore(&ucs->lock, flags);
T
Tilman Schmidt 已提交
1493
	wake_up(&ucs->waitqueue);
1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
}

/* req_submit
 * submit a control output request without message buffer to the Gigaset base
 * and optionally start a timeout
 * parameters:
 *	bcs	B channel control structure
 *	req	control request code (HD_*)
 *	val	control request parameter value (set to 0 if unused)
 *	timeout	timeout in seconds (0: no timeout)
 * return value:
 *	0 on success
 *	-EBUSY if another request is pending
 *	any URB submission error code
 */
static int req_submit(struct bc_state *bcs, int req, int val, int timeout)
{
1511
	struct bas_cardstate *ucs = bcs->cs->hw.bas;
1512 1513 1514
	int ret;
	unsigned long flags;

1515
	gig_dbg(DEBUG_USBREQ, "-------> 0x%02x (%d)", req, val);
1516 1517 1518 1519

	spin_lock_irqsave(&ucs->lock, flags);
	if (ucs->pending) {
		spin_unlock_irqrestore(&ucs->lock, flags);
1520 1521 1522 1523
		dev_err(bcs->cs->dev,
			"submission of request 0x%02x failed: "
			"request 0x%02x still pending\n",
			req, ucs->pending);
1524 1525 1526 1527 1528 1529 1530 1531 1532
		return -EBUSY;
	}

	ucs->dr_ctrl.bRequestType = OUT_VENDOR_REQ;
	ucs->dr_ctrl.bRequest = req;
	ucs->dr_ctrl.wValue = cpu_to_le16(val);
	ucs->dr_ctrl.wIndex = 0;
	ucs->dr_ctrl.wLength = 0;
	usb_fill_control_urb(ucs->urb_ctrl, ucs->udev,
1533
			     usb_sndctrlpipe(ucs->udev, 0),
T
Tilman Schmidt 已提交
1534
			     (unsigned char *) &ucs->dr_ctrl, NULL, 0,
1535
			     write_ctrl_callback, ucs);
1536
	ucs->retry_ctrl = 0;
1537
	ret = usb_submit_urb(ucs->urb_ctrl, GFP_ATOMIC);
1538
	if (unlikely(ret)) {
1539
		dev_err(bcs->cs->dev, "could not submit request 0x%02x: %s\n",
1540
			req, get_usb_rcmsg(ret));
1541 1542 1543 1544 1545 1546
		spin_unlock_irqrestore(&ucs->lock, flags);
		return ret;
	}
	ucs->pending = req;

	if (timeout > 0) {
1547
		gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
1548
		mod_timer(&ucs->timer_ctrl, jiffies + timeout * HZ / 10);
1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
	}

	spin_unlock_irqrestore(&ucs->lock, flags);
	return 0;
}

/* gigaset_init_bchannel
 * called by common.c to connect a B channel
 * initialize isochronous I/O and tell the Gigaset base to open the channel
 * argument:
 *	B channel control structure
 * return value:
 *	0 on success, error code < 0 on error
 */
static int gigaset_init_bchannel(struct bc_state *bcs)
{
T
Tilman Schmidt 已提交
1565
	struct cardstate *cs = bcs->cs;
1566
	int req, ret;
1567 1568
	unsigned long flags;

T
Tilman Schmidt 已提交
1569 1570
	spin_lock_irqsave(&cs->lock, flags);
	if (unlikely(!cs->connected)) {
1571
		gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
T
Tilman Schmidt 已提交
1572
		spin_unlock_irqrestore(&cs->lock, flags);
1573 1574
		return -ENODEV;
	}
1575

T
Tilman Schmidt 已提交
1576
	if (cs->hw.bas->basstate & BS_SUSPEND) {
T
Tilman Schmidt 已提交
1577 1578 1579 1580 1581 1582 1583
		dev_notice(cs->dev,
			   "not starting isochronous I/O, "
			   "suspend in progress\n");
		spin_unlock_irqrestore(&cs->lock, flags);
		return -EHOSTUNREACH;
	}

T
Tilman Schmidt 已提交
1584 1585
	ret = starturbs(bcs);
	if (ret < 0) {
1586
		spin_unlock_irqrestore(&cs->lock, flags);
T
Tilman Schmidt 已提交
1587
		dev_err(cs->dev,
1588 1589 1590 1591 1592
			"could not start isochronous I/O for channel B%d: %s\n",
			bcs->channel + 1,
			ret == -EFAULT ? "null URB" : get_usb_rcmsg(ret));
		if (ret != -ENODEV)
			error_hangup(bcs);
1593 1594 1595 1596
		return ret;
	}

	req = bcs->channel ? HD_OPEN_B2CHANNEL : HD_OPEN_B1CHANNEL;
T
Tilman Schmidt 已提交
1597 1598
	ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
	if (ret < 0) {
T
Tilman Schmidt 已提交
1599
		dev_err(cs->dev, "could not open channel B%d\n",
1600
			bcs->channel + 1);
1601 1602
		stopurbs(bcs->hw.bas);
	}
1603

T
Tilman Schmidt 已提交
1604
	spin_unlock_irqrestore(&cs->lock, flags);
1605 1606
	if (ret < 0 && ret != -ENODEV)
		error_hangup(bcs);
1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
	return ret;
}

/* gigaset_close_bchannel
 * called by common.c to disconnect a B channel
 * tell the Gigaset base to close the channel
 * stopping isochronous I/O and LL notification will be done when the
 * acknowledgement for the close arrives
 * argument:
 *	B channel control structure
 * return value:
 *	0 on success, error code < 0 on error
 */
static int gigaset_close_bchannel(struct bc_state *bcs)
{
T
Tilman Schmidt 已提交
1622
	struct cardstate *cs = bcs->cs;
1623
	int req, ret;
1624 1625
	unsigned long flags;

T
Tilman Schmidt 已提交
1626 1627 1628
	spin_lock_irqsave(&cs->lock, flags);
	if (unlikely(!cs->connected)) {
		spin_unlock_irqrestore(&cs->lock, flags);
1629 1630 1631
		gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
		return -ENODEV;
	}
1632

T
Tilman Schmidt 已提交
1633
	if (!(cs->hw.bas->basstate & (bcs->channel ? BS_B2OPEN : BS_B1OPEN))) {
1634
		/* channel not running: just signal common.c */
T
Tilman Schmidt 已提交
1635
		spin_unlock_irqrestore(&cs->lock, flags);
1636 1637 1638 1639
		gigaset_bchannel_down(bcs);
		return 0;
	}

1640
	/* channel running: tell device to close it */
1641
	req = bcs->channel ? HD_CLOSE_B2CHANNEL : HD_CLOSE_B1CHANNEL;
T
Tilman Schmidt 已提交
1642 1643
	ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
	if (ret < 0)
T
Tilman Schmidt 已提交
1644
		dev_err(cs->dev, "closing channel B%d failed\n",
1645 1646
			bcs->channel + 1);

T
Tilman Schmidt 已提交
1647
	spin_unlock_irqrestore(&cs->lock, flags);
1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
	return ret;
}

/* Device Operations */
/* ================= */

/* complete_cb
 * unqueue first command buffer from queue, waking any sleepers
 * must be called with cs->cmdlock held
 * parameter:
 *	cs	controller state structure
 */
static void complete_cb(struct cardstate *cs)
{
1662
	struct cmdbuf_t *cb = cs->cmdbuf;
1663 1664 1665

	/* unqueue completed buffer */
	cs->cmdbytes -= cs->curlen;
T
Tilman Schmidt 已提交
1666
	gig_dbg(DEBUG_OUTPUT, "write_command: sent %u bytes, %u left",
1667
		cs->curlen, cs->cmdbytes);
T
Tilman Schmidt 已提交
1668 1669
	if (cb->next != NULL) {
		cs->cmdbuf = cb->next;
1670 1671 1672
		cs->cmdbuf->prev = NULL;
		cs->curlen = cs->cmdbuf->len;
	} else {
T
Tilman Schmidt 已提交
1673
		cs->cmdbuf = NULL;
1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
		cs->lastcmdbuf = NULL;
		cs->curlen = 0;
	}

	if (cb->wake_tasklet)
		tasklet_schedule(cb->wake_tasklet);

	kfree(cb);
}

/* write_command_callback
 * USB completion handler for AT command transmission
 * called by the USB subsystem in interrupt context
 * parameter:
 *	urb	USB request block of completed request
 *		urb->context = controller state structure
 */
1691
static void write_command_callback(struct urb *urb)
1692
{
1693 1694
	struct cardstate *cs = urb->context;
	struct bas_cardstate *ucs = cs->hw.bas;
1695
	int status = urb->status;
1696 1697
	unsigned long flags;

1698
	update_basstate(ucs, 0, BS_ATWRPEND);
T
Tilman Schmidt 已提交
1699
	wake_up(&ucs->waitqueue);
1700

1701
	/* check status */
1702
	switch (status) {
1703 1704
	case 0:					/* normal completion */
		break;
1705 1706
	case -ENOENT:			/* cancelled */
	case -ECONNRESET:		/* cancelled (async) */
1707
	case -EINPROGRESS:		/* pending */
1708 1709
	case -ENODEV:			/* device removed */
	case -ESHUTDOWN:		/* device shut down */
1710
		/* ignore silently */
1711
		gig_dbg(DEBUG_USBREQ, "%s: %s",
1712
			__func__, get_usb_statmsg(status));
1713 1714 1715
		return;
	default:				/* any failure */
		if (++ucs->retry_cmd_out > BAS_RETRY) {
1716 1717 1718
			dev_warn(cs->dev,
				 "command write: %s, "
				 "giving up after %d retries\n",
1719
				 get_usb_statmsg(status),
1720
				 ucs->retry_cmd_out);
1721 1722
			break;
		}
T
Tilman Schmidt 已提交
1723
		if (ucs->basstate & BS_SUSPEND) {
T
Tilman Schmidt 已提交
1724 1725 1726 1727 1728 1729
			dev_warn(cs->dev,
				 "command write: %s, "
				 "won't retry - suspend requested\n",
				 get_usb_statmsg(status));
			break;
		}
1730
		if (cs->cmdbuf == NULL) {
1731 1732 1733
			dev_warn(cs->dev,
				 "command write: %s, "
				 "cannot retry - cmdbuf gone\n",
1734
				 get_usb_statmsg(status));
1735 1736
			break;
		}
1737
		dev_notice(cs->dev, "command write: %s, retry %d\n",
1738
			   get_usb_statmsg(status), ucs->retry_cmd_out);
1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
		if (atwrite_submit(cs, cs->cmdbuf->buf, cs->cmdbuf->len) >= 0)
			/* resubmitted - bypass regular exit block */
			return;
		/* command send failed, assume base still waiting */
		update_basstate(ucs, BS_ATREADY, 0);
	}

	spin_lock_irqsave(&cs->cmdlock, flags);
	if (cs->cmdbuf != NULL)
		complete_cb(cs);
	spin_unlock_irqrestore(&cs->cmdlock, flags);
}

/* atrdy_timeout
 * timeout routine for AT command transmission
 * argument:
 *	controller state structure
 */
static void atrdy_timeout(unsigned long data)
{
	struct cardstate *cs = (struct cardstate *) data;
1760
	struct bas_cardstate *ucs = cs->hw.bas;
1761

1762
	dev_warn(cs->dev, "timeout waiting for HD_READY_SEND_ATDATA\n");
1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781

	/* fake the missing signal - what else can I do? */
	update_basstate(ucs, BS_ATREADY, BS_ATTIMER);
	start_cbsend(cs);
}

/* atwrite_submit
 * submit an HD_WRITE_ATMESSAGE command URB
 * parameters:
 *	cs	controller state structure
 *	buf	buffer containing command to send
 *	len	length of command to send
 * return value:
 *	0 on success
 *	-EBUSY if another request is pending
 *	any URB submission error code
 */
static int atwrite_submit(struct cardstate *cs, unsigned char *buf, int len)
{
1782
	struct bas_cardstate *ucs = cs->hw.bas;
1783
	int rc;
1784

1785
	gig_dbg(DEBUG_USBREQ, "-------> HD_WRITE_ATMESSAGE (%d)", len);
1786

1787
	if (update_basstate(ucs, BS_ATWRPEND, 0) & BS_ATWRPEND) {
1788 1789
		dev_err(cs->dev,
			"could not submit HD_WRITE_ATMESSAGE: URB busy\n");
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
		return -EBUSY;
	}

	ucs->dr_cmd_out.bRequestType = OUT_VENDOR_REQ;
	ucs->dr_cmd_out.bRequest = HD_WRITE_ATMESSAGE;
	ucs->dr_cmd_out.wValue = 0;
	ucs->dr_cmd_out.wIndex = 0;
	ucs->dr_cmd_out.wLength = cpu_to_le16(len);
	usb_fill_control_urb(ucs->urb_cmd_out, ucs->udev,
			     usb_sndctrlpipe(ucs->udev, 0),
T
Tilman Schmidt 已提交
1800
			     (unsigned char *) &ucs->dr_cmd_out, buf, len,
1801
			     write_command_callback, cs);
1802
	rc = usb_submit_urb(ucs->urb_cmd_out, GFP_ATOMIC);
1803 1804
	if (unlikely(rc)) {
		update_basstate(ucs, 0, BS_ATWRPEND);
1805
		dev_err(cs->dev, "could not submit HD_WRITE_ATMESSAGE: %s\n",
1806 1807
			get_usb_rcmsg(rc));
		return rc;
1808 1809
	}

1810 1811
	/* submitted successfully, start timeout if necessary */
	if (!(update_basstate(ucs, BS_ATTIMER, BS_ATREADY) & BS_ATTIMER)) {
1812 1813
		gig_dbg(DEBUG_OUTPUT, "setting ATREADY timeout of %d/10 secs",
			ATRDY_TIMEOUT);
1814
		mod_timer(&ucs->timer_atrdy, jiffies + ATRDY_TIMEOUT * HZ / 10);
1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
	}
	return 0;
}

/* start_cbsend
 * start transmission of AT command queue if necessary
 * parameter:
 *	cs		controller state structure
 * return value:
 *	0 on success
 *	error code < 0 on error
 */
static int start_cbsend(struct cardstate *cs)
{
	struct cmdbuf_t *cb;
1830
	struct bas_cardstate *ucs = cs->hw.bas;
1831 1832 1833 1834
	unsigned long flags;
	int rc;
	int retval = 0;

T
Tilman Schmidt 已提交
1835
	/* check if suspend requested */
T
Tilman Schmidt 已提交
1836
	if (ucs->basstate & BS_SUSPEND) {
T
Tilman Schmidt 已提交
1837
		gig_dbg(DEBUG_OUTPUT, "suspending");
T
Tilman Schmidt 已提交
1838 1839 1840
		return -EHOSTUNREACH;
	}

1841
	/* check if AT channel is open */
T
Tilman Schmidt 已提交
1842
	if (!(ucs->basstate & BS_ATOPEN)) {
T
Tilman Schmidt 已提交
1843
		gig_dbg(DEBUG_OUTPUT, "AT channel not open");
1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857
		rc = req_submit(cs->bcs, HD_OPEN_ATCHANNEL, 0, BAS_TIMEOUT);
		if (rc < 0) {
			/* flush command queue */
			spin_lock_irqsave(&cs->cmdlock, flags);
			while (cs->cmdbuf != NULL)
				complete_cb(cs);
			spin_unlock_irqrestore(&cs->cmdlock, flags);
		}
		return rc;
	}

	/* try to send first command in queue */
	spin_lock_irqsave(&cs->cmdlock, flags);

T
Tilman Schmidt 已提交
1858
	while ((cb = cs->cmdbuf) != NULL && (ucs->basstate & BS_ATREADY)) {
1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
		ucs->retry_cmd_out = 0;
		rc = atwrite_submit(cs, cb->buf, cb->len);
		if (unlikely(rc)) {
			retval = rc;
			complete_cb(cs);
		}
	}

	spin_unlock_irqrestore(&cs->cmdlock, flags);
	return retval;
}

/* gigaset_write_cmd
 * This function is called by the device independent part of the driver
 * to transmit an AT command string to the Gigaset device.
 * It encapsulates the device specific method for transmission over the
 * direct USB connection to the base.
 * The command string is added to the queue of commands to send, and
 * USB transmission is started if necessary.
 * parameters:
 *	cs		controller state structure
1880
 *	cb		command buffer structure
1881 1882 1883 1884
 * return value:
 *	number of bytes queued on success
 *	error code < 0 on error
 */
1885
static int gigaset_write_cmd(struct cardstate *cs, struct cmdbuf_t *cb)
1886 1887
{
	unsigned long flags;
1888
	int rc;
1889

T
Tilman Schmidt 已提交
1890
	gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
1891
			     DEBUG_TRANSCMD : DEBUG_LOCKCMD,
1892
			   "CMD Transmit", cb->len, cb->buf);
1893

T
Tilman Schmidt 已提交
1894 1895 1896 1897
	/* translate "+++" escape sequence sent as a single separate command
	 * into "close AT channel" command for error recovery
	 * The next command will reopen the AT channel automatically.
	 */
1898
	if (cb->len == 3 && !memcmp(cb->buf, "+++", 3)) {
T
Tilman Schmidt 已提交
1899
		rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT);
1900 1901
		if (cb->wake_tasklet)
			tasklet_schedule(cb->wake_tasklet);
D
Dan Carpenter 已提交
1902 1903 1904 1905
		if (!rc)
			rc = cb->len;
		kfree(cb);
		return rc;
1906 1907 1908 1909 1910 1911 1912 1913
	}

	spin_lock_irqsave(&cs->cmdlock, flags);
	cb->prev = cs->lastcmdbuf;
	if (cs->lastcmdbuf)
		cs->lastcmdbuf->next = cb;
	else {
		cs->cmdbuf = cb;
1914
		cs->curlen = cb->len;
1915
	}
1916
	cs->cmdbytes += cb->len;
1917 1918 1919
	cs->lastcmdbuf = cb;
	spin_unlock_irqrestore(&cs->cmdlock, flags);

1920 1921 1922 1923
	spin_lock_irqsave(&cs->lock, flags);
	if (unlikely(!cs->connected)) {
		spin_unlock_irqrestore(&cs->lock, flags);
		gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
1924 1925 1926 1927 1928
		/* flush command queue */
		spin_lock_irqsave(&cs->cmdlock, flags);
		while (cs->cmdbuf != NULL)
			complete_cb(cs);
		spin_unlock_irqrestore(&cs->cmdlock, flags);
1929 1930
		return -ENODEV;
	}
1931
	rc = start_cbsend(cs);
1932
	spin_unlock_irqrestore(&cs->lock, flags);
1933
	return rc < 0 ? rc : cb->len;
1934 1935 1936 1937
}

/* gigaset_write_room
 * tty_driver.write_room interface routine
1938 1939
 * return number of characters the driver will accept to be written via
 * gigaset_write_cmd
1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959
 * parameter:
 *	controller state structure
 * return value:
 *	number of characters
 */
static int gigaset_write_room(struct cardstate *cs)
{
	return IF_WRITEBUF;
}

/* gigaset_chars_in_buffer
 * tty_driver.chars_in_buffer interface routine
 * return number of characters waiting to be sent
 * parameter:
 *	controller state structure
 * return value:
 *	number of characters
 */
static int gigaset_chars_in_buffer(struct cardstate *cs)
{
T
Tilman Schmidt 已提交
1960
	return cs->cmdbytes;
1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986
}

/* gigaset_brkchars
 * implementation of ioctl(GIGASET_BRKCHARS)
 * parameter:
 *	controller state structure
 * return value:
 *	-EINVAL (unimplemented function)
 */
static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
{
	return -EINVAL;
}


/* Device Initialization/Shutdown */
/* ============================== */

/* Free hardware dependent part of the B channel structure
 * parameter:
 *	bcs	B channel structure
 * return value:
 *	!=0 on success
 */
static int gigaset_freebcshw(struct bc_state *bcs)
{
1987 1988 1989 1990
	struct bas_bc_state *ubc = bcs->hw.bas;
	int i;

	if (!ubc)
1991 1992
		return 0;

1993
	/* kill URBs and tasklets before freeing - better safe than sorry */
T
Tilman Schmidt 已提交
1994
	ubc->running = 0;
1995 1996 1997 1998 1999 2000 2001 2002 2003
	gig_dbg(DEBUG_INIT, "%s: killing iso URBs", __func__);
	for (i = 0; i < BAS_OUTURBS; ++i) {
		usb_kill_urb(ubc->isoouturbs[i].urb);
		usb_free_urb(ubc->isoouturbs[i].urb);
	}
	for (i = 0; i < BAS_INURBS; ++i) {
		usb_kill_urb(ubc->isoinurbs[i]);
		usb_free_urb(ubc->isoinurbs[i]);
	}
2004 2005 2006 2007
	tasklet_kill(&ubc->sent_tasklet);
	tasklet_kill(&ubc->rcvd_tasklet);
	kfree(ubc->isooutbuf);
	kfree(ubc);
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024
	bcs->hw.bas = NULL;
	return 1;
}

/* Initialize hardware dependent part of the B channel structure
 * parameter:
 *	bcs	B channel structure
 * return value:
 *	!=0 on success
 */
static int gigaset_initbcshw(struct bc_state *bcs)
{
	int i;
	struct bas_bc_state *ubc;

	bcs->hw.bas = ubc = kmalloc(sizeof(struct bas_bc_state), GFP_KERNEL);
	if (!ubc) {
2025
		pr_err("out of memory\n");
2026 2027 2028
		return 0;
	}

T
Tilman Schmidt 已提交
2029
	ubc->running = 0;
2030 2031 2032 2033 2034 2035 2036 2037
	atomic_set(&ubc->corrbytes, 0);
	spin_lock_init(&ubc->isooutlock);
	for (i = 0; i < BAS_OUTURBS; ++i) {
		ubc->isoouturbs[i].urb = NULL;
		ubc->isoouturbs[i].bcs = bcs;
	}
	ubc->isooutdone = ubc->isooutfree = ubc->isooutovfl = NULL;
	ubc->numsub = 0;
T
Tilman Schmidt 已提交
2038 2039
	ubc->isooutbuf = kmalloc(sizeof(struct isowbuf_t), GFP_KERNEL);
	if (!ubc->isooutbuf) {
2040
		pr_err("out of memory\n");
2041 2042 2043 2044 2045
		kfree(ubc);
		bcs->hw.bas = NULL;
		return 0;
	}
	tasklet_init(&ubc->sent_tasklet,
2046
		     write_iso_tasklet, (unsigned long) bcs);
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066

	spin_lock_init(&ubc->isoinlock);
	for (i = 0; i < BAS_INURBS; ++i)
		ubc->isoinurbs[i] = NULL;
	ubc->isoindone = NULL;
	ubc->loststatus = -EINPROGRESS;
	ubc->isoinlost = 0;
	ubc->seqlen = 0;
	ubc->inbyte = 0;
	ubc->inbits = 0;
	ubc->goodbytes = 0;
	ubc->alignerrs = 0;
	ubc->fcserrs = 0;
	ubc->frameerrs = 0;
	ubc->giants = 0;
	ubc->runts = 0;
	ubc->aborts = 0;
	ubc->shared0s = 0;
	ubc->stolen0s = 0;
	tasklet_init(&ubc->rcvd_tasklet,
2067
		     read_iso_tasklet, (unsigned long) bcs);
2068 2069 2070 2071 2072 2073 2074
	return 1;
}

static void gigaset_reinitbcshw(struct bc_state *bcs)
{
	struct bas_bc_state *ubc = bcs->hw.bas;

T
Tilman Schmidt 已提交
2075
	bcs->hw.bas->running = 0;
2076 2077 2078 2079 2080 2081 2082 2083 2084
	atomic_set(&bcs->hw.bas->corrbytes, 0);
	bcs->hw.bas->numsub = 0;
	spin_lock_init(&ubc->isooutlock);
	spin_lock_init(&ubc->isoinlock);
	ubc->loststatus = -EINPROGRESS;
}

static void gigaset_freecshw(struct cardstate *cs)
{
2085
	/* timers, URBs and rcvbuf are disposed of in disconnect */
2086
	kfree(cs->hw.bas->int_in_buf);
2087
	kfree(cs->hw.bas);
2088
	cs->hw.bas = NULL;
2089 2090 2091 2092 2093 2094 2095
}

static int gigaset_initcshw(struct cardstate *cs)
{
	struct bas_cardstate *ucs;

	cs->hw.bas = ucs = kmalloc(sizeof *ucs, GFP_KERNEL);
2096 2097
	if (!ucs) {
		pr_err("out of memory\n");
2098
		return 0;
2099
	}
2100 2101 2102 2103 2104 2105
	ucs->int_in_buf = kmalloc(IP_MSGSIZE, GFP_KERNEL);
	if (!ucs->int_in_buf) {
		kfree(ucs);
		pr_err("out of memory\n");
		return 0;
	}
2106 2107 2108 2109 2110 2111 2112 2113 2114

	ucs->urb_cmd_in = NULL;
	ucs->urb_cmd_out = NULL;
	ucs->rcvbuf = NULL;
	ucs->rcvbuf_size = 0;

	spin_lock_init(&ucs->lock);
	ucs->pending = 0;

T
Tilman Schmidt 已提交
2115
	ucs->basstate = 0;
2116 2117 2118
	setup_timer(&ucs->timer_ctrl, req_timeout, (unsigned long) cs);
	setup_timer(&ucs->timer_atrdy, atrdy_timeout, (unsigned long) cs);
	setup_timer(&ucs->timer_cmd_in, cmd_in_timeout, (unsigned long) cs);
T
Tilman Schmidt 已提交
2119
	init_waitqueue_head(&ucs->waitqueue);
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131

	return 1;
}

/* freeurbs
 * unlink and deallocate all URBs unconditionally
 * caller must make sure that no commands are still in progress
 * parameter:
 *	cs	controller state structure
 */
static void freeurbs(struct cardstate *cs)
{
2132
	struct bas_cardstate *ucs = cs->hw.bas;
2133 2134 2135
	struct bas_bc_state *ubc;
	int i, j;

2136
	gig_dbg(DEBUG_INIT, "%s: killing URBs", __func__);
T
Tilman Schmidt 已提交
2137
	for (j = 0; j < BAS_CHANNELS; ++j) {
2138
		ubc = cs->bcs[j].hw.bas;
2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
		for (i = 0; i < BAS_OUTURBS; ++i) {
			usb_kill_urb(ubc->isoouturbs[i].urb);
			usb_free_urb(ubc->isoouturbs[i].urb);
			ubc->isoouturbs[i].urb = NULL;
		}
		for (i = 0; i < BAS_INURBS; ++i) {
			usb_kill_urb(ubc->isoinurbs[i]);
			usb_free_urb(ubc->isoinurbs[i]);
			ubc->isoinurbs[i] = NULL;
		}
2149
	}
2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
	usb_kill_urb(ucs->urb_int_in);
	usb_free_urb(ucs->urb_int_in);
	ucs->urb_int_in = NULL;
	usb_kill_urb(ucs->urb_cmd_out);
	usb_free_urb(ucs->urb_cmd_out);
	ucs->urb_cmd_out = NULL;
	usb_kill_urb(ucs->urb_cmd_in);
	usb_free_urb(ucs->urb_cmd_in);
	ucs->urb_cmd_in = NULL;
	usb_kill_urb(ucs->urb_ctrl);
	usb_free_urb(ucs->urb_ctrl);
	ucs->urb_ctrl = NULL;
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177
}

/* gigaset_probe
 * This function is called when a new USB device is connected.
 * It checks whether the new device is handled by this driver.
 */
static int gigaset_probe(struct usb_interface *interface,
			 const struct usb_device_id *id)
{
	struct usb_host_interface *hostif;
	struct usb_device *udev = interface_to_usbdev(interface);
	struct cardstate *cs = NULL;
	struct bas_cardstate *ucs = NULL;
	struct bas_bc_state *ubc;
	struct usb_endpoint_descriptor *endpoint;
	int i, j;
2178
	int rc;
2179

T
Tilman Schmidt 已提交
2180
	gig_dbg(DEBUG_INIT,
2181 2182 2183
		"%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
		__func__, le16_to_cpu(udev->descriptor.idVendor),
		le16_to_cpu(udev->descriptor.idProduct));
2184 2185 2186 2187

	/* set required alternate setting */
	hostif = interface->cur_altsetting;
	if (hostif->desc.bAlternateSetting != 3) {
T
Tilman Schmidt 已提交
2188
		gig_dbg(DEBUG_INIT,
2189 2190
			"%s: wrong alternate setting %d - trying to switch",
			__func__, hostif->desc.bAlternateSetting);
T
Tilman Schmidt 已提交
2191 2192
		if (usb_set_interface(udev, hostif->desc.bInterfaceNumber, 3)
		    < 0) {
2193 2194 2195 2196
			dev_warn(&udev->dev, "usb_set_interface failed, "
				 "device %d interface %d altsetting %d\n",
				 udev->devnum, hostif->desc.bInterfaceNumber,
				 hostif->desc.bAlternateSetting);
2197 2198 2199 2200 2201 2202 2203 2204
			return -ENODEV;
		}
		hostif = interface->cur_altsetting;
	}

	/* Reject application specific interfaces
	 */
	if (hostif->desc.bInterfaceClass != 255) {
2205 2206
		dev_warn(&udev->dev, "%s: bInterfaceClass == %d\n",
			 __func__, hostif->desc.bInterfaceClass);
2207 2208 2209
		return -ENODEV;
	}

2210 2211 2212 2213
	dev_info(&udev->dev,
		 "%s: Device matched (Vendor: 0x%x, Product: 0x%x)\n",
		 __func__, le16_to_cpu(udev->descriptor.idVendor),
		 le16_to_cpu(udev->descriptor.idProduct));
2214

T
Tilman Schmidt 已提交
2215 2216 2217 2218
	/* allocate memory for our device state and intialize it */
	cs = gigaset_initcs(driver, BAS_CHANNELS, 0, 0, cidmode,
			    GIGASET_MODULENAME);
	if (!cs)
2219 2220
		return -ENODEV;
	ucs = cs->hw.bas;
2221 2222 2223

	/* save off device structure ptrs for later use */
	usb_get_dev(udev);
2224 2225
	ucs->udev = udev;
	ucs->interface = interface;
2226
	cs->dev = &interface->dev;
2227 2228 2229 2230 2231 2232

	/* allocate URBs:
	 * - one for the interrupt pipe
	 * - three for the different uses of the default control pipe
	 * - three for each isochronous pipe
	 */
2233 2234 2235 2236
	if (!(ucs->urb_int_in = usb_alloc_urb(0, GFP_KERNEL)) ||
	    !(ucs->urb_cmd_in = usb_alloc_urb(0, GFP_KERNEL)) ||
	    !(ucs->urb_cmd_out = usb_alloc_urb(0, GFP_KERNEL)) ||
	    !(ucs->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL)))
2237
		goto allocerr;
2238

T
Tilman Schmidt 已提交
2239
	for (j = 0; j < BAS_CHANNELS; ++j) {
2240
		ubc = cs->bcs[j].hw.bas;
2241 2242
		for (i = 0; i < BAS_OUTURBS; ++i)
			if (!(ubc->isoouturbs[i].urb =
2243
			      usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL)))
2244 2245 2246
				goto allocerr;
		for (i = 0; i < BAS_INURBS; ++i)
			if (!(ubc->isoinurbs[i] =
2247
			      usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL)))
2248
				goto allocerr;
2249 2250 2251 2252 2253 2254 2255 2256
	}

	ucs->rcvbuf = NULL;
	ucs->rcvbuf_size = 0;

	/* Fill the interrupt urb and send it to the core */
	endpoint = &hostif->endpoint[0].desc;
	usb_fill_int_urb(ucs->urb_int_in, udev,
2257 2258
			 usb_rcvintpipe(udev,
					(endpoint->bEndpointAddress) & 0x0f),
2259
			 ucs->int_in_buf, IP_MSGSIZE, read_int_callback, cs,
2260
			 endpoint->bInterval);
T
Tilman Schmidt 已提交
2261 2262
	rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL);
	if (rc != 0) {
2263
		dev_err(cs->dev, "could not submit interrupt URB: %s\n",
2264
			get_usb_rcmsg(rc));
2265 2266 2267 2268
		goto error;
	}

	/* tell the device that the driver is ready */
T
Tilman Schmidt 已提交
2269 2270
	rc = req_submit(cs->bcs, HD_DEVICE_INIT_ACK, 0, 0);
	if (rc != 0)
2271 2272 2273 2274
		goto error;

	/* tell common part that the device is ready */
	if (startmode == SM_LOCKED)
T
Tilman Schmidt 已提交
2275
		cs->mstate = MS_LOCKED;
2276 2277 2278 2279

	/* save address of controller structure */
	usb_set_intfdata(interface, cs);

2280 2281 2282
	if (!gigaset_start(cs))
		goto error;

2283 2284
	return 0;

2285 2286
allocerr:
	dev_err(cs->dev, "could not allocate URBs\n");
2287 2288
error:
	freeurbs(cs);
2289
	usb_set_intfdata(interface, NULL);
T
Tilman Schmidt 已提交
2290
	gigaset_freecs(cs);
2291 2292 2293 2294 2295 2296 2297 2298 2299 2300
	return -ENODEV;
}

/* gigaset_disconnect
 * This function is called when the Gigaset base is unplugged.
 */
static void gigaset_disconnect(struct usb_interface *interface)
{
	struct cardstate *cs;
	struct bas_cardstate *ucs;
2301
	int j;
2302 2303 2304 2305 2306

	cs = usb_get_intfdata(interface);

	ucs = cs->hw.bas;

2307
	dev_info(cs->dev, "disconnecting Gigaset base\n");
2308 2309

	/* mark base as not ready, all channels disconnected */
T
Tilman Schmidt 已提交
2310
	ucs->basstate = 0;
2311 2312

	/* tell LL all channels are down */
T
Tilman Schmidt 已提交
2313
	for (j = 0; j < BAS_CHANNELS; ++j)
2314 2315 2316
		gigaset_bchannel_down(cs->bcs + j);

	/* stop driver (common part) */
2317
	gigaset_stop(cs);
2318 2319 2320 2321 2322

	/* stop timers and URBs, free ressources */
	del_timer_sync(&ucs->timer_ctrl);
	del_timer_sync(&ucs->timer_atrdy);
	del_timer_sync(&ucs->timer_cmd_in);
2323
	freeurbs(cs);
2324
	usb_set_intfdata(interface, NULL);
2325 2326 2327
	kfree(ucs->rcvbuf);
	ucs->rcvbuf = NULL;
	ucs->rcvbuf_size = 0;
2328 2329 2330 2331
	usb_put_dev(ucs->udev);
	ucs->interface = NULL;
	ucs->udev = NULL;
	cs->dev = NULL;
T
Tilman Schmidt 已提交
2332
	gigaset_freecs(cs);
2333 2334
}

T
Tilman Schmidt 已提交
2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351
/* gigaset_suspend
 * This function is called before the USB connection is suspended.
 */
static int gigaset_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct cardstate *cs = usb_get_intfdata(intf);
	struct bas_cardstate *ucs = cs->hw.bas;
	int rc;

	/* set suspend flag; this stops AT command/response traffic */
	if (update_basstate(ucs, BS_SUSPEND, 0) & BS_SUSPEND) {
		gig_dbg(DEBUG_SUSPEND, "already suspended");
		return 0;
	}

	/* wait a bit for blocking conditions to go away */
	rc = wait_event_timeout(ucs->waitqueue,
T
Tilman Schmidt 已提交
2352
			!(ucs->basstate &
T
Tilman Schmidt 已提交
2353 2354 2355 2356 2357
			  (BS_B1OPEN|BS_B2OPEN|BS_ATRDPEND|BS_ATWRPEND)),
			BAS_TIMEOUT*HZ/10);
	gig_dbg(DEBUG_SUSPEND, "wait_event_timeout() -> %d", rc);

	/* check for conditions preventing suspend */
T
Tilman Schmidt 已提交
2358
	if (ucs->basstate & (BS_B1OPEN|BS_B2OPEN|BS_ATRDPEND|BS_ATWRPEND)) {
T
Tilman Schmidt 已提交
2359
		dev_warn(cs->dev, "cannot suspend:\n");
T
Tilman Schmidt 已提交
2360
		if (ucs->basstate & BS_B1OPEN)
T
Tilman Schmidt 已提交
2361
			dev_warn(cs->dev, " B channel 1 open\n");
T
Tilman Schmidt 已提交
2362
		if (ucs->basstate & BS_B2OPEN)
T
Tilman Schmidt 已提交
2363
			dev_warn(cs->dev, " B channel 2 open\n");
T
Tilman Schmidt 已提交
2364
		if (ucs->basstate & BS_ATRDPEND)
T
Tilman Schmidt 已提交
2365
			dev_warn(cs->dev, " receiving AT reply\n");
T
Tilman Schmidt 已提交
2366
		if (ucs->basstate & BS_ATWRPEND)
T
Tilman Schmidt 已提交
2367 2368 2369 2370 2371 2372
			dev_warn(cs->dev, " sending AT command\n");
		update_basstate(ucs, 0, BS_SUSPEND);
		return -EBUSY;
	}

	/* close AT channel if open */
T
Tilman Schmidt 已提交
2373
	if (ucs->basstate & BS_ATOPEN) {
T
Tilman Schmidt 已提交
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
		gig_dbg(DEBUG_SUSPEND, "closing AT channel");
		rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, 0);
		if (rc) {
			update_basstate(ucs, 0, BS_SUSPEND);
			return rc;
		}
		wait_event_timeout(ucs->waitqueue, !ucs->pending,
				   BAS_TIMEOUT*HZ/10);
		/* in case of timeout, proceed anyway */
	}

	/* kill all URBs and timers that might still be pending */
	usb_kill_urb(ucs->urb_ctrl);
	usb_kill_urb(ucs->urb_int_in);
	del_timer_sync(&ucs->timer_ctrl);
2389 2390
	del_timer_sync(&ucs->timer_atrdy);
	del_timer_sync(&ucs->timer_cmd_in);
T
Tilman Schmidt 已提交
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440

	gig_dbg(DEBUG_SUSPEND, "suspend complete");
	return 0;
}

/* gigaset_resume
 * This function is called after the USB connection has been resumed.
 */
static int gigaset_resume(struct usb_interface *intf)
{
	struct cardstate *cs = usb_get_intfdata(intf);
	struct bas_cardstate *ucs = cs->hw.bas;
	int rc;

	/* resubmit interrupt URB for spontaneous messages from base */
	rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL);
	if (rc) {
		dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
			get_usb_rcmsg(rc));
		return rc;
	}

	/* clear suspend flag to reallow activity */
	update_basstate(ucs, 0, BS_SUSPEND);

	gig_dbg(DEBUG_SUSPEND, "resume complete");
	return 0;
}

/* gigaset_pre_reset
 * This function is called before the USB connection is reset.
 */
static int gigaset_pre_reset(struct usb_interface *intf)
{
	/* handle just like suspend */
	return gigaset_suspend(intf, PMSG_ON);
}

/* gigaset_post_reset
 * This function is called after the USB connection has been reset.
 */
static int gigaset_post_reset(struct usb_interface *intf)
{
	/* FIXME: send HD_DEVICE_INIT_ACK? */

	/* resume operations */
	return gigaset_resume(intf);
}


2441
static const struct gigaset_ops gigops = {
2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
	gigaset_write_cmd,
	gigaset_write_room,
	gigaset_chars_in_buffer,
	gigaset_brkchars,
	gigaset_init_bchannel,
	gigaset_close_bchannel,
	gigaset_initbcshw,
	gigaset_freebcshw,
	gigaset_reinitbcshw,
	gigaset_initcshw,
	gigaset_freecshw,
	gigaset_set_modem_ctrl,
	gigaset_baud_rate,
	gigaset_set_line_ctrl,
	gigaset_isoc_send_skb,
	gigaset_isoc_input,
};

/* bas_gigaset_init
 * This function is called after the kernel module is loaded.
 */
static int __init bas_gigaset_init(void)
{
	int result;

	/* allocate memory for our driver state and intialize it */
T
Tilman Schmidt 已提交
2468 2469 2470 2471
	driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
				    GIGASET_MODULENAME, GIGASET_DEVNAME,
				    &gigops, THIS_MODULE);
	if (driver == NULL)
2472 2473 2474 2475 2476
		goto error;

	/* register this driver with the USB subsystem */
	result = usb_register(&gigaset_usb_driver);
	if (result < 0) {
2477
		pr_err("error %d registering USB driver\n", -result);
2478 2479 2480
		goto error;
	}

2481
	pr_info(DRIVER_DESC "\n");
2482 2483
	return 0;

T
Tilman Schmidt 已提交
2484
error:
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495
	if (driver)
		gigaset_freedriver(driver);
	driver = NULL;
	return -1;
}

/* bas_gigaset_exit
 * This function is called before the kernel module is unloaded.
 */
static void __exit bas_gigaset_exit(void)
{
T
Tilman Schmidt 已提交
2496 2497
	struct bas_cardstate *ucs;
	int i;
2498

2499
	gigaset_blockdriver(driver); /* => probe will fail
2500 2501
				      * => no gigaset_start any more
				      */
2502

T
Tilman Schmidt 已提交
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532
	/* stop all connected devices */
	for (i = 0; i < driver->minors; i++) {
		if (gigaset_shutdown(driver->cs + i) < 0)
			continue;		/* no device */
		/* from now on, no isdn callback should be possible */

		/* close all still open channels */
		ucs = driver->cs[i].hw.bas;
		if (ucs->basstate & BS_B1OPEN) {
			gig_dbg(DEBUG_INIT, "closing B1 channel");
			usb_control_msg(ucs->udev,
					usb_sndctrlpipe(ucs->udev, 0),
					HD_CLOSE_B1CHANNEL, OUT_VENDOR_REQ,
					0, 0, NULL, 0, BAS_TIMEOUT);
		}
		if (ucs->basstate & BS_B2OPEN) {
			gig_dbg(DEBUG_INIT, "closing B2 channel");
			usb_control_msg(ucs->udev,
					usb_sndctrlpipe(ucs->udev, 0),
					HD_CLOSE_B2CHANNEL, OUT_VENDOR_REQ,
					0, 0, NULL, 0, BAS_TIMEOUT);
		}
		if (ucs->basstate & BS_ATOPEN) {
			gig_dbg(DEBUG_INIT, "closing AT channel");
			usb_control_msg(ucs->udev,
					usb_sndctrlpipe(ucs->udev, 0),
					HD_CLOSE_ATCHANNEL, OUT_VENDOR_REQ,
					0, 0, NULL, 0, BAS_TIMEOUT);
		}
		ucs->basstate = 0;
2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
	}

	/* deregister this driver with the USB subsystem */
	usb_deregister(&gigaset_usb_driver);
	/* this will call the disconnect-callback */
	/* from now on, no disconnect/probe callback should be running */

	gigaset_freedriver(driver);
	driver = NULL;
}


module_init(bas_gigaset_init);
module_exit(bas_gigaset_exit);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");