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 .disable_hub_initiated_lpm = 1, 152}; 153 154/* get message text for usb_submit_urb return code 155 */ 156static char *get_usb_rcmsg(int rc) 157{ 158 static char unkmsg[28]; 159 160 switch (rc) { 161 case 0: 162 return "success"; 163 case -ENOMEM: 164 return "out of memory"; 165 case -ENODEV: 166 return "device not present"; 167 case -ENOENT: 168 return "endpoint not present"; 169 case -ENXIO: 170 return "URB type not supported"; 171 case -EINVAL: 172 return "invalid argument"; 173 case -EAGAIN: 174 return "start frame too early or too much scheduled"; 175 case -EFBIG: 176 return "too many isoc frames requested"; 177 case -EPIPE: 178 return "endpoint stalled"; 179 case -EMSGSIZE: 180 return "invalid packet size"; 181 case -ENOSPC: 182 return "would overcommit USB bandwidth"; 183 case -ESHUTDOWN: 184 return "device shut down"; 185 case -EPERM: 186 return "reject flag set"; 187 case -EHOSTUNREACH: 188 return "device suspended"; 189 default: 190 snprintf(unkmsg, sizeof(unkmsg), "unknown error %d", rc); 191 return unkmsg; 192 } 193} 194 195/* get message text for USB status code 196 */ 197static char *get_usb_statmsg(int status) 198{ 199 static char unkmsg[28]; 200 201 switch (status) { 202 case 0: 203 return "success"; 204 case -ENOENT: 205 return "unlinked (sync)"; 206 case -EINPROGRESS: 207 return "URB still pending"; 208 case -EPROTO: 209 return "bitstuff error, timeout, or unknown USB error"; 210 case -EILSEQ: 211 return "CRC mismatch, timeout, or unknown USB error"; 212 case -ETIME: 213 return "USB response timeout"; 214 case -EPIPE: 215 return "endpoint stalled"; 216 case -ECOMM: 217 return "IN buffer overrun"; 218 case -ENOSR: 219 return "OUT buffer underrun"; 220 case -EOVERFLOW: 221 return "endpoint babble"; 222 case -EREMOTEIO: 223 return "short packet"; 224 case -ENODEV: 225 return "device removed"; 226 case -EXDEV: 227 return "partial isoc transfer"; 228 case -EINVAL: 229 return "ISO madness"; 230 case -ECONNRESET: 231 return "unlinked (async)"; 232 case -ESHUTDOWN: 233 return "device shut down"; 234 default: 235 snprintf(unkmsg, sizeof(unkmsg), "unknown status %d", status); 236 return unkmsg; 237 } 238} 239 240/* usb_pipetype_str 241 * retrieve string representation of USB pipe type 242 */ 243static inline char *usb_pipetype_str(int pipe) 244{ 245 if (usb_pipeisoc(pipe)) 246 return "Isoc"; 247 if (usb_pipeint(pipe)) 248 return "Int"; 249 if (usb_pipecontrol(pipe)) 250 return "Ctrl"; 251 if (usb_pipebulk(pipe)) 252 return "Bulk"; 253 return "?"; 254} 255 256/* dump_urb 257 * write content of URB to syslog for debugging 258 */ 259static inline void dump_urb(enum debuglevel level, const char *tag, 260 struct urb *urb) 261{ 262#ifdef CONFIG_GIGASET_DEBUG 263 int i; 264 gig_dbg(level, "%s urb(0x%08lx)->{", tag, (unsigned long) urb); 265 if (urb) { 266 gig_dbg(level, 267 " dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, " 268 "hcpriv=0x%08lx, transfer_flags=0x%x,", 269 (unsigned long) urb->dev, 270 usb_pipetype_str(urb->pipe), 271 usb_pipeendpoint(urb->pipe), usb_pipedevice(urb->pipe), 272 usb_pipein(urb->pipe) ? "in" : "out", 273 (unsigned long) urb->hcpriv, 274 urb->transfer_flags); 275 gig_dbg(level, 276 " transfer_buffer=0x%08lx[%d], actual_length=%d, " 277 "setup_packet=0x%08lx,", 278 (unsigned long) urb->transfer_buffer, 279 urb->transfer_buffer_length, urb->actual_length, 280 (unsigned long) urb->setup_packet); 281 gig_dbg(level, 282 " start_frame=%d, number_of_packets=%d, interval=%d, " 283 "error_count=%d,", 284 urb->start_frame, urb->number_of_packets, urb->interval, 285 urb->error_count); 286 gig_dbg(level, 287 " context=0x%08lx, complete=0x%08lx, " 288 "iso_frame_desc[]={", 289 (unsigned long) urb->context, 290 (unsigned long) urb->complete); 291 for (i = 0; i < urb->number_of_packets; i++) { 292 struct usb_iso_packet_descriptor *pifd 293 = &urb->iso_frame_desc[i]; 294 gig_dbg(level, 295 " {offset=%u, length=%u, actual_length=%u, " 296 "status=%u}", 297 pifd->offset, pifd->length, pifd->actual_length, 298 pifd->status); 299 } 300 } 301 gig_dbg(level, "}}"); 302#endif 303} 304 305/* read/set modem control bits etc. (m10x only) */ 306static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state, 307 unsigned new_state) 308{ 309 return -EINVAL; 310} 311 312static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag) 313{ 314 return -EINVAL; 315} 316 317static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag) 318{ 319 return -EINVAL; 320} 321 322/* set/clear bits in base connection state, return previous state 323 */ 324static inline int update_basstate(struct bas_cardstate *ucs, 325 int set, int clear) 326{ 327 unsigned long flags; 328 int state; 329 330 spin_lock_irqsave(&ucs->lock, flags); 331 state = ucs->basstate; 332 ucs->basstate = (state & ~clear) | set; 333 spin_unlock_irqrestore(&ucs->lock, flags); 334 return state; 335} 336 337/* error_hangup 338 * hang up any existing connection because of an unrecoverable error 339 * This function may be called from any context and takes care of scheduling 340 * the necessary actions for execution outside of interrupt context. 341 * cs->lock must not be held. 342 * argument: 343 * B channel control structure 344 */ 345static inline void error_hangup(struct bc_state *bcs) 346{ 347 struct cardstate *cs = bcs->cs; 348 349 gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL); 350 gigaset_schedule_event(cs); 351} 352 353/* error_reset 354 * reset Gigaset device because of an unrecoverable error 355 * This function may be called from any context, and takes care of 356 * scheduling the necessary actions for execution outside of interrupt context. 357 * cs->hw.bas->lock must not be held. 358 * argument: 359 * controller state structure 360 */ 361static inline void error_reset(struct cardstate *cs) 362{ 363 /* reset interrupt pipe to recover (ignore errors) */ 364 update_basstate(cs->hw.bas, BS_RESETTING, 0); 365 if (req_submit(cs->bcs, HD_RESET_INTERRUPT_PIPE, 0, BAS_TIMEOUT)) 366 /* submission failed, escalate to USB port reset */ 367 usb_queue_reset_device(cs->hw.bas->interface); 368} 369 370/* check_pending 371 * check for completion of pending control request 372 * parameter: 373 * ucs hardware specific controller state structure 374 */ 375static void check_pending(struct bas_cardstate *ucs) 376{ 377 unsigned long flags; 378 379 spin_lock_irqsave(&ucs->lock, flags); 380 switch (ucs->pending) { 381 case 0: 382 break; 383 case HD_OPEN_ATCHANNEL: 384 if (ucs->basstate & BS_ATOPEN) 385 ucs->pending = 0; 386 break; 387 case HD_OPEN_B1CHANNEL: 388 if (ucs->basstate & BS_B1OPEN) 389 ucs->pending = 0; 390 break; 391 case HD_OPEN_B2CHANNEL: 392 if (ucs->basstate & BS_B2OPEN) 393 ucs->pending = 0; 394 break; 395 case HD_CLOSE_ATCHANNEL: 396 if (!(ucs->basstate & BS_ATOPEN)) 397 ucs->pending = 0; 398 break; 399 case HD_CLOSE_B1CHANNEL: 400 if (!(ucs->basstate & BS_B1OPEN)) 401 ucs->pending = 0; 402 break; 403 case HD_CLOSE_B2CHANNEL: 404 if (!(ucs->basstate & BS_B2OPEN)) 405 ucs->pending = 0; 406 break; 407 case HD_DEVICE_INIT_ACK: /* no reply expected */ 408 ucs->pending = 0; 409 break; 410 case HD_RESET_INTERRUPT_PIPE: 411 if (!(ucs->basstate & BS_RESETTING)) 412 ucs->pending = 0; 413 break; 414 /* 415 * HD_READ_ATMESSAGE and HD_WRITE_ATMESSAGE are handled separately 416 * and should never end up here 417 */ 418 default: 419 dev_warn(&ucs->interface->dev, 420 "unknown pending request 0x%02x cleared\n", 421 ucs->pending); 422 ucs->pending = 0; 423 } 424 425 if (!ucs->pending) 426 del_timer(&ucs->timer_ctrl); 427 428 spin_unlock_irqrestore(&ucs->lock, flags); 429} 430 431/* cmd_in_timeout 432 * timeout routine for command input request 433 * argument: 434 * controller state structure 435 */ 436static void cmd_in_timeout(unsigned long data) 437{ 438 struct cardstate *cs = (struct cardstate *) data; 439 struct bas_cardstate *ucs = cs->hw.bas; 440 int rc; 441 442 if (!ucs->rcvbuf_size) { 443 gig_dbg(DEBUG_USBREQ, "%s: no receive in progress", __func__); 444 return; 445 } 446 447 if (ucs->retry_cmd_in++ >= BAS_RETRY) { 448 dev_err(cs->dev, 449 "control read: timeout, giving up after %d tries\n", 450 ucs->retry_cmd_in); 451 kfree(ucs->rcvbuf); 452 ucs->rcvbuf = NULL; 453 ucs->rcvbuf_size = 0; 454 error_reset(cs); 455 return; 456 } 457 458 gig_dbg(DEBUG_USBREQ, "%s: timeout, retry %d", 459 __func__, ucs->retry_cmd_in); 460 rc = atread_submit(cs, BAS_TIMEOUT); 461 if (rc < 0) { 462 kfree(ucs->rcvbuf); 463 ucs->rcvbuf = NULL; 464 ucs->rcvbuf_size = 0; 465 if (rc != -ENODEV) 466 error_reset(cs); 467 } 468} 469 470/* read_ctrl_callback 471 * USB completion handler for control pipe input 472 * called by the USB subsystem in interrupt context 473 * parameter: 474 * urb USB request block 475 * urb->context = inbuf structure for controller state 476 */ 477static void read_ctrl_callback(struct urb *urb) 478{ 479 struct inbuf_t *inbuf = urb->context; 480 struct cardstate *cs = inbuf->cs; 481 struct bas_cardstate *ucs = cs->hw.bas; 482 int status = urb->status; 483 unsigned numbytes; 484 int rc; 485 486 update_basstate(ucs, 0, BS_ATRDPEND); 487 wake_up(&ucs->waitqueue); 488 del_timer(&ucs->timer_cmd_in); 489 490 switch (status) { 491 case 0: /* normal completion */ 492 numbytes = urb->actual_length; 493 if (unlikely(numbytes != ucs->rcvbuf_size)) { 494 dev_warn(cs->dev, 495 "control read: received %d chars, expected %d\n", 496 numbytes, ucs->rcvbuf_size); 497 if (numbytes > ucs->rcvbuf_size) 498 numbytes = ucs->rcvbuf_size; 499 } 500 501 /* copy received bytes to inbuf, notify event layer */ 502 if (gigaset_fill_inbuf(inbuf, ucs->rcvbuf, numbytes)) { 503 gig_dbg(DEBUG_INTR, "%s-->BH", __func__); 504 gigaset_schedule_event(cs); 505 } 506 break; 507 508 case -ENOENT: /* cancelled */ 509 case -ECONNRESET: /* cancelled (async) */ 510 case -EINPROGRESS: /* pending */ 511 case -ENODEV: /* device removed */ 512 case -ESHUTDOWN: /* device shut down */ 513 /* no further action necessary */ 514 gig_dbg(DEBUG_USBREQ, "%s: %s", 515 __func__, get_usb_statmsg(status)); 516 break; 517 518 default: /* other errors: retry */ 519 if (ucs->retry_cmd_in++ < BAS_RETRY) { 520 gig_dbg(DEBUG_USBREQ, "%s: %s, retry %d", __func__, 521 get_usb_statmsg(status), ucs->retry_cmd_in); 522 rc = atread_submit(cs, BAS_TIMEOUT); 523 if (rc >= 0) 524 /* successfully resubmitted, skip freeing */ 525 return; 526 if (rc == -ENODEV) 527 /* disconnect, no further action necessary */ 528 break; 529 } 530 dev_err(cs->dev, "control read: %s, giving up after %d tries\n", 531 get_usb_statmsg(status), ucs->retry_cmd_in); 532 error_reset(cs); 533 } 534 535 /* read finished, free buffer */ 536 kfree(ucs->rcvbuf); 537 ucs->rcvbuf = NULL; 538 ucs->rcvbuf_size = 0; 539} 540 541/* atread_submit 542 * submit an HD_READ_ATMESSAGE command URB and optionally start a timeout 543 * parameters: 544 * cs controller state structure 545 * timeout timeout in 1/10 sec., 0: none 546 * return value: 547 * 0 on success 548 * -EBUSY if another request is pending 549 * any URB submission error code 550 */ 551static int atread_submit(struct cardstate *cs, int timeout) 552{ 553 struct bas_cardstate *ucs = cs->hw.bas; 554 int basstate; 555 int ret; 556 557 gig_dbg(DEBUG_USBREQ, "-------> HD_READ_ATMESSAGE (%d)", 558 ucs->rcvbuf_size); 559 560 basstate = update_basstate(ucs, BS_ATRDPEND, 0); 561 if (basstate & BS_ATRDPEND) { 562 dev_err(cs->dev, 563 "could not submit HD_READ_ATMESSAGE: URB busy\n"); 564 return -EBUSY; 565 } 566 567 if (basstate & BS_SUSPEND) { 568 dev_notice(cs->dev, 569 "HD_READ_ATMESSAGE not submitted, " 570 "suspend in progress\n"); 571 update_basstate(ucs, 0, BS_ATRDPEND); 572 /* treat like disconnect */ 573 return -ENODEV; 574 } 575 576 ucs->dr_cmd_in.bRequestType = IN_VENDOR_REQ; 577 ucs->dr_cmd_in.bRequest = HD_READ_ATMESSAGE; 578 ucs->dr_cmd_in.wValue = 0; 579 ucs->dr_cmd_in.wIndex = 0; 580 ucs->dr_cmd_in.wLength = cpu_to_le16(ucs->rcvbuf_size); 581 usb_fill_control_urb(ucs->urb_cmd_in, ucs->udev, 582 usb_rcvctrlpipe(ucs->udev, 0), 583 (unsigned char *) &ucs->dr_cmd_in, 584 ucs->rcvbuf, ucs->rcvbuf_size, 585 read_ctrl_callback, cs->inbuf); 586 587 ret = usb_submit_urb(ucs->urb_cmd_in, GFP_ATOMIC); 588 if (ret != 0) { 589 update_basstate(ucs, 0, BS_ATRDPEND); 590 dev_err(cs->dev, "could not submit HD_READ_ATMESSAGE: %s\n", 591 get_usb_rcmsg(ret)); 592 return ret; 593 } 594 595 if (timeout > 0) { 596 gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout); 597 mod_timer(&ucs->timer_cmd_in, jiffies + timeout * HZ / 10); 598 } 599 return 0; 600} 601 602/* int_in_work 603 * workqueue routine to clear halt on interrupt in endpoint 604 */ 605 606static void int_in_work(struct work_struct *work) 607{ 608 struct bas_cardstate *ucs = 609 container_of(work, struct bas_cardstate, int_in_wq); 610 struct urb *urb = ucs->urb_int_in; 611 struct cardstate *cs = urb->context; 612 int rc; 613 614 /* clear halt condition */ 615 rc = usb_clear_halt(ucs->udev, urb->pipe); 616 gig_dbg(DEBUG_USBREQ, "clear_halt: %s", get_usb_rcmsg(rc)); 617 if (rc == 0) 618 /* success, resubmit interrupt read URB */ 619 rc = usb_submit_urb(urb, GFP_ATOMIC); 620 621 switch (rc) { 622 case 0: /* success */ 623 case -ENODEV: /* device gone */ 624 case -EINVAL: /* URB already resubmitted, or terminal badness */ 625 break; 626 default: /* failure: try to recover by resetting the device */ 627 dev_err(cs->dev, "clear halt failed: %s\n", get_usb_rcmsg(rc)); 628 rc = usb_lock_device_for_reset(ucs->udev, ucs->interface); 629 if (rc == 0) { 630 rc = usb_reset_device(ucs->udev); 631 usb_unlock_device(ucs->udev); 632 } 633 } 634 ucs->retry_int_in = 0; 635} 636 637/* int_in_resubmit 638 * timer routine for interrupt read delayed resubmit 639 * argument: 640 * controller state structure 641 */ 642static void int_in_resubmit(unsigned long data) 643{ 644 struct cardstate *cs = (struct cardstate *) data; 645 struct bas_cardstate *ucs = cs->hw.bas; 646 int rc; 647 648 if (ucs->retry_int_in++ >= BAS_RETRY) { 649 dev_err(cs->dev, "interrupt read: giving up after %d tries\n", 650 ucs->retry_int_in); 651 usb_queue_reset_device(ucs->interface); 652 return; 653 } 654 655 gig_dbg(DEBUG_USBREQ, "%s: retry %d", __func__, ucs->retry_int_in); 656 rc = usb_submit_urb(ucs->urb_int_in, GFP_ATOMIC); 657 if (rc != 0 && rc != -ENODEV) { 658 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n", 659 get_usb_rcmsg(rc)); 660 usb_queue_reset_device(ucs->interface); 661 } 662} 663 664/* read_int_callback 665 * USB completion handler for interrupt pipe input 666 * called by the USB subsystem in interrupt context 667 * parameter: 668 * urb USB request block 669 * urb->context = controller state structure 670 */ 671static void read_int_callback(struct urb *urb) 672{ 673 struct cardstate *cs = urb->context; 674 struct bas_cardstate *ucs = cs->hw.bas; 675 struct bc_state *bcs; 676 int status = urb->status; 677 unsigned long flags; 678 int rc; 679 unsigned l; 680 int channel; 681 682 switch (status) { 683 case 0: /* success */ 684 ucs->retry_int_in = 0; 685 break; 686 case -EPIPE: /* endpoint stalled */ 687 schedule_work(&ucs->int_in_wq); 688 /* fall through */ 689 case -ENOENT: /* cancelled */ 690 case -ECONNRESET: /* cancelled (async) */ 691 case -EINPROGRESS: /* pending */ 692 case -ENODEV: /* device removed */ 693 case -ESHUTDOWN: /* device shut down */ 694 /* no further action necessary */ 695 gig_dbg(DEBUG_USBREQ, "%s: %s", 696 __func__, get_usb_statmsg(status)); 697 return; 698 case -EPROTO: /* protocol error or unplug */ 699 case -EILSEQ: 700 case -ETIME: 701 /* resubmit after delay */ 702 gig_dbg(DEBUG_USBREQ, "%s: %s", 703 __func__, get_usb_statmsg(status)); 704 mod_timer(&ucs->timer_int_in, jiffies + HZ / 10); 705 return; 706 default: /* other errors: just resubmit */ 707 dev_warn(cs->dev, "interrupt read: %s\n", 708 get_usb_statmsg(status)); 709 goto resubmit; 710 } 711 712 /* drop incomplete packets even if the missing bytes wouldn't matter */ 713 if (unlikely(urb->actual_length < IP_MSGSIZE)) { 714 dev_warn(cs->dev, "incomplete interrupt packet (%d bytes)\n", 715 urb->actual_length); 716 goto resubmit; 717 } 718 719 l = (unsigned) ucs->int_in_buf[1] + 720 (((unsigned) ucs->int_in_buf[2]) << 8); 721 722 gig_dbg(DEBUG_USBREQ, "<-------%d: 0x%02x (%u [0x%02x 0x%02x])", 723 urb->actual_length, (int)ucs->int_in_buf[0], l, 724 (int)ucs->int_in_buf[1], (int)ucs->int_in_buf[2]); 725 726 channel = 0; 727 728 switch (ucs->int_in_buf[0]) { 729 case HD_DEVICE_INIT_OK: 730 update_basstate(ucs, BS_INIT, 0); 731 break; 732 733 case HD_READY_SEND_ATDATA: 734 del_timer(&ucs->timer_atrdy); 735 update_basstate(ucs, BS_ATREADY, BS_ATTIMER); 736 start_cbsend(cs); 737 break; 738 739 case HD_OPEN_B2CHANNEL_ACK: 740 ++channel; 741 case HD_OPEN_B1CHANNEL_ACK: 742 bcs = cs->bcs + channel; 743 update_basstate(ucs, BS_B1OPEN << channel, 0); 744 gigaset_bchannel_up(bcs); 745 break; 746 747 case HD_OPEN_ATCHANNEL_ACK: 748 update_basstate(ucs, BS_ATOPEN, 0); 749 start_cbsend(cs); 750 break; 751 752 case HD_CLOSE_B2CHANNEL_ACK: 753 ++channel; 754 case HD_CLOSE_B1CHANNEL_ACK: 755 bcs = cs->bcs + channel; 756 update_basstate(ucs, 0, BS_B1OPEN << channel); 757 stopurbs(bcs->hw.bas); 758 gigaset_bchannel_down(bcs); 759 break; 760 761 case HD_CLOSE_ATCHANNEL_ACK: 762 update_basstate(ucs, 0, BS_ATOPEN); 763 break; 764 765 case HD_B2_FLOW_CONTROL: 766 ++channel; 767 case HD_B1_FLOW_CONTROL: 768 bcs = cs->bcs + channel; 769 atomic_add((l - BAS_NORMFRAME) * BAS_CORRFRAMES, 770 &bcs->hw.bas->corrbytes); 771 gig_dbg(DEBUG_ISO, 772 "Flow control (channel %d, sub %d): 0x%02x => %d", 773 channel, bcs->hw.bas->numsub, l, 774 atomic_read(&bcs->hw.bas->corrbytes)); 775 break; 776 777 case HD_RECEIVEATDATA_ACK: /* AT response ready to be received */ 778 if (!l) { 779 dev_warn(cs->dev, 780 "HD_RECEIVEATDATA_ACK with length 0 ignored\n"); 781 break; 782 } 783 spin_lock_irqsave(&cs->lock, flags); 784 if (ucs->basstate & BS_ATRDPEND) { 785 spin_unlock_irqrestore(&cs->lock, flags); 786 dev_warn(cs->dev, 787 "HD_RECEIVEATDATA_ACK(%d) during HD_READ_ATMESSAGE(%d) ignored\n", 788 l, ucs->rcvbuf_size); 789 break; 790 } 791 if (ucs->rcvbuf_size) { 792 /* throw away previous buffer - we have no queue */ 793 dev_err(cs->dev, 794 "receive AT data overrun, %d bytes lost\n", 795 ucs->rcvbuf_size); 796 kfree(ucs->rcvbuf); 797 ucs->rcvbuf_size = 0; 798 } 799 ucs->rcvbuf = kmalloc(l, GFP_ATOMIC); 800 if (ucs->rcvbuf == NULL) { 801 spin_unlock_irqrestore(&cs->lock, flags); 802 dev_err(cs->dev, "out of memory receiving AT data\n"); 803 break; 804 } 805 ucs->rcvbuf_size = l; 806 ucs->retry_cmd_in = 0; 807 rc = atread_submit(cs, BAS_TIMEOUT); 808 if (rc < 0) { 809 kfree(ucs->rcvbuf); 810 ucs->rcvbuf = NULL; 811 ucs->rcvbuf_size = 0; 812 } 813 spin_unlock_irqrestore(&cs->lock, flags); 814 if (rc < 0 && rc != -ENODEV) 815 error_reset(cs); 816 break; 817 818 case HD_RESET_INTERRUPT_PIPE_ACK: 819 update_basstate(ucs, 0, BS_RESETTING); 820 dev_notice(cs->dev, "interrupt pipe reset\n"); 821 break; 822 823 case HD_SUSPEND_END: 824 gig_dbg(DEBUG_USBREQ, "HD_SUSPEND_END"); 825 break; 826 827 default: 828 dev_warn(cs->dev, 829 "unknown Gigaset signal 0x%02x (%u) ignored\n", 830 (int) ucs->int_in_buf[0], l); 831 } 832 833 check_pending(ucs); 834 wake_up(&ucs->waitqueue); 835 836resubmit: 837 rc = usb_submit_urb(urb, GFP_ATOMIC); 838 if (unlikely(rc != 0 && rc != -ENODEV)) { 839 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n", 840 get_usb_rcmsg(rc)); 841 error_reset(cs); 842 } 843} 844 845/* read_iso_callback 846 * USB completion handler for B channel isochronous input 847 * called by the USB subsystem in interrupt context 848 * parameter: 849 * urb USB request block of completed request 850 * urb->context = bc_state structure 851 */ 852static void read_iso_callback(struct urb *urb) 853{ 854 struct bc_state *bcs; 855 struct bas_bc_state *ubc; 856 int status = urb->status; 857 unsigned long flags; 858 int i, rc; 859 860 /* status codes not worth bothering the tasklet with */ 861 if (unlikely(status == -ENOENT || 862 status == -ECONNRESET || 863 status == -EINPROGRESS || 864 status == -ENODEV || 865 status == -ESHUTDOWN)) { 866 gig_dbg(DEBUG_ISO, "%s: %s", 867 __func__, get_usb_statmsg(status)); 868 return; 869 } 870 871 bcs = urb->context; 872 ubc = bcs->hw.bas; 873 874 spin_lock_irqsave(&ubc->isoinlock, flags); 875 if (likely(ubc->isoindone == NULL)) { 876 /* pass URB to tasklet */ 877 ubc->isoindone = urb; 878 ubc->isoinstatus = status; 879 tasklet_hi_schedule(&ubc->rcvd_tasklet); 880 } else { 881 /* tasklet still busy, drop data and resubmit URB */ 882 gig_dbg(DEBUG_ISO, "%s: overrun", __func__); 883 ubc->loststatus = status; 884 for (i = 0; i < BAS_NUMFRAMES; i++) { 885 ubc->isoinlost += urb->iso_frame_desc[i].actual_length; 886 if (unlikely(urb->iso_frame_desc[i].status != 0 && 887 urb->iso_frame_desc[i].status != -EINPROGRESS)) 888 ubc->loststatus = urb->iso_frame_desc[i].status; 889 urb->iso_frame_desc[i].status = 0; 890 urb->iso_frame_desc[i].actual_length = 0; 891 } 892 if (likely(ubc->running)) { 893 /* urb->dev is clobbered by USB subsystem */ 894 urb->dev = bcs->cs->hw.bas->udev; 895 urb->transfer_flags = URB_ISO_ASAP; 896 urb->number_of_packets = BAS_NUMFRAMES; 897 rc = usb_submit_urb(urb, GFP_ATOMIC); 898 if (unlikely(rc != 0 && rc != -ENODEV)) { 899 dev_err(bcs->cs->dev, 900 "could not resubmit isoc read URB: %s\n", 901 get_usb_rcmsg(rc)); 902 dump_urb(DEBUG_ISO, "isoc read", urb); 903 error_hangup(bcs); 904 } 905 } 906 } 907 spin_unlock_irqrestore(&ubc->isoinlock, flags); 908} 909 910/* write_iso_callback 911 * USB completion handler for B channel isochronous output 912 * called by the USB subsystem in interrupt context 913 * parameter: 914 * urb USB request block of completed request 915 * urb->context = isow_urbctx_t structure 916 */ 917static void write_iso_callback(struct urb *urb) 918{ 919 struct isow_urbctx_t *ucx; 920 struct bas_bc_state *ubc; 921 int status = urb->status; 922 unsigned long flags; 923 924 /* status codes not worth bothering the tasklet with */ 925 if (unlikely(status == -ENOENT || 926 status == -ECONNRESET || 927 status == -EINPROGRESS || 928 status == -ENODEV || 929 status == -ESHUTDOWN)) { 930 gig_dbg(DEBUG_ISO, "%s: %s", 931 __func__, get_usb_statmsg(status)); 932 return; 933 } 934 935 /* pass URB context to tasklet */ 936 ucx = urb->context; 937 ubc = ucx->bcs->hw.bas; 938 ucx->status = status; 939 940 spin_lock_irqsave(&ubc->isooutlock, flags); 941 ubc->isooutovfl = ubc->isooutdone; 942 ubc->isooutdone = ucx; 943 spin_unlock_irqrestore(&ubc->isooutlock, flags); 944 tasklet_hi_schedule(&ubc->sent_tasklet); 945} 946 947/* starturbs 948 * prepare and submit USB request blocks for isochronous input and output 949 * argument: 950 * B channel control structure 951 * return value: 952 * 0 on success 953 * < 0 on error (no URBs submitted) 954 */ 955static int starturbs(struct bc_state *bcs) 956{ 957 struct bas_bc_state *ubc = bcs->hw.bas; 958 struct urb *urb; 959 int j, k; 960 int rc; 961 962 /* initialize L2 reception */ 963 if (bcs->proto2 == L2_HDLC) 964 bcs->inputstate |= INS_flag_hunt; 965 966 /* submit all isochronous input URBs */ 967 ubc->running = 1; 968 for (k = 0; k < BAS_INURBS; k++) { 969 urb = ubc->isoinurbs[k]; 970 if (!urb) { 971 rc = -EFAULT; 972 goto error; 973 } 974 975 urb->dev = bcs->cs->hw.bas->udev; 976 urb->pipe = usb_rcvisocpipe(urb->dev, 3 + 2 * bcs->channel); 977 urb->transfer_flags = URB_ISO_ASAP; 978 urb->transfer_buffer = ubc->isoinbuf + k * BAS_INBUFSIZE; 979 urb->transfer_buffer_length = BAS_INBUFSIZE; 980 urb->number_of_packets = BAS_NUMFRAMES; 981 urb->interval = BAS_FRAMETIME; 982 urb->complete = read_iso_callback; 983 urb->context = bcs; 984 for (j = 0; j < BAS_NUMFRAMES; j++) { 985 urb->iso_frame_desc[j].offset = j * BAS_MAXFRAME; 986 urb->iso_frame_desc[j].length = BAS_MAXFRAME; 987 urb->iso_frame_desc[j].status = 0; 988 urb->iso_frame_desc[j].actual_length = 0; 989 } 990 991 dump_urb(DEBUG_ISO, "Initial isoc read", urb); 992 rc = usb_submit_urb(urb, GFP_ATOMIC); 993 if (rc != 0) 994 goto error; 995 } 996 997 /* initialize L2 transmission */ 998 gigaset_isowbuf_init(ubc->isooutbuf, PPP_FLAG); 999 1000 /* set up isochronous output URBs for flag idling */ 1001 for (k = 0; k < BAS_OUTURBS; ++k) { 1002 urb = ubc->isoouturbs[k].urb; 1003 if (!urb) { 1004 rc = -EFAULT; 1005 goto error; 1006 } 1007 urb->dev = bcs->cs->hw.bas->udev; 1008 urb->pipe = usb_sndisocpipe(urb->dev, 4 + 2 * bcs->channel); 1009 urb->transfer_flags = URB_ISO_ASAP; 1010 urb->transfer_buffer = ubc->isooutbuf->data; 1011 urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data); 1012 urb->number_of_packets = BAS_NUMFRAMES; 1013 urb->interval = BAS_FRAMETIME; 1014 urb->complete = write_iso_callback; 1015 urb->context = &ubc->isoouturbs[k]; 1016 for (j = 0; j < BAS_NUMFRAMES; ++j) { 1017 urb->iso_frame_desc[j].offset = BAS_OUTBUFSIZE; 1018 urb->iso_frame_desc[j].length = BAS_NORMFRAME; 1019 urb->iso_frame_desc[j].status = 0; 1020 urb->iso_frame_desc[j].actual_length = 0; 1021 } 1022 ubc->isoouturbs[k].limit = -1; 1023 } 1024 1025 /* keep one URB free, submit the others */ 1026 for (k = 0; k < BAS_OUTURBS - 1; ++k) { 1027 dump_urb(DEBUG_ISO, "Initial isoc write", urb); 1028 rc = usb_submit_urb(ubc->isoouturbs[k].urb, GFP_ATOMIC); 1029 if (rc != 0) 1030 goto error; 1031 } 1032 dump_urb(DEBUG_ISO, "Initial isoc write (free)", urb); 1033 ubc->isooutfree = &ubc->isoouturbs[BAS_OUTURBS - 1]; 1034 ubc->isooutdone = ubc->isooutovfl = NULL; 1035 return 0; 1036error: 1037 stopurbs(ubc); 1038 return rc; 1039} 1040 1041/* stopurbs 1042 * cancel the USB request blocks for isochronous input and output 1043 * errors are silently ignored 1044 * argument: 1045 * B channel control structure 1046 */ 1047static void stopurbs(struct bas_bc_state *ubc) 1048{ 1049 int k, rc; 1050 1051 ubc->running = 0; 1052 1053 for (k = 0; k < BAS_INURBS; ++k) { 1054 rc = usb_unlink_urb(ubc->isoinurbs[k]); 1055 gig_dbg(DEBUG_ISO, 1056 "%s: isoc input URB %d unlinked, result = %s", 1057 __func__, k, get_usb_rcmsg(rc)); 1058 } 1059 1060 for (k = 0; k < BAS_OUTURBS; ++k) { 1061 rc = usb_unlink_urb(ubc->isoouturbs[k].urb); 1062 gig_dbg(DEBUG_ISO, 1063 "%s: isoc output URB %d unlinked, result = %s", 1064 __func__, k, get_usb_rcmsg(rc)); 1065 } 1066} 1067 1068/* Isochronous Write - Bottom Half */ 1069/* =============================== */ 1070 1071/* submit_iso_write_urb 1072 * fill and submit the next isochronous write URB 1073 * parameters: 1074 * ucx context structure containing URB 1075 * return value: 1076 * number of frames submitted in URB 1077 * 0 if URB not submitted because no data available (isooutbuf busy) 1078 * error code < 0 on error 1079 */ 1080static int submit_iso_write_urb(struct isow_urbctx_t *ucx) 1081{ 1082 struct urb *urb = ucx->urb; 1083 struct bas_bc_state *ubc = ucx->bcs->hw.bas; 1084 struct usb_iso_packet_descriptor *ifd; 1085 int corrbytes, nframe, rc; 1086 1087 /* urb->dev is clobbered by USB subsystem */ 1088 urb->dev = ucx->bcs->cs->hw.bas->udev; 1089 urb->transfer_flags = URB_ISO_ASAP; 1090 urb->transfer_buffer = ubc->isooutbuf->data; 1091 urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data); 1092 1093 for (nframe = 0; nframe < BAS_NUMFRAMES; nframe++) { 1094 ifd = &urb->iso_frame_desc[nframe]; 1095 1096 /* compute frame length according to flow control */ 1097 ifd->length = BAS_NORMFRAME; 1098 corrbytes = atomic_read(&ubc->corrbytes); 1099 if (corrbytes != 0) { 1100 gig_dbg(DEBUG_ISO, "%s: corrbytes=%d", 1101 __func__, corrbytes); 1102 if (corrbytes > BAS_HIGHFRAME - BAS_NORMFRAME) 1103 corrbytes = BAS_HIGHFRAME - BAS_NORMFRAME; 1104 else if (corrbytes < BAS_LOWFRAME - BAS_NORMFRAME) 1105 corrbytes = BAS_LOWFRAME - BAS_NORMFRAME; 1106 ifd->length += corrbytes; 1107 atomic_add(-corrbytes, &ubc->corrbytes); 1108 } 1109 1110 /* retrieve block of data to send */ 1111 rc = gigaset_isowbuf_getbytes(ubc->isooutbuf, ifd->length); 1112 if (rc < 0) { 1113 if (rc == -EBUSY) { 1114 gig_dbg(DEBUG_ISO, 1115 "%s: buffer busy at frame %d", 1116 __func__, nframe); 1117 /* tasklet will be restarted from 1118 gigaset_isoc_send_skb() */ 1119 } else { 1120 dev_err(ucx->bcs->cs->dev, 1121 "%s: buffer error %d at frame %d\n", 1122 __func__, rc, nframe); 1123 return rc; 1124 } 1125 break; 1126 } 1127 ifd->offset = rc; 1128 ucx->limit = ubc->isooutbuf->nextread; 1129 ifd->status = 0; 1130 ifd->actual_length = 0; 1131 } 1132 if (unlikely(nframe == 0)) 1133 return 0; /* no data to send */ 1134 urb->number_of_packets = nframe; 1135 1136 rc = usb_submit_urb(urb, GFP_ATOMIC); 1137 if (unlikely(rc)) { 1138 if (rc == -ENODEV) 1139 /* device removed - give up silently */ 1140 gig_dbg(DEBUG_ISO, "%s: disconnected", __func__); 1141 else 1142 dev_err(ucx->bcs->cs->dev, 1143 "could not submit isoc write URB: %s\n", 1144 get_usb_rcmsg(rc)); 1145 return rc; 1146 } 1147 ++ubc->numsub; 1148 return nframe; 1149} 1150 1151/* write_iso_tasklet 1152 * tasklet scheduled when an isochronous output URB from the Gigaset device 1153 * has completed 1154 * parameter: 1155 * data B channel state structure 1156 */ 1157static void write_iso_tasklet(unsigned long data) 1158{ 1159 struct bc_state *bcs = (struct bc_state *) data; 1160 struct bas_bc_state *ubc = bcs->hw.bas; 1161 struct cardstate *cs = bcs->cs; 1162 struct isow_urbctx_t *done, *next, *ovfl; 1163 struct urb *urb; 1164 int status; 1165 struct usb_iso_packet_descriptor *ifd; 1166 unsigned long flags; 1167 int i; 1168 struct sk_buff *skb; 1169 int len; 1170 int rc; 1171 1172 /* loop while completed URBs arrive in time */ 1173 for (;;) { 1174 if (unlikely(!(ubc->running))) { 1175 gig_dbg(DEBUG_ISO, "%s: not running", __func__); 1176 return; 1177 } 1178 1179 /* retrieve completed URBs */ 1180 spin_lock_irqsave(&ubc->isooutlock, flags); 1181 done = ubc->isooutdone; 1182 ubc->isooutdone = NULL; 1183 ovfl = ubc->isooutovfl; 1184 ubc->isooutovfl = NULL; 1185 spin_unlock_irqrestore(&ubc->isooutlock, flags); 1186 if (ovfl) { 1187 dev_err(cs->dev, "isoc write underrun\n"); 1188 error_hangup(bcs); 1189 break; 1190 } 1191 if (!done) 1192 break; 1193 1194 /* submit free URB if available */ 1195 spin_lock_irqsave(&ubc->isooutlock, flags); 1196 next = ubc->isooutfree; 1197 ubc->isooutfree = NULL; 1198 spin_unlock_irqrestore(&ubc->isooutlock, flags); 1199 if (next) { 1200 rc = submit_iso_write_urb(next); 1201 if (unlikely(rc <= 0 && rc != -ENODEV)) { 1202 /* could not submit URB, put it back */ 1203 spin_lock_irqsave(&ubc->isooutlock, flags); 1204 if (ubc->isooutfree == NULL) { 1205 ubc->isooutfree = next; 1206 next = NULL; 1207 } 1208 spin_unlock_irqrestore(&ubc->isooutlock, flags); 1209 if (next) { 1210 /* couldn't put it back */ 1211 dev_err(cs->dev, 1212 "losing isoc write URB\n"); 1213 error_hangup(bcs); 1214 } 1215 } 1216 } 1217 1218 /* process completed URB */ 1219 urb = done->urb; 1220 status = done->status; 1221 switch (status) { 1222 case -EXDEV: /* partial completion */ 1223 gig_dbg(DEBUG_ISO, "%s: URB partially completed", 1224 __func__); 1225 /* fall through - what's the difference anyway? */ 1226 case 0: /* normal completion */ 1227 /* inspect individual frames 1228 * assumptions (for lack of documentation): 1229 * - actual_length bytes of first frame in error are 1230 * successfully sent 1231 * - all following frames are not sent at all 1232 */ 1233 for (i = 0; i < BAS_NUMFRAMES; i++) { 1234 ifd = &urb->iso_frame_desc[i]; 1235 if (ifd->status || 1236 ifd->actual_length != ifd->length) { 1237 dev_warn(cs->dev, 1238 "isoc write: frame %d[%d/%d]: %s\n", 1239 i, ifd->actual_length, 1240 ifd->length, 1241 get_usb_statmsg(ifd->status)); 1242 break; 1243 } 1244 } 1245 break; 1246 case -EPIPE: /* stall - probably underrun */ 1247 dev_err(cs->dev, "isoc write: stalled\n"); 1248 error_hangup(bcs); 1249 break; 1250 default: /* other errors */ 1251 dev_warn(cs->dev, "isoc write: %s\n", 1252 get_usb_statmsg(status)); 1253 } 1254 1255 /* mark the write buffer area covered by this URB as free */ 1256 if (done->limit >= 0) 1257 ubc->isooutbuf->read = done->limit; 1258 1259 /* mark URB as free */ 1260 spin_lock_irqsave(&ubc->isooutlock, flags); 1261 next = ubc->isooutfree; 1262 ubc->isooutfree = done; 1263 spin_unlock_irqrestore(&ubc->isooutlock, flags); 1264 if (next) { 1265 /* only one URB still active - resubmit one */ 1266 rc = submit_iso_write_urb(next); 1267 if (unlikely(rc <= 0 && rc != -ENODEV)) { 1268 /* couldn't submit */ 1269 error_hangup(bcs); 1270 } 1271 } 1272 } 1273 1274 /* process queued SKBs */ 1275 while ((skb = skb_dequeue(&bcs->squeue))) { 1276 /* copy to output buffer, doing L2 encapsulation */ 1277 len = skb->len; 1278 if (gigaset_isoc_buildframe(bcs, skb->data, len) == -EAGAIN) { 1279 /* insufficient buffer space, push back onto queue */ 1280 skb_queue_head(&bcs->squeue, skb); 1281 gig_dbg(DEBUG_ISO, "%s: skb requeued, qlen=%d", 1282 __func__, skb_queue_len(&bcs->squeue)); 1283 break; 1284 } 1285 skb_pull(skb, len); 1286 gigaset_skb_sent(bcs, skb); 1287 dev_kfree_skb_any(skb); 1288 } 1289} 1290 1291/* Isochronous Read - Bottom Half */ 1292/* ============================== */ 1293 1294/* read_iso_tasklet 1295 * tasklet scheduled when an isochronous input URB from the Gigaset device 1296 * has completed 1297 * parameter: 1298 * data B channel state structure 1299 */ 1300static void read_iso_tasklet(unsigned long data) 1301{ 1302 struct bc_state *bcs = (struct bc_state *) data; 1303 struct bas_bc_state *ubc = bcs->hw.bas; 1304 struct cardstate *cs = bcs->cs; 1305 struct urb *urb; 1306 int status; 1307 struct usb_iso_packet_descriptor *ifd; 1308 char *rcvbuf; 1309 unsigned long flags; 1310 int totleft, numbytes, offset, frame, rc; 1311 1312 /* loop while more completed URBs arrive in the meantime */ 1313 for (;;) { 1314 /* retrieve URB */ 1315 spin_lock_irqsave(&ubc->isoinlock, flags); 1316 urb = ubc->isoindone; 1317 if (!urb) { 1318 spin_unlock_irqrestore(&ubc->isoinlock, flags); 1319 return; 1320 } 1321 status = ubc->isoinstatus; 1322 ubc->isoindone = NULL; 1323 if (unlikely(ubc->loststatus != -EINPROGRESS)) { 1324 dev_warn(cs->dev, 1325 "isoc read overrun, URB dropped (status: %s, %d bytes)\n", 1326 get_usb_statmsg(ubc->loststatus), 1327 ubc->isoinlost); 1328 ubc->loststatus = -EINPROGRESS; 1329 } 1330 spin_unlock_irqrestore(&ubc->isoinlock, flags); 1331 1332 if (unlikely(!(ubc->running))) { 1333 gig_dbg(DEBUG_ISO, 1334 "%s: channel not running, " 1335 "dropped URB with status: %s", 1336 __func__, get_usb_statmsg(status)); 1337 return; 1338 } 1339 1340 switch (status) { 1341 case 0: /* normal completion */ 1342 break; 1343 case -EXDEV: /* inspect individual frames 1344 (we do that anyway) */ 1345 gig_dbg(DEBUG_ISO, "%s: URB partially completed", 1346 __func__); 1347 break; 1348 case -ENOENT: 1349 case -ECONNRESET: 1350 case -EINPROGRESS: 1351 gig_dbg(DEBUG_ISO, "%s: %s", 1352 __func__, get_usb_statmsg(status)); 1353 continue; /* -> skip */ 1354 case -EPIPE: 1355 dev_err(cs->dev, "isoc read: stalled\n"); 1356 error_hangup(bcs); 1357 continue; /* -> skip */ 1358 default: /* other error */ 1359 dev_warn(cs->dev, "isoc read: %s\n", 1360 get_usb_statmsg(status)); 1361 goto error; 1362 } 1363 1364 rcvbuf = urb->transfer_buffer; 1365 totleft = urb->actual_length; 1366 for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) { 1367 ifd = &urb->iso_frame_desc[frame]; 1368 numbytes = ifd->actual_length; 1369 switch (ifd->status) { 1370 case 0: /* success */ 1371 break; 1372 case -EPROTO: /* protocol error or unplug */ 1373 case -EILSEQ: 1374 case -ETIME: 1375 /* probably just disconnected, ignore */ 1376 gig_dbg(DEBUG_ISO, 1377 "isoc read: frame %d[%d]: %s\n", 1378 frame, numbytes, 1379 get_usb_statmsg(ifd->status)); 1380 break; 1381 default: /* other error */ 1382 /* report, assume transferred bytes are ok */ 1383 dev_warn(cs->dev, 1384 "isoc read: frame %d[%d]: %s\n", 1385 frame, numbytes, 1386 get_usb_statmsg(ifd->status)); 1387 } 1388 if (unlikely(numbytes > BAS_MAXFRAME)) 1389 dev_warn(cs->dev, 1390 "isoc read: frame %d[%d]: %s\n", 1391 frame, numbytes, 1392 "exceeds max frame size"); 1393 if (unlikely(numbytes > totleft)) { 1394 dev_warn(cs->dev, 1395 "isoc read: frame %d[%d]: %s\n", 1396 frame, numbytes, 1397 "exceeds total transfer length"); 1398 numbytes = totleft; 1399 } 1400 offset = ifd->offset; 1401 if (unlikely(offset + numbytes > BAS_INBUFSIZE)) { 1402 dev_warn(cs->dev, 1403 "isoc read: frame %d[%d]: %s\n", 1404 frame, numbytes, 1405 "exceeds end of buffer"); 1406 numbytes = BAS_INBUFSIZE - offset; 1407 } 1408 gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs); 1409 totleft -= numbytes; 1410 } 1411 if (unlikely(totleft > 0)) 1412 dev_warn(cs->dev, "isoc read: %d data bytes missing\n", 1413 totleft); 1414 1415error: 1416 /* URB processed, resubmit */ 1417 for (frame = 0; frame < BAS_NUMFRAMES; frame++) { 1418 urb->iso_frame_desc[frame].status = 0; 1419 urb->iso_frame_desc[frame].actual_length = 0; 1420 } 1421 /* urb->dev is clobbered by USB subsystem */ 1422 urb->dev = bcs->cs->hw.bas->udev; 1423 urb->transfer_flags = URB_ISO_ASAP; 1424 urb->number_of_packets = BAS_NUMFRAMES; 1425 rc = usb_submit_urb(urb, GFP_ATOMIC); 1426 if (unlikely(rc != 0 && rc != -ENODEV)) { 1427 dev_err(cs->dev, 1428 "could not resubmit isoc read URB: %s\n", 1429 get_usb_rcmsg(rc)); 1430 dump_urb(DEBUG_ISO, "resubmit isoc read", urb); 1431 error_hangup(bcs); 1432 } 1433 } 1434} 1435 1436/* Channel Operations */ 1437/* ================== */ 1438 1439/* req_timeout 1440 * timeout routine for control output request 1441 * argument: 1442 * controller state structure 1443 */ 1444static void req_timeout(unsigned long data) 1445{ 1446 struct cardstate *cs = (struct cardstate *) data; 1447 struct bas_cardstate *ucs = cs->hw.bas; 1448 int pending; 1449 unsigned long flags; 1450 1451 check_pending(ucs); 1452 1453 spin_lock_irqsave(&ucs->lock, flags); 1454 pending = ucs->pending; 1455 ucs->pending = 0; 1456 spin_unlock_irqrestore(&ucs->lock, flags); 1457 1458 switch (pending) { 1459 case 0: /* no pending request */ 1460 gig_dbg(DEBUG_USBREQ, "%s: no request pending", __func__); 1461 break; 1462 1463 case HD_OPEN_ATCHANNEL: 1464 dev_err(cs->dev, "timeout opening AT channel\n"); 1465 error_reset(cs); 1466 break; 1467 1468 case HD_OPEN_B1CHANNEL: 1469 dev_err(cs->dev, "timeout opening channel 1\n"); 1470 error_hangup(&cs->bcs[0]); 1471 break; 1472 1473 case HD_OPEN_B2CHANNEL: 1474 dev_err(cs->dev, "timeout opening channel 2\n"); 1475 error_hangup(&cs->bcs[1]); 1476 break; 1477 1478 case HD_CLOSE_ATCHANNEL: 1479 dev_err(cs->dev, "timeout closing AT channel\n"); 1480 error_reset(cs); 1481 break; 1482 1483 case HD_CLOSE_B1CHANNEL: 1484 dev_err(cs->dev, "timeout closing channel 1\n"); 1485 error_reset(cs); 1486 break; 1487 1488 case HD_CLOSE_B2CHANNEL: 1489 dev_err(cs->dev, "timeout closing channel 2\n"); 1490 error_reset(cs); 1491 break; 1492 1493 case HD_RESET_INTERRUPT_PIPE: 1494 /* error recovery escalation */ 1495 dev_err(cs->dev, 1496 "reset interrupt pipe timeout, attempting USB reset\n"); 1497 usb_queue_reset_device(ucs->interface); 1498 break; 1499 1500 default: 1501 dev_warn(cs->dev, "request 0x%02x timed out, clearing\n", 1502 pending); 1503 } 1504 1505 wake_up(&ucs->waitqueue); 1506} 1507 1508/* write_ctrl_callback 1509 * USB completion handler for control pipe output 1510 * called by the USB subsystem in interrupt context 1511 * parameter: 1512 * urb USB request block of completed request 1513 * urb->context = hardware specific controller state structure 1514 */ 1515static void write_ctrl_callback(struct urb *urb) 1516{ 1517 struct bas_cardstate *ucs = urb->context; 1518 int status = urb->status; 1519 int rc; 1520 unsigned long flags; 1521 1522 /* check status */ 1523 switch (status) { 1524 case 0: /* normal completion */ 1525 spin_lock_irqsave(&ucs->lock, flags); 1526 switch (ucs->pending) { 1527 case HD_DEVICE_INIT_ACK: /* no reply expected */ 1528 del_timer(&ucs->timer_ctrl); 1529 ucs->pending = 0; 1530 break; 1531 } 1532 spin_unlock_irqrestore(&ucs->lock, flags); 1533 return; 1534 1535 case -ENOENT: /* cancelled */ 1536 case -ECONNRESET: /* cancelled (async) */ 1537 case -EINPROGRESS: /* pending */ 1538 case -ENODEV: /* device removed */ 1539 case -ESHUTDOWN: /* device shut down */ 1540 /* ignore silently */ 1541 gig_dbg(DEBUG_USBREQ, "%s: %s", 1542 __func__, get_usb_statmsg(status)); 1543 break; 1544 1545 default: /* any failure */ 1546 /* don't retry if suspend requested */ 1547 if (++ucs->retry_ctrl > BAS_RETRY || 1548 (ucs->basstate & BS_SUSPEND)) { 1549 dev_err(&ucs->interface->dev, 1550 "control request 0x%02x failed: %s\n", 1551 ucs->dr_ctrl.bRequest, 1552 get_usb_statmsg(status)); 1553 break; /* give up */ 1554 } 1555 dev_notice(&ucs->interface->dev, 1556 "control request 0x%02x: %s, retry %d\n", 1557 ucs->dr_ctrl.bRequest, get_usb_statmsg(status), 1558 ucs->retry_ctrl); 1559 /* urb->dev is clobbered by USB subsystem */ 1560 urb->dev = ucs->udev; 1561 rc = usb_submit_urb(urb, GFP_ATOMIC); 1562 if (unlikely(rc)) { 1563 dev_err(&ucs->interface->dev, 1564 "could not resubmit request 0x%02x: %s\n", 1565 ucs->dr_ctrl.bRequest, get_usb_rcmsg(rc)); 1566 break; 1567 } 1568 /* resubmitted */ 1569 return; 1570 } 1571 1572 /* failed, clear pending request */ 1573 spin_lock_irqsave(&ucs->lock, flags); 1574 del_timer(&ucs->timer_ctrl); 1575 ucs->pending = 0; 1576 spin_unlock_irqrestore(&ucs->lock, flags); 1577 wake_up(&ucs->waitqueue); 1578} 1579 1580/* req_submit 1581 * submit a control output request without message buffer to the Gigaset base 1582 * and optionally start a timeout 1583 * parameters: 1584 * bcs B channel control structure 1585 * req control request code (HD_*) 1586 * val control request parameter value (set to 0 if unused) 1587 * timeout timeout in seconds (0: no timeout) 1588 * return value: 1589 * 0 on success 1590 * -EBUSY if another request is pending 1591 * any URB submission error code 1592 */ 1593static int req_submit(struct bc_state *bcs, int req, int val, int timeout) 1594{ 1595 struct bas_cardstate *ucs = bcs->cs->hw.bas; 1596 int ret; 1597 unsigned long flags; 1598 1599 gig_dbg(DEBUG_USBREQ, "-------> 0x%02x (%d)", req, val); 1600 1601 spin_lock_irqsave(&ucs->lock, flags); 1602 if (ucs->pending) { 1603 spin_unlock_irqrestore(&ucs->lock, flags); 1604 dev_err(bcs->cs->dev, 1605 "submission of request 0x%02x failed: " 1606 "request 0x%02x still pending\n", 1607 req, ucs->pending); 1608 return -EBUSY; 1609 } 1610 1611 ucs->dr_ctrl.bRequestType = OUT_VENDOR_REQ; 1612 ucs->dr_ctrl.bRequest = req; 1613 ucs->dr_ctrl.wValue = cpu_to_le16(val); 1614 ucs->dr_ctrl.wIndex = 0; 1615 ucs->dr_ctrl.wLength = 0; 1616 usb_fill_control_urb(ucs->urb_ctrl, ucs->udev, 1617 usb_sndctrlpipe(ucs->udev, 0), 1618 (unsigned char *) &ucs->dr_ctrl, NULL, 0, 1619 write_ctrl_callback, ucs); 1620 ucs->retry_ctrl = 0; 1621 ret = usb_submit_urb(ucs->urb_ctrl, GFP_ATOMIC); 1622 if (unlikely(ret)) { 1623 dev_err(bcs->cs->dev, "could not submit request 0x%02x: %s\n", 1624 req, get_usb_rcmsg(ret)); 1625 spin_unlock_irqrestore(&ucs->lock, flags); 1626 return ret; 1627 } 1628 ucs->pending = req; 1629 1630 if (timeout > 0) { 1631 gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout); 1632 mod_timer(&ucs->timer_ctrl, jiffies + timeout * HZ / 10); 1633 } 1634 1635 spin_unlock_irqrestore(&ucs->lock, flags); 1636 return 0; 1637} 1638 1639/* gigaset_init_bchannel 1640 * called by common.c to connect a B channel 1641 * initialize isochronous I/O and tell the Gigaset base to open the channel 1642 * argument: 1643 * B channel control structure 1644 * return value: 1645 * 0 on success, error code < 0 on error 1646 */ 1647static int gigaset_init_bchannel(struct bc_state *bcs) 1648{ 1649 struct cardstate *cs = bcs->cs; 1650 int req, ret; 1651 unsigned long flags; 1652 1653 spin_lock_irqsave(&cs->lock, flags); 1654 if (unlikely(!cs->connected)) { 1655 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__); 1656 spin_unlock_irqrestore(&cs->lock, flags); 1657 return -ENODEV; 1658 } 1659 1660 if (cs->hw.bas->basstate & BS_SUSPEND) { 1661 dev_notice(cs->dev, 1662 "not starting isoc I/O, suspend in progress\n"); 1663 spin_unlock_irqrestore(&cs->lock, flags); 1664 return -EHOSTUNREACH; 1665 } 1666 1667 ret = starturbs(bcs); 1668 if (ret < 0) { 1669 spin_unlock_irqrestore(&cs->lock, flags); 1670 dev_err(cs->dev, 1671 "could not start isoc I/O for channel B%d: %s\n", 1672 bcs->channel + 1, 1673 ret == -EFAULT ? "null URB" : get_usb_rcmsg(ret)); 1674 if (ret != -ENODEV) 1675 error_hangup(bcs); 1676 return ret; 1677 } 1678 1679 req = bcs->channel ? HD_OPEN_B2CHANNEL : HD_OPEN_B1CHANNEL; 1680 ret = req_submit(bcs, req, 0, BAS_TIMEOUT); 1681 if (ret < 0) { 1682 dev_err(cs->dev, "could not open channel B%d\n", 1683 bcs->channel + 1); 1684 stopurbs(bcs->hw.bas); 1685 } 1686 1687 spin_unlock_irqrestore(&cs->lock, flags); 1688 if (ret < 0 && ret != -ENODEV) 1689 error_hangup(bcs); 1690 return ret; 1691} 1692 1693/* gigaset_close_bchannel 1694 * called by common.c to disconnect a B channel 1695 * tell the Gigaset base to close the channel 1696 * stopping isochronous I/O and LL notification will be done when the 1697 * acknowledgement for the close arrives 1698 * argument: 1699 * B channel control structure 1700 * return value: 1701 * 0 on success, error code < 0 on error 1702 */ 1703static int gigaset_close_bchannel(struct bc_state *bcs) 1704{ 1705 struct cardstate *cs = bcs->cs; 1706 int req, ret; 1707 unsigned long flags; 1708 1709 spin_lock_irqsave(&cs->lock, flags); 1710 if (unlikely(!cs->connected)) { 1711 spin_unlock_irqrestore(&cs->lock, flags); 1712 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__); 1713 return -ENODEV; 1714 } 1715 1716 if (!(cs->hw.bas->basstate & (bcs->channel ? BS_B2OPEN : BS_B1OPEN))) { 1717 /* channel not running: just signal common.c */ 1718 spin_unlock_irqrestore(&cs->lock, flags); 1719 gigaset_bchannel_down(bcs); 1720 return 0; 1721 } 1722 1723 /* channel running: tell device to close it */ 1724 req = bcs->channel ? HD_CLOSE_B2CHANNEL : HD_CLOSE_B1CHANNEL; 1725 ret = req_submit(bcs, req, 0, BAS_TIMEOUT); 1726 if (ret < 0) 1727 dev_err(cs->dev, "closing channel B%d failed\n", 1728 bcs->channel + 1); 1729 1730 spin_unlock_irqrestore(&cs->lock, flags); 1731 return ret; 1732} 1733 1734/* Device Operations */ 1735/* ================= */ 1736 1737/* complete_cb 1738 * unqueue first command buffer from queue, waking any sleepers 1739 * must be called with cs->cmdlock held 1740 * parameter: 1741 * cs controller state structure 1742 */ 1743static void complete_cb(struct cardstate *cs) 1744{ 1745 struct cmdbuf_t *cb = cs->cmdbuf; 1746 1747 /* unqueue completed buffer */ 1748 cs->cmdbytes -= cs->curlen; 1749 gig_dbg(DEBUG_OUTPUT, "write_command: sent %u bytes, %u left", 1750 cs->curlen, cs->cmdbytes); 1751 if (cb->next != NULL) { 1752 cs->cmdbuf = cb->next; 1753 cs->cmdbuf->prev = NULL; 1754 cs->curlen = cs->cmdbuf->len; 1755 } else { 1756 cs->cmdbuf = NULL; 1757 cs->lastcmdbuf = NULL; 1758 cs->curlen = 0; 1759 } 1760 1761 if (cb->wake_tasklet) 1762 tasklet_schedule(cb->wake_tasklet); 1763 1764 kfree(cb); 1765} 1766 1767/* write_command_callback 1768 * USB completion handler for AT command transmission 1769 * called by the USB subsystem in interrupt context 1770 * parameter: 1771 * urb USB request block of completed request 1772 * urb->context = controller state structure 1773 */ 1774static void write_command_callback(struct urb *urb) 1775{ 1776 struct cardstate *cs = urb->context; 1777 struct bas_cardstate *ucs = cs->hw.bas; 1778 int status = urb->status; 1779 unsigned long flags; 1780 1781 update_basstate(ucs, 0, BS_ATWRPEND); 1782 wake_up(&ucs->waitqueue); 1783 1784 /* check status */ 1785 switch (status) { 1786 case 0: /* normal completion */ 1787 break; 1788 case -ENOENT: /* cancelled */ 1789 case -ECONNRESET: /* cancelled (async) */ 1790 case -EINPROGRESS: /* pending */ 1791 case -ENODEV: /* device removed */ 1792 case -ESHUTDOWN: /* device shut down */ 1793 /* ignore silently */ 1794 gig_dbg(DEBUG_USBREQ, "%s: %s", 1795 __func__, get_usb_statmsg(status)); 1796 return; 1797 default: /* any failure */ 1798 if (++ucs->retry_cmd_out > BAS_RETRY) { 1799 dev_warn(cs->dev, 1800 "command write: %s, " 1801 "giving up after %d retries\n", 1802 get_usb_statmsg(status), 1803 ucs->retry_cmd_out); 1804 break; 1805 } 1806 if (ucs->basstate & BS_SUSPEND) { 1807 dev_warn(cs->dev, 1808 "command write: %s, " 1809 "won't retry - suspend requested\n", 1810 get_usb_statmsg(status)); 1811 break; 1812 } 1813 if (cs->cmdbuf == NULL) { 1814 dev_warn(cs->dev, 1815 "command write: %s, " 1816 "cannot retry - cmdbuf gone\n", 1817 get_usb_statmsg(status)); 1818 break; 1819 } 1820 dev_notice(cs->dev, "command write: %s, retry %d\n", 1821 get_usb_statmsg(status), ucs->retry_cmd_out); 1822 if (atwrite_submit(cs, cs->cmdbuf->buf, cs->cmdbuf->len) >= 0) 1823 /* resubmitted - bypass regular exit block */ 1824 return; 1825 /* command send failed, assume base still waiting */ 1826 update_basstate(ucs, BS_ATREADY, 0); 1827 } 1828 1829 spin_lock_irqsave(&cs->cmdlock, flags); 1830 if (cs->cmdbuf != NULL) 1831 complete_cb(cs); 1832 spin_unlock_irqrestore(&cs->cmdlock, flags); 1833} 1834 1835/* atrdy_timeout 1836 * timeout routine for AT command transmission 1837 * argument: 1838 * controller state structure 1839 */ 1840static void atrdy_timeout(unsigned long data) 1841{ 1842 struct cardstate *cs = (struct cardstate *) data; 1843 struct bas_cardstate *ucs = cs->hw.bas; 1844 1845 dev_warn(cs->dev, "timeout waiting for HD_READY_SEND_ATDATA\n"); 1846 1847 /* fake the missing signal - what else can I do? */ 1848 update_basstate(ucs, BS_ATREADY, BS_ATTIMER); 1849 start_cbsend(cs); 1850} 1851 1852/* atwrite_submit 1853 * submit an HD_WRITE_ATMESSAGE command URB 1854 * parameters: 1855 * cs controller state structure 1856 * buf buffer containing command to send 1857 * len length of command to send 1858 * return value: 1859 * 0 on success 1860 * -EBUSY if another request is pending 1861 * any URB submission error code 1862 */ 1863static int atwrite_submit(struct cardstate *cs, unsigned char *buf, int len) 1864{ 1865 struct bas_cardstate *ucs = cs->hw.bas; 1866 int rc; 1867 1868 gig_dbg(DEBUG_USBREQ, "-------> HD_WRITE_ATMESSAGE (%d)", len); 1869 1870 if (update_basstate(ucs, BS_ATWRPEND, 0) & BS_ATWRPEND) { 1871 dev_err(cs->dev, 1872 "could not submit HD_WRITE_ATMESSAGE: URB busy\n"); 1873 return -EBUSY; 1874 } 1875 1876 ucs->dr_cmd_out.bRequestType = OUT_VENDOR_REQ; 1877 ucs->dr_cmd_out.bRequest = HD_WRITE_ATMESSAGE; 1878 ucs->dr_cmd_out.wValue = 0; 1879 ucs->dr_cmd_out.wIndex = 0; 1880 ucs->dr_cmd_out.wLength = cpu_to_le16(len); 1881 usb_fill_control_urb(ucs->urb_cmd_out, ucs->udev, 1882 usb_sndctrlpipe(ucs->udev, 0), 1883 (unsigned char *) &ucs->dr_cmd_out, buf, len, 1884 write_command_callback, cs); 1885 rc = usb_submit_urb(ucs->urb_cmd_out, GFP_ATOMIC); 1886 if (unlikely(rc)) { 1887 update_basstate(ucs, 0, BS_ATWRPEND); 1888 dev_err(cs->dev, "could not submit HD_WRITE_ATMESSAGE: %s\n", 1889 get_usb_rcmsg(rc)); 1890 return rc; 1891 } 1892 1893 /* submitted successfully, start timeout if necessary */ 1894 if (!(update_basstate(ucs, BS_ATTIMER, BS_ATREADY) & BS_ATTIMER)) { 1895 gig_dbg(DEBUG_OUTPUT, "setting ATREADY timeout of %d/10 secs", 1896 ATRDY_TIMEOUT); 1897 mod_timer(&ucs->timer_atrdy, jiffies + ATRDY_TIMEOUT * HZ / 10); 1898 } 1899 return 0; 1900} 1901 1902/* start_cbsend 1903 * start transmission of AT command queue if necessary 1904 * parameter: 1905 * cs controller state structure 1906 * return value: 1907 * 0 on success 1908 * error code < 0 on error 1909 */ 1910static int start_cbsend(struct cardstate *cs) 1911{ 1912 struct cmdbuf_t *cb; 1913 struct bas_cardstate *ucs = cs->hw.bas; 1914 unsigned long flags; 1915 int rc; 1916 int retval = 0; 1917 1918 /* check if suspend requested */ 1919 if (ucs->basstate & BS_SUSPEND) { 1920 gig_dbg(DEBUG_OUTPUT, "suspending"); 1921 return -EHOSTUNREACH; 1922 } 1923 1924 /* check if AT channel is open */ 1925 if (!(ucs->basstate & BS_ATOPEN)) { 1926 gig_dbg(DEBUG_OUTPUT, "AT channel not open"); 1927 rc = req_submit(cs->bcs, HD_OPEN_ATCHANNEL, 0, BAS_TIMEOUT); 1928 if (rc < 0) { 1929 /* flush command queue */ 1930 spin_lock_irqsave(&cs->cmdlock, flags); 1931 while (cs->cmdbuf != NULL) 1932 complete_cb(cs); 1933 spin_unlock_irqrestore(&cs->cmdlock, flags); 1934 } 1935 return rc; 1936 } 1937 1938 /* try to send first command in queue */ 1939 spin_lock_irqsave(&cs->cmdlock, flags); 1940 1941 while ((cb = cs->cmdbuf) != NULL && (ucs->basstate & BS_ATREADY)) { 1942 ucs->retry_cmd_out = 0; 1943 rc = atwrite_submit(cs, cb->buf, cb->len); 1944 if (unlikely(rc)) { 1945 retval = rc; 1946 complete_cb(cs); 1947 } 1948 } 1949 1950 spin_unlock_irqrestore(&cs->cmdlock, flags); 1951 return retval; 1952} 1953 1954/* gigaset_write_cmd 1955 * This function is called by the device independent part of the driver 1956 * to transmit an AT command string to the Gigaset device. 1957 * It encapsulates the device specific method for transmission over the 1958 * direct USB connection to the base. 1959 * The command string is added to the queue of commands to send, and 1960 * USB transmission is started if necessary. 1961 * parameters: 1962 * cs controller state structure 1963 * cb command buffer structure 1964 * return value: 1965 * number of bytes queued on success 1966 * error code < 0 on error 1967 */ 1968static int gigaset_write_cmd(struct cardstate *cs, struct cmdbuf_t *cb) 1969{ 1970 unsigned long flags; 1971 int rc; 1972 1973 gigaset_dbg_buffer(cs->mstate != MS_LOCKED ? 1974 DEBUG_TRANSCMD : DEBUG_LOCKCMD, 1975 "CMD Transmit", cb->len, cb->buf); 1976 1977 /* translate "+++" escape sequence sent as a single separate command 1978 * into "close AT channel" command for error recovery 1979 * The next command will reopen the AT channel automatically. 1980 */ 1981 if (cb->len == 3 && !memcmp(cb->buf, "+++", 3)) { 1982 /* If an HD_RECEIVEATDATA_ACK message remains unhandled 1983 * because of an error, the base never sends another one. 1984 * The response channel is thus effectively blocked. 1985 * Closing and reopening the AT channel does *not* clear 1986 * this condition. 1987 * As a stopgap measure, submit a zero-length AT read 1988 * before closing the AT channel. This has the undocumented 1989 * effect of triggering a new HD_RECEIVEATDATA_ACK message 1990 * from the base if necessary. 1991 * The subsequent AT channel close then discards any pending 1992 * messages. 1993 */ 1994 spin_lock_irqsave(&cs->lock, flags); 1995 if (!(cs->hw.bas->basstate & BS_ATRDPEND)) { 1996 kfree(cs->hw.bas->rcvbuf); 1997 cs->hw.bas->rcvbuf = NULL; 1998 cs->hw.bas->rcvbuf_size = 0; 1999 cs->hw.bas->retry_cmd_in = 0; 2000 atread_submit(cs, 0); 2001 } 2002 spin_unlock_irqrestore(&cs->lock, flags); 2003 2004 rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT); 2005 if (cb->wake_tasklet) 2006 tasklet_schedule(cb->wake_tasklet); 2007 if (!rc) 2008 rc = cb->len; 2009 kfree(cb); 2010 return rc; 2011 } 2012 2013 spin_lock_irqsave(&cs->cmdlock, flags); 2014 cb->prev = cs->lastcmdbuf; 2015 if (cs->lastcmdbuf) 2016 cs->lastcmdbuf->next = cb; 2017 else { 2018 cs->cmdbuf = cb; 2019 cs->curlen = cb->len; 2020 } 2021 cs->cmdbytes += cb->len; 2022 cs->lastcmdbuf = cb; 2023 spin_unlock_irqrestore(&cs->cmdlock, flags); 2024 2025 spin_lock_irqsave(&cs->lock, flags); 2026 if (unlikely(!cs->connected)) { 2027 spin_unlock_irqrestore(&cs->lock, flags); 2028 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__); 2029 /* flush command queue */ 2030 spin_lock_irqsave(&cs->cmdlock, flags); 2031 while (cs->cmdbuf != NULL) 2032 complete_cb(cs); 2033 spin_unlock_irqrestore(&cs->cmdlock, flags); 2034 return -ENODEV; 2035 } 2036 rc = start_cbsend(cs); 2037 spin_unlock_irqrestore(&cs->lock, flags); 2038 return rc < 0 ? rc : cb->len; 2039} 2040 2041/* gigaset_write_room 2042 * tty_driver.write_room interface routine 2043 * return number of characters the driver will accept to be written via 2044 * gigaset_write_cmd 2045 * parameter: 2046 * controller state structure 2047 * return value: 2048 * number of characters 2049 */ 2050static int gigaset_write_room(struct cardstate *cs) 2051{ 2052 return IF_WRITEBUF; 2053} 2054 2055/* gigaset_chars_in_buffer 2056 * tty_driver.chars_in_buffer interface routine 2057 * return number of characters waiting to be sent 2058 * parameter: 2059 * controller state structure 2060 * return value: 2061 * number of characters 2062 */ 2063static int gigaset_chars_in_buffer(struct cardstate *cs) 2064{ 2065 return cs->cmdbytes; 2066} 2067 2068/* gigaset_brkchars 2069 * implementation of ioctl(GIGASET_BRKCHARS) 2070 * parameter: 2071 * controller state structure 2072 * return value: 2073 * -EINVAL (unimplemented function) 2074 */ 2075static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6]) 2076{ 2077 return -EINVAL; 2078} 2079 2080 2081/* Device Initialization/Shutdown */ 2082/* ============================== */ 2083 2084/* Free hardware dependent part of the B channel structure 2085 * parameter: 2086 * bcs B channel structure 2087 */ 2088static void gigaset_freebcshw(struct bc_state *bcs) 2089{ 2090 struct bas_bc_state *ubc = bcs->hw.bas; 2091 int i; 2092 2093 if (!ubc) 2094 return; 2095 2096 /* kill URBs and tasklets before freeing - better safe than sorry */ 2097 ubc->running = 0; 2098 gig_dbg(DEBUG_INIT, "%s: killing isoc URBs", __func__); 2099 for (i = 0; i < BAS_OUTURBS; ++i) { 2100 usb_kill_urb(ubc->isoouturbs[i].urb); 2101 usb_free_urb(ubc->isoouturbs[i].urb); 2102 } 2103 for (i = 0; i < BAS_INURBS; ++i) { 2104 usb_kill_urb(ubc->isoinurbs[i]); 2105 usb_free_urb(ubc->isoinurbs[i]); 2106 } 2107 tasklet_kill(&ubc->sent_tasklet); 2108 tasklet_kill(&ubc->rcvd_tasklet); 2109 kfree(ubc->isooutbuf); 2110 kfree(ubc); 2111 bcs->hw.bas = NULL; 2112} 2113 2114/* Initialize hardware dependent part of the B channel structure 2115 * parameter: 2116 * bcs B channel structure 2117 * return value: 2118 * 0 on success, error code < 0 on failure 2119 */ 2120static int gigaset_initbcshw(struct bc_state *bcs) 2121{ 2122 int i; 2123 struct bas_bc_state *ubc; 2124 2125 bcs->hw.bas = ubc = kmalloc(sizeof(struct bas_bc_state), GFP_KERNEL); 2126 if (!ubc) { 2127 pr_err("out of memory\n"); 2128 return -ENOMEM; 2129 } 2130 2131 ubc->running = 0; 2132 atomic_set(&ubc->corrbytes, 0); 2133 spin_lock_init(&ubc->isooutlock); 2134 for (i = 0; i < BAS_OUTURBS; ++i) { 2135 ubc->isoouturbs[i].urb = NULL; 2136 ubc->isoouturbs[i].bcs = bcs; 2137 } 2138 ubc->isooutdone = ubc->isooutfree = ubc->isooutovfl = NULL; 2139 ubc->numsub = 0; 2140 ubc->isooutbuf = kmalloc(sizeof(struct isowbuf_t), GFP_KERNEL); 2141 if (!ubc->isooutbuf) { 2142 pr_err("out of memory\n"); 2143 kfree(ubc); 2144 bcs->hw.bas = NULL; 2145 return -ENOMEM; 2146 } 2147 tasklet_init(&ubc->sent_tasklet, 2148 write_iso_tasklet, (unsigned long) bcs); 2149 2150 spin_lock_init(&ubc->isoinlock); 2151 for (i = 0; i < BAS_INURBS; ++i) 2152 ubc->isoinurbs[i] = NULL; 2153 ubc->isoindone = NULL; 2154 ubc->loststatus = -EINPROGRESS; 2155 ubc->isoinlost = 0; 2156 ubc->seqlen = 0; 2157 ubc->inbyte = 0; 2158 ubc->inbits = 0; 2159 ubc->goodbytes = 0; 2160 ubc->alignerrs = 0; 2161 ubc->fcserrs = 0; 2162 ubc->frameerrs = 0; 2163 ubc->giants = 0; 2164 ubc->runts = 0; 2165 ubc->aborts = 0; 2166 ubc->shared0s = 0; 2167 ubc->stolen0s = 0; 2168 tasklet_init(&ubc->rcvd_tasklet, 2169 read_iso_tasklet, (unsigned long) bcs); 2170 return 0; 2171} 2172 2173static void gigaset_reinitbcshw(struct bc_state *bcs) 2174{ 2175 struct bas_bc_state *ubc = bcs->hw.bas; 2176 2177 bcs->hw.bas->running = 0; 2178 atomic_set(&bcs->hw.bas->corrbytes, 0); 2179 bcs->hw.bas->numsub = 0; 2180 spin_lock_init(&ubc->isooutlock); 2181 spin_lock_init(&ubc->isoinlock); 2182 ubc->loststatus = -EINPROGRESS; 2183} 2184 2185static void gigaset_freecshw(struct cardstate *cs) 2186{ 2187 /* timers, URBs and rcvbuf are disposed of in disconnect */ 2188 kfree(cs->hw.bas->int_in_buf); 2189 kfree(cs->hw.bas); 2190 cs->hw.bas = NULL; 2191} 2192 2193/* Initialize hardware dependent part of the cardstate structure 2194 * parameter: 2195 * cs cardstate structure 2196 * return value: 2197 * 0 on success, error code < 0 on failure 2198 */ 2199static int gigaset_initcshw(struct cardstate *cs) 2200{ 2201 struct bas_cardstate *ucs; 2202 2203 cs->hw.bas = ucs = kmalloc(sizeof *ucs, GFP_KERNEL); 2204 if (!ucs) { 2205 pr_err("out of memory\n"); 2206 return -ENOMEM; 2207 } 2208 ucs->int_in_buf = kmalloc(IP_MSGSIZE, GFP_KERNEL); 2209 if (!ucs->int_in_buf) { 2210 kfree(ucs); 2211 pr_err("out of memory\n"); 2212 return -ENOMEM; 2213 } 2214 2215 ucs->urb_cmd_in = NULL; 2216 ucs->urb_cmd_out = NULL; 2217 ucs->rcvbuf = NULL; 2218 ucs->rcvbuf_size = 0; 2219 2220 spin_lock_init(&ucs->lock); 2221 ucs->pending = 0; 2222 2223 ucs->basstate = 0; 2224 setup_timer(&ucs->timer_ctrl, req_timeout, (unsigned long) cs); 2225 setup_timer(&ucs->timer_atrdy, atrdy_timeout, (unsigned long) cs); 2226 setup_timer(&ucs->timer_cmd_in, cmd_in_timeout, (unsigned long) cs); 2227 setup_timer(&ucs->timer_int_in, int_in_resubmit, (unsigned long) cs); 2228 init_waitqueue_head(&ucs->waitqueue); 2229 INIT_WORK(&ucs->int_in_wq, int_in_work); 2230 2231 return 0; 2232} 2233 2234/* freeurbs 2235 * unlink and deallocate all URBs unconditionally 2236 * caller must make sure that no commands are still in progress 2237 * parameter: 2238 * cs controller state structure 2239 */ 2240static void freeurbs(struct cardstate *cs) 2241{ 2242 struct bas_cardstate *ucs = cs->hw.bas; 2243 struct bas_bc_state *ubc; 2244 int i, j; 2245 2246 gig_dbg(DEBUG_INIT, "%s: killing URBs", __func__); 2247 for (j = 0; j < BAS_CHANNELS; ++j) { 2248 ubc = cs->bcs[j].hw.bas; 2249 for (i = 0; i < BAS_OUTURBS; ++i) { 2250 usb_kill_urb(ubc->isoouturbs[i].urb); 2251 usb_free_urb(ubc->isoouturbs[i].urb); 2252 ubc->isoouturbs[i].urb = NULL; 2253 } 2254 for (i = 0; i < BAS_INURBS; ++i) { 2255 usb_kill_urb(ubc->isoinurbs[i]); 2256 usb_free_urb(ubc->isoinurbs[i]); 2257 ubc->isoinurbs[i] = NULL; 2258 } 2259 } 2260 usb_kill_urb(ucs->urb_int_in); 2261 usb_free_urb(ucs->urb_int_in); 2262 ucs->urb_int_in = NULL; 2263 usb_kill_urb(ucs->urb_cmd_out); 2264 usb_free_urb(ucs->urb_cmd_out); 2265 ucs->urb_cmd_out = NULL; 2266 usb_kill_urb(ucs->urb_cmd_in); 2267 usb_free_urb(ucs->urb_cmd_in); 2268 ucs->urb_cmd_in = NULL; 2269 usb_kill_urb(ucs->urb_ctrl); 2270 usb_free_urb(ucs->urb_ctrl); 2271 ucs->urb_ctrl = NULL; 2272} 2273 2274/* gigaset_probe 2275 * This function is called when a new USB device is connected. 2276 * It checks whether the new device is handled by this driver. 2277 */ 2278static int gigaset_probe(struct usb_interface *interface, 2279 const struct usb_device_id *id) 2280{ 2281 struct usb_host_interface *hostif; 2282 struct usb_device *udev = interface_to_usbdev(interface); 2283 struct cardstate *cs = NULL; 2284 struct bas_cardstate *ucs = NULL; 2285 struct bas_bc_state *ubc; 2286 struct usb_endpoint_descriptor *endpoint; 2287 int i, j; 2288 int rc; 2289 2290 gig_dbg(DEBUG_INIT, 2291 "%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)", 2292 __func__, le16_to_cpu(udev->descriptor.idVendor), 2293 le16_to_cpu(udev->descriptor.idProduct)); 2294 2295 /* set required alternate setting */ 2296 hostif = interface->cur_altsetting; 2297 if (hostif->desc.bAlternateSetting != 3) { 2298 gig_dbg(DEBUG_INIT, 2299 "%s: wrong alternate setting %d - trying to switch", 2300 __func__, hostif->desc.bAlternateSetting); 2301 if (usb_set_interface(udev, hostif->desc.bInterfaceNumber, 3) 2302 < 0) { 2303 dev_warn(&udev->dev, "usb_set_interface failed, " 2304 "device %d interface %d altsetting %d\n", 2305 udev->devnum, hostif->desc.bInterfaceNumber, 2306 hostif->desc.bAlternateSetting); 2307 return -ENODEV; 2308 } 2309 hostif = interface->cur_altsetting; 2310 } 2311 2312 /* Reject application specific interfaces 2313 */ 2314 if (hostif->desc.bInterfaceClass != 255) { 2315 dev_warn(&udev->dev, "%s: bInterfaceClass == %d\n", 2316 __func__, hostif->desc.bInterfaceClass); 2317 return -ENODEV; 2318 } 2319 2320 dev_info(&udev->dev, 2321 "%s: Device matched (Vendor: 0x%x, Product: 0x%x)\n", 2322 __func__, le16_to_cpu(udev->descriptor.idVendor), 2323 le16_to_cpu(udev->descriptor.idProduct)); 2324 2325 /* allocate memory for our device state and initialize it */ 2326 cs = gigaset_initcs(driver, BAS_CHANNELS, 0, 0, cidmode, 2327 GIGASET_MODULENAME); 2328 if (!cs) 2329 return -ENODEV; 2330 ucs = cs->hw.bas; 2331 2332 /* save off device structure ptrs for later use */ 2333 usb_get_dev(udev); 2334 ucs->udev = udev; 2335 ucs->interface = interface; 2336 cs->dev = &interface->dev; 2337 2338 /* allocate URBs: 2339 * - one for the interrupt pipe 2340 * - three for the different uses of the default control pipe 2341 * - three for each isochronous pipe 2342 */ 2343 if (!(ucs->urb_int_in = usb_alloc_urb(0, GFP_KERNEL)) || 2344 !(ucs->urb_cmd_in = usb_alloc_urb(0, GFP_KERNEL)) || 2345 !(ucs->urb_cmd_out = usb_alloc_urb(0, GFP_KERNEL)) || 2346 !(ucs->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL))) 2347 goto allocerr; 2348 2349 for (j = 0; j < BAS_CHANNELS; ++j) { 2350 ubc = cs->bcs[j].hw.bas; 2351 for (i = 0; i < BAS_OUTURBS; ++i) 2352 if (!(ubc->isoouturbs[i].urb = 2353 usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL))) 2354 goto allocerr; 2355 for (i = 0; i < BAS_INURBS; ++i) 2356 if (!(ubc->isoinurbs[i] = 2357 usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL))) 2358 goto allocerr; 2359 } 2360 2361 ucs->rcvbuf = NULL; 2362 ucs->rcvbuf_size = 0; 2363 2364 /* Fill the interrupt urb and send it to the core */ 2365 endpoint = &hostif->endpoint[0].desc; 2366 usb_fill_int_urb(ucs->urb_int_in, udev, 2367 usb_rcvintpipe(udev, 2368 usb_endpoint_num(endpoint)), 2369 ucs->int_in_buf, IP_MSGSIZE, read_int_callback, cs, 2370 endpoint->bInterval); 2371 rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL); 2372 if (rc != 0) { 2373 dev_err(cs->dev, "could not submit interrupt URB: %s\n", 2374 get_usb_rcmsg(rc)); 2375 goto error; 2376 } 2377 ucs->retry_int_in = 0; 2378 2379 /* tell the device that the driver is ready */ 2380 rc = req_submit(cs->bcs, HD_DEVICE_INIT_ACK, 0, 0); 2381 if (rc != 0) 2382 goto error; 2383 2384 /* tell common part that the device is ready */ 2385 if (startmode == SM_LOCKED) 2386 cs->mstate = MS_LOCKED; 2387 2388 /* save address of controller structure */ 2389 usb_set_intfdata(interface, cs); 2390 2391 rc = gigaset_start(cs); 2392 if (rc < 0) 2393 goto error; 2394 2395 return 0; 2396 2397allocerr: 2398 dev_err(cs->dev, "could not allocate URBs\n"); 2399 rc = -ENOMEM; 2400error: 2401 freeurbs(cs); 2402 usb_set_intfdata(interface, NULL); 2403 usb_put_dev(udev); 2404 gigaset_freecs(cs); 2405 return rc; 2406} 2407 2408/* gigaset_disconnect 2409 * This function is called when the Gigaset base is unplugged. 2410 */ 2411static void gigaset_disconnect(struct usb_interface *interface) 2412{ 2413 struct cardstate *cs; 2414 struct bas_cardstate *ucs; 2415 int j; 2416 2417 cs = usb_get_intfdata(interface); 2418 2419 ucs = cs->hw.bas; 2420 2421 dev_info(cs->dev, "disconnecting Gigaset base\n"); 2422 2423 /* mark base as not ready, all channels disconnected */ 2424 ucs->basstate = 0; 2425 2426 /* tell LL all channels are down */ 2427 for (j = 0; j < BAS_CHANNELS; ++j) 2428 gigaset_bchannel_down(cs->bcs + j); 2429 2430 /* stop driver (common part) */ 2431 gigaset_stop(cs); 2432 2433 /* stop delayed work and URBs, free ressources */ 2434 del_timer_sync(&ucs->timer_ctrl); 2435 del_timer_sync(&ucs->timer_atrdy); 2436 del_timer_sync(&ucs->timer_cmd_in); 2437 del_timer_sync(&ucs->timer_int_in); 2438 cancel_work_sync(&ucs->int_in_wq); 2439 freeurbs(cs); 2440 usb_set_intfdata(interface, NULL); 2441 kfree(ucs->rcvbuf); 2442 ucs->rcvbuf = NULL; 2443 ucs->rcvbuf_size = 0; 2444 usb_put_dev(ucs->udev); 2445 ucs->interface = NULL; 2446 ucs->udev = NULL; 2447 cs->dev = NULL; 2448 gigaset_freecs(cs); 2449} 2450 2451/* gigaset_suspend 2452 * This function is called before the USB connection is suspended 2453 * or before the USB device is reset. 2454 * In the latter case, message == PMSG_ON. 2455 */ 2456static int gigaset_suspend(struct usb_interface *intf, pm_message_t message) 2457{ 2458 struct cardstate *cs = usb_get_intfdata(intf); 2459 struct bas_cardstate *ucs = cs->hw.bas; 2460 int rc; 2461 2462 /* set suspend flag; this stops AT command/response traffic */ 2463 if (update_basstate(ucs, BS_SUSPEND, 0) & BS_SUSPEND) { 2464 gig_dbg(DEBUG_SUSPEND, "already suspended"); 2465 return 0; 2466 } 2467 2468 /* wait a bit for blocking conditions to go away */ 2469 rc = wait_event_timeout(ucs->waitqueue, 2470 !(ucs->basstate & 2471 (BS_B1OPEN | BS_B2OPEN | BS_ATRDPEND | BS_ATWRPEND)), 2472 BAS_TIMEOUT * HZ / 10); 2473 gig_dbg(DEBUG_SUSPEND, "wait_event_timeout() -> %d", rc); 2474 2475 /* check for conditions preventing suspend */ 2476 if (ucs->basstate & (BS_B1OPEN | BS_B2OPEN | BS_ATRDPEND | BS_ATWRPEND)) { 2477 dev_warn(cs->dev, "cannot suspend:\n"); 2478 if (ucs->basstate & BS_B1OPEN) 2479 dev_warn(cs->dev, " B channel 1 open\n"); 2480 if (ucs->basstate & BS_B2OPEN) 2481 dev_warn(cs->dev, " B channel 2 open\n"); 2482 if (ucs->basstate & BS_ATRDPEND) 2483 dev_warn(cs->dev, " receiving AT reply\n"); 2484 if (ucs->basstate & BS_ATWRPEND) 2485 dev_warn(cs->dev, " sending AT command\n"); 2486 update_basstate(ucs, 0, BS_SUSPEND); 2487 return -EBUSY; 2488 } 2489 2490 /* close AT channel if open */ 2491 if (ucs->basstate & BS_ATOPEN) { 2492 gig_dbg(DEBUG_SUSPEND, "closing AT channel"); 2493 rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, 0); 2494 if (rc) { 2495 update_basstate(ucs, 0, BS_SUSPEND); 2496 return rc; 2497 } 2498 wait_event_timeout(ucs->waitqueue, !ucs->pending, 2499 BAS_TIMEOUT * HZ / 10); 2500 /* in case of timeout, proceed anyway */ 2501 } 2502 2503 /* kill all URBs and delayed work that might still be pending */ 2504 usb_kill_urb(ucs->urb_ctrl); 2505 usb_kill_urb(ucs->urb_int_in); 2506 del_timer_sync(&ucs->timer_ctrl); 2507 del_timer_sync(&ucs->timer_atrdy); 2508 del_timer_sync(&ucs->timer_cmd_in); 2509 del_timer_sync(&ucs->timer_int_in); 2510 2511 /* don't try to cancel int_in_wq from within reset as it 2512 * might be the one requesting the reset 2513 */ 2514 if (message.event != PM_EVENT_ON) 2515 cancel_work_sync(&ucs->int_in_wq); 2516 2517 gig_dbg(DEBUG_SUSPEND, "suspend complete"); 2518 return 0; 2519} 2520 2521/* gigaset_resume 2522 * This function is called after the USB connection has been resumed. 2523 */ 2524static int gigaset_resume(struct usb_interface *intf) 2525{ 2526 struct cardstate *cs = usb_get_intfdata(intf); 2527 struct bas_cardstate *ucs = cs->hw.bas; 2528 int rc; 2529 2530 /* resubmit interrupt URB for spontaneous messages from base */ 2531 rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL); 2532 if (rc) { 2533 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n", 2534 get_usb_rcmsg(rc)); 2535 return rc; 2536 } 2537 ucs->retry_int_in = 0; 2538 2539 /* clear suspend flag to reallow activity */ 2540 update_basstate(ucs, 0, BS_SUSPEND); 2541 2542 gig_dbg(DEBUG_SUSPEND, "resume complete"); 2543 return 0; 2544} 2545 2546/* gigaset_pre_reset 2547 * This function is called before the USB connection is reset. 2548 */ 2549static int gigaset_pre_reset(struct usb_interface *intf) 2550{ 2551 /* handle just like suspend */ 2552 return gigaset_suspend(intf, PMSG_ON); 2553} 2554 2555/* gigaset_post_reset 2556 * This function is called after the USB connection has been reset. 2557 */ 2558static int gigaset_post_reset(struct usb_interface *intf) 2559{ 2560 /* FIXME: send HD_DEVICE_INIT_ACK? */ 2561 2562 /* resume operations */ 2563 return gigaset_resume(intf); 2564} 2565 2566 2567static const struct gigaset_ops gigops = { 2568 gigaset_write_cmd, 2569 gigaset_write_room, 2570 gigaset_chars_in_buffer, 2571 gigaset_brkchars, 2572 gigaset_init_bchannel, 2573 gigaset_close_bchannel, 2574 gigaset_initbcshw, 2575 gigaset_freebcshw, 2576 gigaset_reinitbcshw, 2577 gigaset_initcshw, 2578 gigaset_freecshw, 2579 gigaset_set_modem_ctrl, 2580 gigaset_baud_rate, 2581 gigaset_set_line_ctrl, 2582 gigaset_isoc_send_skb, 2583 gigaset_isoc_input, 2584}; 2585 2586/* bas_gigaset_init 2587 * This function is called after the kernel module is loaded. 2588 */ 2589static int __init bas_gigaset_init(void) 2590{ 2591 int result; 2592 2593 /* allocate memory for our driver state and initialize it */ 2594 driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS, 2595 GIGASET_MODULENAME, GIGASET_DEVNAME, 2596 &gigops, THIS_MODULE); 2597 if (driver == NULL) 2598 goto error; 2599 2600 /* register this driver with the USB subsystem */ 2601 result = usb_register(&gigaset_usb_driver); 2602 if (result < 0) { 2603 pr_err("error %d registering USB driver\n", -result); 2604 goto error; 2605 } 2606 2607 pr_info(DRIVER_DESC "\n"); 2608 return 0; 2609 2610error: 2611 if (driver) 2612 gigaset_freedriver(driver); 2613 driver = NULL; 2614 return -1; 2615} 2616 2617/* bas_gigaset_exit 2618 * This function is called before the kernel module is unloaded. 2619 */ 2620static void __exit bas_gigaset_exit(void) 2621{ 2622 struct bas_cardstate *ucs; 2623 int i; 2624 2625 gigaset_blockdriver(driver); /* => probe will fail 2626 * => no gigaset_start any more 2627 */ 2628 2629 /* stop all connected devices */ 2630 for (i = 0; i < driver->minors; i++) { 2631 if (gigaset_shutdown(driver->cs + i) < 0) 2632 continue; /* no device */ 2633 /* from now on, no isdn callback should be possible */ 2634 2635 /* close all still open channels */ 2636 ucs = driver->cs[i].hw.bas; 2637 if (ucs->basstate & BS_B1OPEN) { 2638 gig_dbg(DEBUG_INIT, "closing B1 channel"); 2639 usb_control_msg(ucs->udev, 2640 usb_sndctrlpipe(ucs->udev, 0), 2641 HD_CLOSE_B1CHANNEL, OUT_VENDOR_REQ, 2642 0, 0, NULL, 0, BAS_TIMEOUT); 2643 } 2644 if (ucs->basstate & BS_B2OPEN) { 2645 gig_dbg(DEBUG_INIT, "closing B2 channel"); 2646 usb_control_msg(ucs->udev, 2647 usb_sndctrlpipe(ucs->udev, 0), 2648 HD_CLOSE_B2CHANNEL, OUT_VENDOR_REQ, 2649 0, 0, NULL, 0, BAS_TIMEOUT); 2650 } 2651 if (ucs->basstate & BS_ATOPEN) { 2652 gig_dbg(DEBUG_INIT, "closing AT channel"); 2653 usb_control_msg(ucs->udev, 2654 usb_sndctrlpipe(ucs->udev, 0), 2655 HD_CLOSE_ATCHANNEL, OUT_VENDOR_REQ, 2656 0, 0, NULL, 0, BAS_TIMEOUT); 2657 } 2658 ucs->basstate = 0; 2659 } 2660 2661 /* deregister this driver with the USB subsystem */ 2662 usb_deregister(&gigaset_usb_driver); 2663 /* this will call the disconnect-callback */ 2664 /* from now on, no disconnect/probe callback should be running */ 2665 2666 gigaset_freedriver(driver); 2667 driver = NULL; 2668} 2669 2670 2671module_init(bas_gigaset_init); 2672module_exit(bas_gigaset_exit); 2673 2674MODULE_AUTHOR(DRIVER_AUTHOR); 2675MODULE_DESCRIPTION(DRIVER_DESC); 2676MODULE_LICENSE("GPL"); 2677