1/* 2 * USB driver for Gigaset 307x directly or using M105 Data. 3 * 4 * Copyright (c) 2001 by Stefan Eilers 5 * and Hansjoerg Lipp <hjlipp@web.de>. 6 * 7 * This driver was derived from the USB skeleton driver by 8 * Greg Kroah-Hartman <greg@kroah.com> 9 * 10 * ===================================================================== 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License as 13 * published by the Free Software Foundation; either version 2 of 14 * the License, or (at your option) any later version. 15 * ===================================================================== 16 */ 17 18#include "gigaset.h" 19#include <linux/usb.h> 20#include <linux/module.h> 21#include <linux/moduleparam.h> 22 23/* Version Information */ 24#define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers" 25#define DRIVER_DESC "USB Driver for Gigaset 307x using M105" 26 27/* Module parameters */ 28 29static int startmode = SM_ISDN; 30static int cidmode = 1; 31 32module_param(startmode, int, S_IRUGO); 33module_param(cidmode, int, S_IRUGO); 34MODULE_PARM_DESC(startmode, "start in isdn4linux mode"); 35MODULE_PARM_DESC(cidmode, "Call-ID mode"); 36 37#define GIGASET_MINORS 1 38#define GIGASET_MINOR 8 39#define GIGASET_MODULENAME "usb_gigaset" 40#define GIGASET_DEVNAME "ttyGU" 41 42/* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */ 43#define IF_WRITEBUF 264 44 45/* Values for the Gigaset M105 Data */ 46#define USB_M105_VENDOR_ID 0x0681 47#define USB_M105_PRODUCT_ID 0x0009 48 49/* table of devices that work with this driver */ 50static const struct usb_device_id gigaset_table[] = { 51 { USB_DEVICE(USB_M105_VENDOR_ID, USB_M105_PRODUCT_ID) }, 52 { } /* Terminating entry */ 53}; 54 55MODULE_DEVICE_TABLE(usb, gigaset_table); 56 57/* 58 * Control requests (empty fields: 00) 59 * 60 * RT|RQ|VALUE|INDEX|LEN |DATA 61 * In: 62 * C1 08 01 63 * Get flags (1 byte). Bits: 0=dtr,1=rts,3-7:? 64 * C1 0F ll ll 65 * Get device information/status (llll: 0x200 and 0x40 seen). 66 * Real size: I only saw MIN(llll,0x64). 67 * Contents: seems to be always the same... 68 * offset 0x00: Length of this structure (0x64) (len: 1,2,3 bytes) 69 * offset 0x3c: String (16 bit chars): "MCCI USB Serial V2.0" 70 * rest: ? 71 * Out: 72 * 41 11 73 * Initialize/reset device ? 74 * 41 00 xx 00 75 * ? (xx=00 or 01; 01 on start, 00 on close) 76 * 41 07 vv mm 77 * Set/clear flags vv=value, mm=mask (see RQ 08) 78 * 41 12 xx 79 * Used before the following configuration requests are issued 80 * (with xx=0x0f). I've seen other values<0xf, though. 81 * 41 01 xx xx 82 * Set baud rate. xxxx=ceil(0x384000/rate)=trunc(0x383fff/rate)+1. 83 * 41 03 ps bb 84 * Set byte size and parity. p: 0x20=even,0x10=odd,0x00=no parity 85 * [ 0x30: m, 0x40: s ] 86 * [s: 0: 1 stop bit; 1: 1.5; 2: 2] 87 * bb: bits/byte (seen 7 and 8) 88 * 41 13 -- -- -- -- 10 00 ww 00 00 00 xx 00 00 00 yy 00 00 00 zz 00 00 00 89 * ?? 90 * Initialization: 01, 40, 00, 00 91 * Open device: 00 40, 00, 00 92 * yy and zz seem to be equal, either 0x00 or 0x0a 93 * (ww,xx) pairs seen: (00,00), (00,40), (01,40), (09,80), (19,80) 94 * 41 19 -- -- -- -- 06 00 00 00 00 xx 11 13 95 * Used after every "configuration sequence" (RQ 12, RQs 01/03/13). 96 * xx is usually 0x00 but was 0x7e before starting data transfer 97 * in unimodem mode. So, this might be an array of characters that 98 * need special treatment ("commit all bufferd data"?), 11=^Q, 13=^S. 99 * 100 * Unimodem mode: use "modprobe ppp_async flag_time=0" as the device _needs_ two 101 * flags per packet. 102 */ 103 104/* functions called if a device of this driver is connected/disconnected */ 105static int gigaset_probe(struct usb_interface *interface, 106 const struct usb_device_id *id); 107static void gigaset_disconnect(struct usb_interface *interface); 108 109/* functions called before/after suspend */ 110static int gigaset_suspend(struct usb_interface *intf, pm_message_t message); 111static int gigaset_resume(struct usb_interface *intf); 112static int gigaset_pre_reset(struct usb_interface *intf); 113 114static struct gigaset_driver *driver; 115 116/* usb specific object needed to register this driver with the usb subsystem */ 117static struct usb_driver gigaset_usb_driver = { 118 .name = GIGASET_MODULENAME, 119 .probe = gigaset_probe, 120 .disconnect = gigaset_disconnect, 121 .id_table = gigaset_table, 122 .suspend = gigaset_suspend, 123 .resume = gigaset_resume, 124 .reset_resume = gigaset_resume, 125 .pre_reset = gigaset_pre_reset, 126 .post_reset = gigaset_resume, 127 .disable_hub_initiated_lpm = 1, 128}; 129 130struct usb_cardstate { 131 struct usb_device *udev; /* usb device pointer */ 132 struct usb_interface *interface; /* interface for this device */ 133 int busy; /* bulk output in progress */ 134 135 /* Output buffer */ 136 unsigned char *bulk_out_buffer; 137 int bulk_out_size; 138 int bulk_out_epnum; 139 struct urb *bulk_out_urb; 140 141 /* Input buffer */ 142 unsigned char *rcvbuf; 143 int rcvbuf_size; 144 struct urb *read_urb; 145 146 char bchars[6]; /* for request 0x19 */ 147}; 148 149static inline unsigned tiocm_to_gigaset(unsigned state) 150{ 151 return ((state & TIOCM_DTR) ? 1 : 0) | ((state & TIOCM_RTS) ? 2 : 0); 152} 153 154static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state, 155 unsigned new_state) 156{ 157 struct usb_device *udev = cs->hw.usb->udev; 158 unsigned mask, val; 159 int r; 160 161 mask = tiocm_to_gigaset(old_state ^ new_state); 162 val = tiocm_to_gigaset(new_state); 163 164 gig_dbg(DEBUG_USBREQ, "set flags 0x%02x with mask 0x%02x", val, mask); 165 r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 7, 0x41, 166 (val & 0xff) | ((mask & 0xff) << 8), 0, 167 NULL, 0, 2000 /* timeout? */); 168 if (r < 0) 169 return r; 170 return 0; 171} 172 173/* 174 * Set M105 configuration value 175 * using undocumented device commands reverse engineered from USB traces 176 * of the Siemens Windows driver 177 */ 178static int set_value(struct cardstate *cs, u8 req, u16 val) 179{ 180 struct usb_device *udev = cs->hw.usb->udev; 181 int r, r2; 182 183 gig_dbg(DEBUG_USBREQ, "request %02x (%04x)", 184 (unsigned)req, (unsigned)val); 185 r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x12, 0x41, 186 0xf /*?*/, 0, NULL, 0, 2000 /*?*/); 187 /* no idea what this does */ 188 if (r < 0) { 189 dev_err(&udev->dev, "error %d on request 0x12\n", -r); 190 return r; 191 } 192 193 r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), req, 0x41, 194 val, 0, NULL, 0, 2000 /*?*/); 195 if (r < 0) 196 dev_err(&udev->dev, "error %d on request 0x%02x\n", 197 -r, (unsigned)req); 198 199 r2 = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41, 200 0, 0, cs->hw.usb->bchars, 6, 2000 /*?*/); 201 if (r2 < 0) 202 dev_err(&udev->dev, "error %d on request 0x19\n", -r2); 203 204 return r < 0 ? r : (r2 < 0 ? r2 : 0); 205} 206 207/* 208 * set the baud rate on the internal serial adapter 209 * using the undocumented parameter setting command 210 */ 211static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag) 212{ 213 u16 val; 214 u32 rate; 215 216 cflag &= CBAUD; 217 218 switch (cflag) { 219 case B300: rate = 300; break; 220 case B600: rate = 600; break; 221 case B1200: rate = 1200; break; 222 case B2400: rate = 2400; break; 223 case B4800: rate = 4800; break; 224 case B9600: rate = 9600; break; 225 case B19200: rate = 19200; break; 226 case B38400: rate = 38400; break; 227 case B57600: rate = 57600; break; 228 case B115200: rate = 115200; break; 229 default: 230 rate = 9600; 231 dev_err(cs->dev, "unsupported baudrate request 0x%x," 232 " using default of B9600\n", cflag); 233 } 234 235 val = 0x383fff / rate + 1; 236 237 return set_value(cs, 1, val); 238} 239 240/* 241 * set the line format on the internal serial adapter 242 * using the undocumented parameter setting command 243 */ 244static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag) 245{ 246 u16 val = 0; 247 248 /* set the parity */ 249 if (cflag & PARENB) 250 val |= (cflag & PARODD) ? 0x10 : 0x20; 251 252 /* set the number of data bits */ 253 switch (cflag & CSIZE) { 254 case CS5: 255 val |= 5 << 8; break; 256 case CS6: 257 val |= 6 << 8; break; 258 case CS7: 259 val |= 7 << 8; break; 260 case CS8: 261 val |= 8 << 8; break; 262 default: 263 dev_err(cs->dev, "CSIZE was not CS5-CS8, using default of 8\n"); 264 val |= 8 << 8; 265 break; 266 } 267 268 /* set the number of stop bits */ 269 if (cflag & CSTOPB) { 270 if ((cflag & CSIZE) == CS5) 271 val |= 1; /* 1.5 stop bits */ 272 else 273 val |= 2; /* 2 stop bits */ 274 } 275 276 return set_value(cs, 3, val); 277} 278 279 280/*============================================================================*/ 281static int gigaset_init_bchannel(struct bc_state *bcs) 282{ 283 /* nothing to do for M10x */ 284 gigaset_bchannel_up(bcs); 285 return 0; 286} 287 288static int gigaset_close_bchannel(struct bc_state *bcs) 289{ 290 /* nothing to do for M10x */ 291 gigaset_bchannel_down(bcs); 292 return 0; 293} 294 295static int write_modem(struct cardstate *cs); 296static int send_cb(struct cardstate *cs); 297 298 299/* Write tasklet handler: Continue sending current skb, or send command, or 300 * start sending an skb from the send queue. 301 */ 302static void gigaset_modem_fill(unsigned long data) 303{ 304 struct cardstate *cs = (struct cardstate *) data; 305 struct bc_state *bcs = &cs->bcs[0]; /* only one channel */ 306 307 gig_dbg(DEBUG_OUTPUT, "modem_fill"); 308 309 if (cs->hw.usb->busy) { 310 gig_dbg(DEBUG_OUTPUT, "modem_fill: busy"); 311 return; 312 } 313 314again: 315 if (!bcs->tx_skb) { /* no skb is being sent */ 316 if (cs->cmdbuf) { /* commands to send? */ 317 gig_dbg(DEBUG_OUTPUT, "modem_fill: cb"); 318 if (send_cb(cs) < 0) { 319 gig_dbg(DEBUG_OUTPUT, 320 "modem_fill: send_cb failed"); 321 goto again; /* no callback will be called! */ 322 } 323 return; 324 } 325 326 /* skbs to send? */ 327 bcs->tx_skb = skb_dequeue(&bcs->squeue); 328 if (!bcs->tx_skb) 329 return; 330 331 gig_dbg(DEBUG_INTR, "Dequeued skb (Adr: %lx)!", 332 (unsigned long) bcs->tx_skb); 333 } 334 335 gig_dbg(DEBUG_OUTPUT, "modem_fill: tx_skb"); 336 if (write_modem(cs) < 0) { 337 gig_dbg(DEBUG_OUTPUT, "modem_fill: write_modem failed"); 338 goto again; /* no callback will be called! */ 339 } 340} 341 342/* 343 * Interrupt Input URB completion routine 344 */ 345static void gigaset_read_int_callback(struct urb *urb) 346{ 347 struct cardstate *cs = urb->context; 348 struct inbuf_t *inbuf = cs->inbuf; 349 int status = urb->status; 350 int r; 351 unsigned numbytes; 352 unsigned char *src; 353 unsigned long flags; 354 355 if (!status) { 356 numbytes = urb->actual_length; 357 358 if (numbytes) { 359 src = cs->hw.usb->rcvbuf; 360 if (unlikely(*src)) 361 dev_warn(cs->dev, 362 "%s: There was no leading 0, but 0x%02x!\n", 363 __func__, (unsigned) *src); 364 ++src; /* skip leading 0x00 */ 365 --numbytes; 366 if (gigaset_fill_inbuf(inbuf, src, numbytes)) { 367 gig_dbg(DEBUG_INTR, "%s-->BH", __func__); 368 gigaset_schedule_event(inbuf->cs); 369 } 370 } else 371 gig_dbg(DEBUG_INTR, "Received zero block length"); 372 } else { 373 /* The urb might have been killed. */ 374 gig_dbg(DEBUG_ANY, "%s - nonzero status received: %d", 375 __func__, status); 376 if (status == -ENOENT || status == -ESHUTDOWN) 377 /* killed or endpoint shutdown: don't resubmit */ 378 return; 379 } 380 381 /* resubmit URB */ 382 spin_lock_irqsave(&cs->lock, flags); 383 if (!cs->connected) { 384 spin_unlock_irqrestore(&cs->lock, flags); 385 pr_err("%s: disconnected\n", __func__); 386 return; 387 } 388 r = usb_submit_urb(urb, GFP_ATOMIC); 389 spin_unlock_irqrestore(&cs->lock, flags); 390 if (r) 391 dev_err(cs->dev, "error %d resubmitting URB\n", -r); 392} 393 394 395/* This callback routine is called when data was transmitted to the device. */ 396static void gigaset_write_bulk_callback(struct urb *urb) 397{ 398 struct cardstate *cs = urb->context; 399 int status = urb->status; 400 unsigned long flags; 401 402 switch (status) { 403 case 0: /* normal completion */ 404 break; 405 case -ENOENT: /* killed */ 406 gig_dbg(DEBUG_ANY, "%s: killed", __func__); 407 cs->hw.usb->busy = 0; 408 return; 409 default: 410 dev_err(cs->dev, "bulk transfer failed (status %d)\n", 411 -status); 412 /* That's all we can do. Communication problems 413 are handled by timeouts or network protocols. */ 414 } 415 416 spin_lock_irqsave(&cs->lock, flags); 417 if (!cs->connected) { 418 pr_err("%s: disconnected\n", __func__); 419 } else { 420 cs->hw.usb->busy = 0; 421 tasklet_schedule(&cs->write_tasklet); 422 } 423 spin_unlock_irqrestore(&cs->lock, flags); 424} 425 426static int send_cb(struct cardstate *cs) 427{ 428 struct cmdbuf_t *cb = cs->cmdbuf; 429 unsigned long flags; 430 int count; 431 int status = -ENOENT; 432 struct usb_cardstate *ucs = cs->hw.usb; 433 434 do { 435 if (!cb->len) { 436 spin_lock_irqsave(&cs->cmdlock, flags); 437 cs->cmdbytes -= cs->curlen; 438 gig_dbg(DEBUG_OUTPUT, "send_cb: sent %u bytes, %u left", 439 cs->curlen, cs->cmdbytes); 440 cs->cmdbuf = cb->next; 441 if (cs->cmdbuf) { 442 cs->cmdbuf->prev = NULL; 443 cs->curlen = cs->cmdbuf->len; 444 } else { 445 cs->lastcmdbuf = NULL; 446 cs->curlen = 0; 447 } 448 spin_unlock_irqrestore(&cs->cmdlock, flags); 449 450 if (cb->wake_tasklet) 451 tasklet_schedule(cb->wake_tasklet); 452 kfree(cb); 453 454 cb = cs->cmdbuf; 455 } 456 457 if (cb) { 458 count = min(cb->len, ucs->bulk_out_size); 459 gig_dbg(DEBUG_OUTPUT, "send_cb: send %d bytes", count); 460 461 usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev, 462 usb_sndbulkpipe(ucs->udev, 463 ucs->bulk_out_epnum), 464 cb->buf + cb->offset, count, 465 gigaset_write_bulk_callback, cs); 466 467 cb->offset += count; 468 cb->len -= count; 469 ucs->busy = 1; 470 471 spin_lock_irqsave(&cs->lock, flags); 472 status = cs->connected ? 473 usb_submit_urb(ucs->bulk_out_urb, GFP_ATOMIC) : 474 -ENODEV; 475 spin_unlock_irqrestore(&cs->lock, flags); 476 477 if (status) { 478 ucs->busy = 0; 479 dev_err(cs->dev, 480 "could not submit urb (error %d)\n", 481 -status); 482 cb->len = 0; /* skip urb => remove cb+wakeup 483 in next loop cycle */ 484 } 485 } 486 } while (cb && status); /* next command on error */ 487 488 return status; 489} 490 491/* Send command to device. */ 492static int gigaset_write_cmd(struct cardstate *cs, struct cmdbuf_t *cb) 493{ 494 unsigned long flags; 495 int len; 496 497 gigaset_dbg_buffer(cs->mstate != MS_LOCKED ? 498 DEBUG_TRANSCMD : DEBUG_LOCKCMD, 499 "CMD Transmit", cb->len, cb->buf); 500 501 spin_lock_irqsave(&cs->cmdlock, flags); 502 cb->prev = cs->lastcmdbuf; 503 if (cs->lastcmdbuf) 504 cs->lastcmdbuf->next = cb; 505 else { 506 cs->cmdbuf = cb; 507 cs->curlen = cb->len; 508 } 509 cs->cmdbytes += cb->len; 510 cs->lastcmdbuf = cb; 511 spin_unlock_irqrestore(&cs->cmdlock, flags); 512 513 spin_lock_irqsave(&cs->lock, flags); 514 len = cb->len; 515 if (cs->connected) 516 tasklet_schedule(&cs->write_tasklet); 517 spin_unlock_irqrestore(&cs->lock, flags); 518 return len; 519} 520 521static int gigaset_write_room(struct cardstate *cs) 522{ 523 unsigned bytes; 524 525 bytes = cs->cmdbytes; 526 return bytes < IF_WRITEBUF ? IF_WRITEBUF - bytes : 0; 527} 528 529static int gigaset_chars_in_buffer(struct cardstate *cs) 530{ 531 return cs->cmdbytes; 532} 533 534/* 535 * set the break characters on the internal serial adapter 536 * using undocumented device commands reverse engineered from USB traces 537 * of the Siemens Windows driver 538 */ 539static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6]) 540{ 541 struct usb_device *udev = cs->hw.usb->udev; 542 543 gigaset_dbg_buffer(DEBUG_USBREQ, "brkchars", 6, buf); 544 memcpy(cs->hw.usb->bchars, buf, 6); 545 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41, 546 0, 0, &buf, 6, 2000); 547} 548 549static void gigaset_freebcshw(struct bc_state *bcs) 550{ 551 /* unused */ 552} 553 554/* Initialize the b-channel structure */ 555static int gigaset_initbcshw(struct bc_state *bcs) 556{ 557 /* unused */ 558 bcs->hw.usb = NULL; 559 return 0; 560} 561 562static void gigaset_reinitbcshw(struct bc_state *bcs) 563{ 564 /* nothing to do for M10x */ 565} 566 567static void gigaset_freecshw(struct cardstate *cs) 568{ 569 tasklet_kill(&cs->write_tasklet); 570 kfree(cs->hw.usb); 571} 572 573static int gigaset_initcshw(struct cardstate *cs) 574{ 575 struct usb_cardstate *ucs; 576 577 cs->hw.usb = ucs = 578 kmalloc(sizeof(struct usb_cardstate), GFP_KERNEL); 579 if (!ucs) { 580 pr_err("out of memory\n"); 581 return -ENOMEM; 582 } 583 584 ucs->bchars[0] = 0; 585 ucs->bchars[1] = 0; 586 ucs->bchars[2] = 0; 587 ucs->bchars[3] = 0; 588 ucs->bchars[4] = 0x11; 589 ucs->bchars[5] = 0x13; 590 ucs->bulk_out_buffer = NULL; 591 ucs->bulk_out_urb = NULL; 592 ucs->read_urb = NULL; 593 tasklet_init(&cs->write_tasklet, 594 gigaset_modem_fill, (unsigned long) cs); 595 596 return 0; 597} 598 599/* Send data from current skb to the device. */ 600static int write_modem(struct cardstate *cs) 601{ 602 int ret = 0; 603 int count; 604 struct bc_state *bcs = &cs->bcs[0]; /* only one channel */ 605 struct usb_cardstate *ucs = cs->hw.usb; 606 unsigned long flags; 607 608 gig_dbg(DEBUG_OUTPUT, "len: %d...", bcs->tx_skb->len); 609 610 if (!bcs->tx_skb->len) { 611 dev_kfree_skb_any(bcs->tx_skb); 612 bcs->tx_skb = NULL; 613 return -EINVAL; 614 } 615 616 /* Copy data to bulk out buffer and transmit data */ 617 count = min(bcs->tx_skb->len, (unsigned) ucs->bulk_out_size); 618 skb_copy_from_linear_data(bcs->tx_skb, ucs->bulk_out_buffer, count); 619 skb_pull(bcs->tx_skb, count); 620 ucs->busy = 1; 621 gig_dbg(DEBUG_OUTPUT, "write_modem: send %d bytes", count); 622 623 spin_lock_irqsave(&cs->lock, flags); 624 if (cs->connected) { 625 usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev, 626 usb_sndbulkpipe(ucs->udev, 627 ucs->bulk_out_epnum), 628 ucs->bulk_out_buffer, count, 629 gigaset_write_bulk_callback, cs); 630 ret = usb_submit_urb(ucs->bulk_out_urb, GFP_ATOMIC); 631 } else { 632 ret = -ENODEV; 633 } 634 spin_unlock_irqrestore(&cs->lock, flags); 635 636 if (ret) { 637 dev_err(cs->dev, "could not submit urb (error %d)\n", -ret); 638 ucs->busy = 0; 639 } 640 641 if (!bcs->tx_skb->len) { 642 /* skb sent completely */ 643 gigaset_skb_sent(bcs, bcs->tx_skb); 644 645 gig_dbg(DEBUG_INTR, "kfree skb (Adr: %lx)!", 646 (unsigned long) bcs->tx_skb); 647 dev_kfree_skb_any(bcs->tx_skb); 648 bcs->tx_skb = NULL; 649 } 650 651 return ret; 652} 653 654static int gigaset_probe(struct usb_interface *interface, 655 const struct usb_device_id *id) 656{ 657 int retval; 658 struct usb_device *udev = interface_to_usbdev(interface); 659 struct usb_host_interface *hostif = interface->cur_altsetting; 660 struct cardstate *cs = NULL; 661 struct usb_cardstate *ucs = NULL; 662 struct usb_endpoint_descriptor *endpoint; 663 int buffer_size; 664 665 gig_dbg(DEBUG_ANY, "%s: Check if device matches ...", __func__); 666 667 /* See if the device offered us matches what we can accept */ 668 if ((le16_to_cpu(udev->descriptor.idVendor) != USB_M105_VENDOR_ID) || 669 (le16_to_cpu(udev->descriptor.idProduct) != USB_M105_PRODUCT_ID)) { 670 gig_dbg(DEBUG_ANY, "device ID (0x%x, 0x%x) not for me - skip", 671 le16_to_cpu(udev->descriptor.idVendor), 672 le16_to_cpu(udev->descriptor.idProduct)); 673 return -ENODEV; 674 } 675 if (hostif->desc.bInterfaceNumber != 0) { 676 gig_dbg(DEBUG_ANY, "interface %d not for me - skip", 677 hostif->desc.bInterfaceNumber); 678 return -ENODEV; 679 } 680 if (hostif->desc.bAlternateSetting != 0) { 681 dev_notice(&udev->dev, "unsupported altsetting %d - skip", 682 hostif->desc.bAlternateSetting); 683 return -ENODEV; 684 } 685 if (hostif->desc.bInterfaceClass != 255) { 686 dev_notice(&udev->dev, "unsupported interface class %d - skip", 687 hostif->desc.bInterfaceClass); 688 return -ENODEV; 689 } 690 691 dev_info(&udev->dev, "%s: Device matched ... !\n", __func__); 692 693 /* allocate memory for our device state and initialize it */ 694 cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME); 695 if (!cs) 696 return -ENODEV; 697 ucs = cs->hw.usb; 698 699 /* save off device structure ptrs for later use */ 700 usb_get_dev(udev); 701 ucs->udev = udev; 702 ucs->interface = interface; 703 cs->dev = &interface->dev; 704 705 /* save address of controller structure */ 706 usb_set_intfdata(interface, cs); 707 708 endpoint = &hostif->endpoint[0].desc; 709 710 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 711 ucs->bulk_out_size = buffer_size; 712 ucs->bulk_out_epnum = usb_endpoint_num(endpoint); 713 ucs->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL); 714 if (!ucs->bulk_out_buffer) { 715 dev_err(cs->dev, "Couldn't allocate bulk_out_buffer\n"); 716 retval = -ENOMEM; 717 goto error; 718 } 719 720 ucs->bulk_out_urb = usb_alloc_urb(0, GFP_KERNEL); 721 if (!ucs->bulk_out_urb) { 722 dev_err(cs->dev, "Couldn't allocate bulk_out_urb\n"); 723 retval = -ENOMEM; 724 goto error; 725 } 726 727 endpoint = &hostif->endpoint[1].desc; 728 729 ucs->busy = 0; 730 731 ucs->read_urb = usb_alloc_urb(0, GFP_KERNEL); 732 if (!ucs->read_urb) { 733 dev_err(cs->dev, "No free urbs available\n"); 734 retval = -ENOMEM; 735 goto error; 736 } 737 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 738 ucs->rcvbuf_size = buffer_size; 739 ucs->rcvbuf = kmalloc(buffer_size, GFP_KERNEL); 740 if (!ucs->rcvbuf) { 741 dev_err(cs->dev, "Couldn't allocate rcvbuf\n"); 742 retval = -ENOMEM; 743 goto error; 744 } 745 /* Fill the interrupt urb and send it to the core */ 746 usb_fill_int_urb(ucs->read_urb, udev, 747 usb_rcvintpipe(udev, usb_endpoint_num(endpoint)), 748 ucs->rcvbuf, buffer_size, 749 gigaset_read_int_callback, 750 cs, endpoint->bInterval); 751 752 retval = usb_submit_urb(ucs->read_urb, GFP_KERNEL); 753 if (retval) { 754 dev_err(cs->dev, "Could not submit URB (error %d)\n", -retval); 755 goto error; 756 } 757 758 /* tell common part that the device is ready */ 759 if (startmode == SM_LOCKED) 760 cs->mstate = MS_LOCKED; 761 762 retval = gigaset_start(cs); 763 if (retval < 0) { 764 tasklet_kill(&cs->write_tasklet); 765 goto error; 766 } 767 return 0; 768 769error: 770 usb_kill_urb(ucs->read_urb); 771 kfree(ucs->bulk_out_buffer); 772 usb_free_urb(ucs->bulk_out_urb); 773 kfree(ucs->rcvbuf); 774 usb_free_urb(ucs->read_urb); 775 usb_set_intfdata(interface, NULL); 776 ucs->read_urb = ucs->bulk_out_urb = NULL; 777 ucs->rcvbuf = ucs->bulk_out_buffer = NULL; 778 usb_put_dev(ucs->udev); 779 ucs->udev = NULL; 780 ucs->interface = NULL; 781 gigaset_freecs(cs); 782 return retval; 783} 784 785static void gigaset_disconnect(struct usb_interface *interface) 786{ 787 struct cardstate *cs; 788 struct usb_cardstate *ucs; 789 790 cs = usb_get_intfdata(interface); 791 ucs = cs->hw.usb; 792 793 dev_info(cs->dev, "disconnecting Gigaset USB adapter\n"); 794 795 usb_kill_urb(ucs->read_urb); 796 797 gigaset_stop(cs); 798 799 usb_set_intfdata(interface, NULL); 800 tasklet_kill(&cs->write_tasklet); 801 802 usb_kill_urb(ucs->bulk_out_urb); 803 804 kfree(ucs->bulk_out_buffer); 805 usb_free_urb(ucs->bulk_out_urb); 806 kfree(ucs->rcvbuf); 807 usb_free_urb(ucs->read_urb); 808 ucs->read_urb = ucs->bulk_out_urb = NULL; 809 ucs->rcvbuf = ucs->bulk_out_buffer = NULL; 810 811 usb_put_dev(ucs->udev); 812 ucs->interface = NULL; 813 ucs->udev = NULL; 814 cs->dev = NULL; 815 gigaset_freecs(cs); 816} 817 818/* gigaset_suspend 819 * This function is called before the USB connection is suspended or reset. 820 */ 821static int gigaset_suspend(struct usb_interface *intf, pm_message_t message) 822{ 823 struct cardstate *cs = usb_get_intfdata(intf); 824 825 /* stop activity */ 826 cs->connected = 0; /* prevent rescheduling */ 827 usb_kill_urb(cs->hw.usb->read_urb); 828 tasklet_kill(&cs->write_tasklet); 829 usb_kill_urb(cs->hw.usb->bulk_out_urb); 830 831 gig_dbg(DEBUG_SUSPEND, "suspend complete"); 832 return 0; 833} 834 835/* gigaset_resume 836 * This function is called after the USB connection has been resumed or reset. 837 */ 838static int gigaset_resume(struct usb_interface *intf) 839{ 840 struct cardstate *cs = usb_get_intfdata(intf); 841 int rc; 842 843 /* resubmit interrupt URB */ 844 cs->connected = 1; 845 rc = usb_submit_urb(cs->hw.usb->read_urb, GFP_KERNEL); 846 if (rc) { 847 dev_err(cs->dev, "Could not submit read URB (error %d)\n", -rc); 848 return rc; 849 } 850 851 gig_dbg(DEBUG_SUSPEND, "resume complete"); 852 return 0; 853} 854 855/* gigaset_pre_reset 856 * This function is called before the USB connection is reset. 857 */ 858static int gigaset_pre_reset(struct usb_interface *intf) 859{ 860 /* same as suspend */ 861 return gigaset_suspend(intf, PMSG_ON); 862} 863 864static const struct gigaset_ops ops = { 865 gigaset_write_cmd, 866 gigaset_write_room, 867 gigaset_chars_in_buffer, 868 gigaset_brkchars, 869 gigaset_init_bchannel, 870 gigaset_close_bchannel, 871 gigaset_initbcshw, 872 gigaset_freebcshw, 873 gigaset_reinitbcshw, 874 gigaset_initcshw, 875 gigaset_freecshw, 876 gigaset_set_modem_ctrl, 877 gigaset_baud_rate, 878 gigaset_set_line_ctrl, 879 gigaset_m10x_send_skb, 880 gigaset_m10x_input, 881}; 882 883/* 884 * This function is called while kernel-module is loaded 885 */ 886static int __init usb_gigaset_init(void) 887{ 888 int result; 889 890 /* allocate memory for our driver state and initialize it */ 891 driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS, 892 GIGASET_MODULENAME, GIGASET_DEVNAME, 893 &ops, THIS_MODULE); 894 if (driver == NULL) { 895 result = -ENOMEM; 896 goto error; 897 } 898 899 /* register this driver with the USB subsystem */ 900 result = usb_register(&gigaset_usb_driver); 901 if (result < 0) { 902 pr_err("error %d registering USB driver\n", -result); 903 goto error; 904 } 905 906 pr_info(DRIVER_DESC "\n"); 907 return 0; 908 909error: 910 if (driver) 911 gigaset_freedriver(driver); 912 driver = NULL; 913 return result; 914} 915 916/* 917 * This function is called while unloading the kernel-module 918 */ 919static void __exit usb_gigaset_exit(void) 920{ 921 int i; 922 923 gigaset_blockdriver(driver); /* => probe will fail 924 * => no gigaset_start any more 925 */ 926 927 /* stop all connected devices */ 928 for (i = 0; i < driver->minors; i++) 929 gigaset_shutdown(driver->cs + i); 930 931 /* from now on, no isdn callback should be possible */ 932 933 /* deregister this driver with the USB subsystem */ 934 usb_deregister(&gigaset_usb_driver); 935 /* this will call the disconnect-callback */ 936 /* from now on, no disconnect/probe callback should be running */ 937 938 gigaset_freedriver(driver); 939 driver = NULL; 940} 941 942 943module_init(usb_gigaset_init); 944module_exit(usb_gigaset_exit); 945 946MODULE_AUTHOR(DRIVER_AUTHOR); 947MODULE_DESCRIPTION(DRIVER_DESC); 948 949MODULE_LICENSE("GPL"); 950