1/* 2 * Stuff used by all variants of the driver 3 * 4 * Copyright (c) 2001 by Stefan Eilers, 5 * Hansjoerg Lipp <hjlipp@web.de>, 6 * Tilman Schmidt <tilman@imap.cc>. 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/module.h> 18#include <linux/moduleparam.h> 19 20/* Version Information */ 21#define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Tilman Schmidt <tilman@imap.cc>, Stefan Eilers" 22#define DRIVER_DESC "Driver for Gigaset 307x" 23 24#ifdef CONFIG_GIGASET_DEBUG 25#define DRIVER_DESC_DEBUG " (debug build)" 26#else 27#define DRIVER_DESC_DEBUG "" 28#endif 29 30/* Module parameters */ 31int gigaset_debuglevel; 32EXPORT_SYMBOL_GPL(gigaset_debuglevel); 33module_param_named(debug, gigaset_debuglevel, int, S_IRUGO|S_IWUSR); 34MODULE_PARM_DESC(debug, "debug level"); 35 36/* driver state flags */ 37#define VALID_MINOR 0x01 38#define VALID_ID 0x02 39 40/** 41 * gigaset_dbg_buffer() - dump data in ASCII and hex for debugging 42 * @level: debugging level. 43 * @msg: message prefix. 44 * @len: number of bytes to dump. 45 * @buf: data to dump. 46 * 47 * If the current debugging level includes one of the bits set in @level, 48 * @len bytes starting at @buf are logged to dmesg at KERN_DEBUG prio, 49 * prefixed by the text @msg. 50 */ 51void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg, 52 size_t len, const unsigned char *buf) 53{ 54 unsigned char outbuf[80]; 55 unsigned char c; 56 size_t space = sizeof outbuf - 1; 57 unsigned char *out = outbuf; 58 size_t numin = len; 59 60 while (numin--) { 61 c = *buf++; 62 if (c == '~' || c == '^' || c == '\\') { 63 if (!space--) 64 break; 65 *out++ = '\\'; 66 } 67 if (c & 0x80) { 68 if (!space--) 69 break; 70 *out++ = '~'; 71 c ^= 0x80; 72 } 73 if (c < 0x20 || c == 0x7f) { 74 if (!space--) 75 break; 76 *out++ = '^'; 77 c ^= 0x40; 78 } 79 if (!space--) 80 break; 81 *out++ = c; 82 } 83 *out = 0; 84 85 gig_dbg(level, "%s (%u bytes): %s", msg, (unsigned) len, outbuf); 86} 87EXPORT_SYMBOL_GPL(gigaset_dbg_buffer); 88 89static int setflags(struct cardstate *cs, unsigned flags, unsigned delay) 90{ 91 int r; 92 93 r = cs->ops->set_modem_ctrl(cs, cs->control_state, flags); 94 cs->control_state = flags; 95 if (r < 0) 96 return r; 97 98 if (delay) { 99 set_current_state(TASK_INTERRUPTIBLE); 100 schedule_timeout(delay * HZ / 1000); 101 } 102 103 return 0; 104} 105 106int gigaset_enterconfigmode(struct cardstate *cs) 107{ 108 int i, r; 109 110 cs->control_state = TIOCM_RTS; 111 112 r = setflags(cs, TIOCM_DTR, 200); 113 if (r < 0) 114 goto error; 115 r = setflags(cs, 0, 200); 116 if (r < 0) 117 goto error; 118 for (i = 0; i < 5; ++i) { 119 r = setflags(cs, TIOCM_RTS, 100); 120 if (r < 0) 121 goto error; 122 r = setflags(cs, 0, 100); 123 if (r < 0) 124 goto error; 125 } 126 r = setflags(cs, TIOCM_RTS|TIOCM_DTR, 800); 127 if (r < 0) 128 goto error; 129 130 return 0; 131 132error: 133 dev_err(cs->dev, "error %d on setuartbits\n", -r); 134 cs->control_state = TIOCM_RTS|TIOCM_DTR; 135 cs->ops->set_modem_ctrl(cs, 0, TIOCM_RTS|TIOCM_DTR); 136 137 return -1; 138} 139 140static int test_timeout(struct at_state_t *at_state) 141{ 142 if (!at_state->timer_expires) 143 return 0; 144 145 if (--at_state->timer_expires) { 146 gig_dbg(DEBUG_MCMD, "decreased timer of %p to %lu", 147 at_state, at_state->timer_expires); 148 return 0; 149 } 150 151 gigaset_add_event(at_state->cs, at_state, EV_TIMEOUT, NULL, 152 at_state->timer_index, NULL); 153 return 1; 154} 155 156static void timer_tick(unsigned long data) 157{ 158 struct cardstate *cs = (struct cardstate *) data; 159 unsigned long flags; 160 unsigned channel; 161 struct at_state_t *at_state; 162 int timeout = 0; 163 164 spin_lock_irqsave(&cs->lock, flags); 165 166 for (channel = 0; channel < cs->channels; ++channel) 167 if (test_timeout(&cs->bcs[channel].at_state)) 168 timeout = 1; 169 170 if (test_timeout(&cs->at_state)) 171 timeout = 1; 172 173 list_for_each_entry(at_state, &cs->temp_at_states, list) 174 if (test_timeout(at_state)) 175 timeout = 1; 176 177 if (cs->running) { 178 mod_timer(&cs->timer, jiffies + msecs_to_jiffies(GIG_TICK)); 179 if (timeout) { 180 gig_dbg(DEBUG_EVENT, "scheduling timeout"); 181 tasklet_schedule(&cs->event_tasklet); 182 } 183 } 184 185 spin_unlock_irqrestore(&cs->lock, flags); 186} 187 188int gigaset_get_channel(struct bc_state *bcs) 189{ 190 unsigned long flags; 191 192 spin_lock_irqsave(&bcs->cs->lock, flags); 193 if (bcs->use_count || !try_module_get(bcs->cs->driver->owner)) { 194 gig_dbg(DEBUG_CHANNEL, "could not allocate channel %d", 195 bcs->channel); 196 spin_unlock_irqrestore(&bcs->cs->lock, flags); 197 return 0; 198 } 199 ++bcs->use_count; 200 bcs->busy = 1; 201 gig_dbg(DEBUG_CHANNEL, "allocated channel %d", bcs->channel); 202 spin_unlock_irqrestore(&bcs->cs->lock, flags); 203 return 1; 204} 205 206struct bc_state *gigaset_get_free_channel(struct cardstate *cs) 207{ 208 unsigned long flags; 209 int i; 210 211 spin_lock_irqsave(&cs->lock, flags); 212 if (!try_module_get(cs->driver->owner)) { 213 gig_dbg(DEBUG_CHANNEL, 214 "could not get module for allocating channel"); 215 spin_unlock_irqrestore(&cs->lock, flags); 216 return NULL; 217 } 218 for (i = 0; i < cs->channels; ++i) 219 if (!cs->bcs[i].use_count) { 220 ++cs->bcs[i].use_count; 221 cs->bcs[i].busy = 1; 222 spin_unlock_irqrestore(&cs->lock, flags); 223 gig_dbg(DEBUG_CHANNEL, "allocated channel %d", i); 224 return cs->bcs + i; 225 } 226 module_put(cs->driver->owner); 227 spin_unlock_irqrestore(&cs->lock, flags); 228 gig_dbg(DEBUG_CHANNEL, "no free channel"); 229 return NULL; 230} 231 232void gigaset_free_channel(struct bc_state *bcs) 233{ 234 unsigned long flags; 235 236 spin_lock_irqsave(&bcs->cs->lock, flags); 237 if (!bcs->busy) { 238 gig_dbg(DEBUG_CHANNEL, "could not free channel %d", 239 bcs->channel); 240 spin_unlock_irqrestore(&bcs->cs->lock, flags); 241 return; 242 } 243 --bcs->use_count; 244 bcs->busy = 0; 245 module_put(bcs->cs->driver->owner); 246 gig_dbg(DEBUG_CHANNEL, "freed channel %d", bcs->channel); 247 spin_unlock_irqrestore(&bcs->cs->lock, flags); 248} 249 250int gigaset_get_channels(struct cardstate *cs) 251{ 252 unsigned long flags; 253 int i; 254 255 spin_lock_irqsave(&cs->lock, flags); 256 for (i = 0; i < cs->channels; ++i) 257 if (cs->bcs[i].use_count) { 258 spin_unlock_irqrestore(&cs->lock, flags); 259 gig_dbg(DEBUG_CHANNEL, 260 "could not allocate all channels"); 261 return 0; 262 } 263 for (i = 0; i < cs->channels; ++i) 264 ++cs->bcs[i].use_count; 265 spin_unlock_irqrestore(&cs->lock, flags); 266 267 gig_dbg(DEBUG_CHANNEL, "allocated all channels"); 268 269 return 1; 270} 271 272void gigaset_free_channels(struct cardstate *cs) 273{ 274 unsigned long flags; 275 int i; 276 277 gig_dbg(DEBUG_CHANNEL, "unblocking all channels"); 278 spin_lock_irqsave(&cs->lock, flags); 279 for (i = 0; i < cs->channels; ++i) 280 --cs->bcs[i].use_count; 281 spin_unlock_irqrestore(&cs->lock, flags); 282} 283 284void gigaset_block_channels(struct cardstate *cs) 285{ 286 unsigned long flags; 287 int i; 288 289 gig_dbg(DEBUG_CHANNEL, "blocking all channels"); 290 spin_lock_irqsave(&cs->lock, flags); 291 for (i = 0; i < cs->channels; ++i) 292 ++cs->bcs[i].use_count; 293 spin_unlock_irqrestore(&cs->lock, flags); 294} 295 296static void clear_events(struct cardstate *cs) 297{ 298 struct event_t *ev; 299 unsigned head, tail; 300 unsigned long flags; 301 302 spin_lock_irqsave(&cs->ev_lock, flags); 303 304 head = cs->ev_head; 305 tail = cs->ev_tail; 306 307 while (tail != head) { 308 ev = cs->events + head; 309 kfree(ev->ptr); 310 head = (head + 1) % MAX_EVENTS; 311 } 312 313 cs->ev_head = tail; 314 315 spin_unlock_irqrestore(&cs->ev_lock, flags); 316} 317 318/** 319 * gigaset_add_event() - add event to device event queue 320 * @cs: device descriptor structure. 321 * @at_state: connection state structure. 322 * @type: event type. 323 * @ptr: pointer parameter for event. 324 * @parameter: integer parameter for event. 325 * @arg: pointer parameter for event. 326 * 327 * Allocate an event queue entry from the device's event queue, and set it up 328 * with the parameters given. 329 * 330 * Return value: added event 331 */ 332struct event_t *gigaset_add_event(struct cardstate *cs, 333 struct at_state_t *at_state, int type, 334 void *ptr, int parameter, void *arg) 335{ 336 unsigned long flags; 337 unsigned next, tail; 338 struct event_t *event = NULL; 339 340 gig_dbg(DEBUG_EVENT, "queueing event %d", type); 341 342 spin_lock_irqsave(&cs->ev_lock, flags); 343 344 tail = cs->ev_tail; 345 next = (tail + 1) % MAX_EVENTS; 346 if (unlikely(next == cs->ev_head)) 347 dev_err(cs->dev, "event queue full\n"); 348 else { 349 event = cs->events + tail; 350 event->type = type; 351 event->at_state = at_state; 352 event->cid = -1; 353 event->ptr = ptr; 354 event->arg = arg; 355 event->parameter = parameter; 356 cs->ev_tail = next; 357 } 358 359 spin_unlock_irqrestore(&cs->ev_lock, flags); 360 361 return event; 362} 363EXPORT_SYMBOL_GPL(gigaset_add_event); 364 365static void free_strings(struct at_state_t *at_state) 366{ 367 int i; 368 369 for (i = 0; i < STR_NUM; ++i) { 370 kfree(at_state->str_var[i]); 371 at_state->str_var[i] = NULL; 372 } 373} 374 375static void clear_at_state(struct at_state_t *at_state) 376{ 377 free_strings(at_state); 378} 379 380static void dealloc_at_states(struct cardstate *cs) 381{ 382 struct at_state_t *cur, *next; 383 384 list_for_each_entry_safe(cur, next, &cs->temp_at_states, list) { 385 list_del(&cur->list); 386 free_strings(cur); 387 kfree(cur); 388 } 389} 390 391static void gigaset_freebcs(struct bc_state *bcs) 392{ 393 int i; 394 395 gig_dbg(DEBUG_INIT, "freeing bcs[%d]->hw", bcs->channel); 396 if (!bcs->cs->ops->freebcshw(bcs)) 397 gig_dbg(DEBUG_INIT, "failed"); 398 399 gig_dbg(DEBUG_INIT, "clearing bcs[%d]->at_state", bcs->channel); 400 clear_at_state(&bcs->at_state); 401 gig_dbg(DEBUG_INIT, "freeing bcs[%d]->skb", bcs->channel); 402 dev_kfree_skb(bcs->rx_skb); 403 bcs->rx_skb = NULL; 404 405 for (i = 0; i < AT_NUM; ++i) { 406 kfree(bcs->commands[i]); 407 bcs->commands[i] = NULL; 408 } 409} 410 411static struct cardstate *alloc_cs(struct gigaset_driver *drv) 412{ 413 unsigned long flags; 414 unsigned i; 415 struct cardstate *cs; 416 struct cardstate *ret = NULL; 417 418 spin_lock_irqsave(&drv->lock, flags); 419 if (drv->blocked) 420 goto exit; 421 for (i = 0; i < drv->minors; ++i) { 422 cs = drv->cs + i; 423 if (!(cs->flags & VALID_MINOR)) { 424 cs->flags = VALID_MINOR; 425 ret = cs; 426 break; 427 } 428 } 429exit: 430 spin_unlock_irqrestore(&drv->lock, flags); 431 return ret; 432} 433 434static void free_cs(struct cardstate *cs) 435{ 436 cs->flags = 0; 437} 438 439static void make_valid(struct cardstate *cs, unsigned mask) 440{ 441 unsigned long flags; 442 struct gigaset_driver *drv = cs->driver; 443 spin_lock_irqsave(&drv->lock, flags); 444 cs->flags |= mask; 445 spin_unlock_irqrestore(&drv->lock, flags); 446} 447 448static void make_invalid(struct cardstate *cs, unsigned mask) 449{ 450 unsigned long flags; 451 struct gigaset_driver *drv = cs->driver; 452 spin_lock_irqsave(&drv->lock, flags); 453 cs->flags &= ~mask; 454 spin_unlock_irqrestore(&drv->lock, flags); 455} 456 457/** 458 * gigaset_freecs() - free all associated ressources of a device 459 * @cs: device descriptor structure. 460 * 461 * Stops all tasklets and timers, unregisters the device from all 462 * subsystems it was registered to, deallocates the device structure 463 * @cs and all structures referenced from it. 464 * Operations on the device should be stopped before calling this. 465 */ 466void gigaset_freecs(struct cardstate *cs) 467{ 468 int i; 469 unsigned long flags; 470 471 if (!cs) 472 return; 473 474 mutex_lock(&cs->mutex); 475 476 if (!cs->bcs) 477 goto f_cs; 478 if (!cs->inbuf) 479 goto f_bcs; 480 481 spin_lock_irqsave(&cs->lock, flags); 482 cs->running = 0; 483 spin_unlock_irqrestore(&cs->lock, flags); /* event handler and timer are 484 not rescheduled below */ 485 486 tasklet_kill(&cs->event_tasklet); 487 del_timer_sync(&cs->timer); 488 489 switch (cs->cs_init) { 490 default: 491 /* clear B channel structures */ 492 for (i = 0; i < cs->channels; ++i) { 493 gig_dbg(DEBUG_INIT, "clearing bcs[%d]", i); 494 gigaset_freebcs(cs->bcs + i); 495 } 496 497 /* clear device sysfs */ 498 gigaset_free_dev_sysfs(cs); 499 500 gigaset_if_free(cs); 501 502 gig_dbg(DEBUG_INIT, "clearing hw"); 503 cs->ops->freecshw(cs); 504 505 /* fall through */ 506 case 2: /* error in initcshw */ 507 /* Deregister from LL */ 508 make_invalid(cs, VALID_ID); 509 gigaset_isdn_unregdev(cs); 510 511 /* fall through */ 512 case 1: /* error when registering to LL */ 513 gig_dbg(DEBUG_INIT, "clearing at_state"); 514 clear_at_state(&cs->at_state); 515 dealloc_at_states(cs); 516 517 /* fall through */ 518 case 0: /* error in basic setup */ 519 clear_events(cs); 520 gig_dbg(DEBUG_INIT, "freeing inbuf"); 521 kfree(cs->inbuf); 522 } 523f_bcs: gig_dbg(DEBUG_INIT, "freeing bcs[]"); 524 kfree(cs->bcs); 525f_cs: gig_dbg(DEBUG_INIT, "freeing cs"); 526 mutex_unlock(&cs->mutex); 527 free_cs(cs); 528} 529EXPORT_SYMBOL_GPL(gigaset_freecs); 530 531void gigaset_at_init(struct at_state_t *at_state, struct bc_state *bcs, 532 struct cardstate *cs, int cid) 533{ 534 int i; 535 536 INIT_LIST_HEAD(&at_state->list); 537 at_state->waiting = 0; 538 at_state->getstring = 0; 539 at_state->pending_commands = 0; 540 at_state->timer_expires = 0; 541 at_state->timer_active = 0; 542 at_state->timer_index = 0; 543 at_state->seq_index = 0; 544 at_state->ConState = 0; 545 for (i = 0; i < STR_NUM; ++i) 546 at_state->str_var[i] = NULL; 547 at_state->int_var[VAR_ZDLE] = 0; 548 at_state->int_var[VAR_ZCTP] = -1; 549 at_state->int_var[VAR_ZSAU] = ZSAU_NULL; 550 at_state->cs = cs; 551 at_state->bcs = bcs; 552 at_state->cid = cid; 553 if (!cid) 554 at_state->replystruct = cs->tabnocid; 555 else 556 at_state->replystruct = cs->tabcid; 557} 558 559 560static void gigaset_inbuf_init(struct inbuf_t *inbuf, struct cardstate *cs) 561/* inbuf->read must be allocated before! */ 562{ 563 inbuf->head = 0; 564 inbuf->tail = 0; 565 inbuf->cs = cs; 566 inbuf->inputstate = INS_command; 567} 568 569/** 570 * gigaset_fill_inbuf() - append received data to input buffer 571 * @inbuf: buffer structure. 572 * @src: received data. 573 * @numbytes: number of bytes received. 574 */ 575int gigaset_fill_inbuf(struct inbuf_t *inbuf, const unsigned char *src, 576 unsigned numbytes) 577{ 578 unsigned n, head, tail, bytesleft; 579 580 gig_dbg(DEBUG_INTR, "received %u bytes", numbytes); 581 582 if (!numbytes) 583 return 0; 584 585 bytesleft = numbytes; 586 tail = inbuf->tail; 587 head = inbuf->head; 588 gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail); 589 590 while (bytesleft) { 591 if (head > tail) 592 n = head - 1 - tail; 593 else if (head == 0) 594 n = (RBUFSIZE-1) - tail; 595 else 596 n = RBUFSIZE - tail; 597 if (!n) { 598 dev_err(inbuf->cs->dev, 599 "buffer overflow (%u bytes lost)\n", 600 bytesleft); 601 break; 602 } 603 if (n > bytesleft) 604 n = bytesleft; 605 memcpy(inbuf->data + tail, src, n); 606 bytesleft -= n; 607 tail = (tail + n) % RBUFSIZE; 608 src += n; 609 } 610 gig_dbg(DEBUG_INTR, "setting tail to %u", tail); 611 inbuf->tail = tail; 612 return numbytes != bytesleft; 613} 614EXPORT_SYMBOL_GPL(gigaset_fill_inbuf); 615 616/* Initialize the b-channel structure */ 617static struct bc_state *gigaset_initbcs(struct bc_state *bcs, 618 struct cardstate *cs, int channel) 619{ 620 int i; 621 622 bcs->tx_skb = NULL; 623 624 skb_queue_head_init(&bcs->squeue); 625 626 bcs->corrupted = 0; 627 bcs->trans_down = 0; 628 bcs->trans_up = 0; 629 630 gig_dbg(DEBUG_INIT, "setting up bcs[%d]->at_state", channel); 631 gigaset_at_init(&bcs->at_state, bcs, cs, -1); 632 633#ifdef CONFIG_GIGASET_DEBUG 634 bcs->emptycount = 0; 635#endif 636 637 bcs->rx_bufsize = 0; 638 bcs->rx_skb = NULL; 639 bcs->rx_fcs = PPP_INITFCS; 640 bcs->inputstate = 0; 641 bcs->channel = channel; 642 bcs->cs = cs; 643 644 bcs->chstate = 0; 645 bcs->use_count = 1; 646 bcs->busy = 0; 647 bcs->ignore = cs->ignoreframes; 648 649 for (i = 0; i < AT_NUM; ++i) 650 bcs->commands[i] = NULL; 651 652 spin_lock_init(&bcs->aplock); 653 bcs->ap = NULL; 654 bcs->apconnstate = 0; 655 656 gig_dbg(DEBUG_INIT, " setting up bcs[%d]->hw", channel); 657 if (cs->ops->initbcshw(bcs)) 658 return bcs; 659 660 gig_dbg(DEBUG_INIT, " failed"); 661 return NULL; 662} 663 664/** 665 * gigaset_initcs() - initialize device structure 666 * @drv: hardware driver the device belongs to 667 * @channels: number of B channels supported by device 668 * @onechannel: !=0 if B channel data and AT commands share one 669 * communication channel (M10x), 670 * ==0 if B channels have separate communication channels (base) 671 * @ignoreframes: number of frames to ignore after setting up B channel 672 * @cidmode: !=0: start in CallID mode 673 * @modulename: name of driver module for LL registration 674 * 675 * Allocate and initialize cardstate structure for Gigaset driver 676 * Calls hardware dependent gigaset_initcshw() function 677 * Calls B channel initialization function gigaset_initbcs() for each B channel 678 * 679 * Return value: 680 * pointer to cardstate structure 681 */ 682struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels, 683 int onechannel, int ignoreframes, 684 int cidmode, const char *modulename) 685{ 686 struct cardstate *cs; 687 unsigned long flags; 688 int i; 689 690 gig_dbg(DEBUG_INIT, "allocating cs"); 691 cs = alloc_cs(drv); 692 if (!cs) { 693 pr_err("maximum number of devices exceeded\n"); 694 return NULL; 695 } 696 697 gig_dbg(DEBUG_INIT, "allocating bcs[0..%d]", channels - 1); 698 cs->bcs = kmalloc(channels * sizeof(struct bc_state), GFP_KERNEL); 699 if (!cs->bcs) { 700 pr_err("out of memory\n"); 701 goto error; 702 } 703 gig_dbg(DEBUG_INIT, "allocating inbuf"); 704 cs->inbuf = kmalloc(sizeof(struct inbuf_t), GFP_KERNEL); 705 if (!cs->inbuf) { 706 pr_err("out of memory\n"); 707 goto error; 708 } 709 710 cs->cs_init = 0; 711 cs->channels = channels; 712 cs->onechannel = onechannel; 713 cs->ignoreframes = ignoreframes; 714 INIT_LIST_HEAD(&cs->temp_at_states); 715 cs->running = 0; 716 init_timer(&cs->timer); /* clear next & prev */ 717 spin_lock_init(&cs->ev_lock); 718 cs->ev_tail = 0; 719 cs->ev_head = 0; 720 721 tasklet_init(&cs->event_tasklet, gigaset_handle_event, 722 (unsigned long) cs); 723 cs->commands_pending = 0; 724 cs->cur_at_seq = 0; 725 cs->gotfwver = -1; 726 cs->open_count = 0; 727 cs->dev = NULL; 728 cs->tty = NULL; 729 cs->tty_dev = NULL; 730 cs->cidmode = cidmode != 0; 731 cs->tabnocid = gigaset_tab_nocid; 732 cs->tabcid = gigaset_tab_cid; 733 734 init_waitqueue_head(&cs->waitqueue); 735 cs->waiting = 0; 736 737 cs->mode = M_UNKNOWN; 738 cs->mstate = MS_UNINITIALIZED; 739 740 ++cs->cs_init; 741 742 gig_dbg(DEBUG_INIT, "setting up at_state"); 743 spin_lock_init(&cs->lock); 744 gigaset_at_init(&cs->at_state, NULL, cs, 0); 745 cs->dle = 0; 746 cs->cbytes = 0; 747 748 gig_dbg(DEBUG_INIT, "setting up inbuf"); 749 gigaset_inbuf_init(cs->inbuf, cs); 750 751 cs->connected = 0; 752 cs->isdn_up = 0; 753 754 gig_dbg(DEBUG_INIT, "setting up cmdbuf"); 755 cs->cmdbuf = cs->lastcmdbuf = NULL; 756 spin_lock_init(&cs->cmdlock); 757 cs->curlen = 0; 758 cs->cmdbytes = 0; 759 760 gig_dbg(DEBUG_INIT, "setting up iif"); 761 if (!gigaset_isdn_regdev(cs, modulename)) { 762 pr_err("error registering ISDN device\n"); 763 goto error; 764 } 765 766 make_valid(cs, VALID_ID); 767 ++cs->cs_init; 768 gig_dbg(DEBUG_INIT, "setting up hw"); 769 if (!cs->ops->initcshw(cs)) 770 goto error; 771 772 ++cs->cs_init; 773 774 /* set up character device */ 775 gigaset_if_init(cs); 776 777 /* set up device sysfs */ 778 gigaset_init_dev_sysfs(cs); 779 780 /* set up channel data structures */ 781 for (i = 0; i < channels; ++i) { 782 gig_dbg(DEBUG_INIT, "setting up bcs[%d]", i); 783 if (!gigaset_initbcs(cs->bcs + i, cs, i)) { 784 pr_err("could not allocate channel %d data\n", i); 785 goto error; 786 } 787 } 788 789 spin_lock_irqsave(&cs->lock, flags); 790 cs->running = 1; 791 spin_unlock_irqrestore(&cs->lock, flags); 792 setup_timer(&cs->timer, timer_tick, (unsigned long) cs); 793 cs->timer.expires = jiffies + msecs_to_jiffies(GIG_TICK); 794 add_timer(&cs->timer); 795 796 gig_dbg(DEBUG_INIT, "cs initialized"); 797 return cs; 798 799error: 800 gig_dbg(DEBUG_INIT, "failed"); 801 gigaset_freecs(cs); 802 return NULL; 803} 804EXPORT_SYMBOL_GPL(gigaset_initcs); 805 806/* ReInitialize the b-channel structure on hangup */ 807void gigaset_bcs_reinit(struct bc_state *bcs) 808{ 809 struct sk_buff *skb; 810 struct cardstate *cs = bcs->cs; 811 unsigned long flags; 812 813 while ((skb = skb_dequeue(&bcs->squeue)) != NULL) 814 dev_kfree_skb(skb); 815 816 spin_lock_irqsave(&cs->lock, flags); 817 clear_at_state(&bcs->at_state); 818 bcs->at_state.ConState = 0; 819 bcs->at_state.timer_active = 0; 820 bcs->at_state.timer_expires = 0; 821 bcs->at_state.cid = -1; /* No CID defined */ 822 spin_unlock_irqrestore(&cs->lock, flags); 823 824 bcs->inputstate = 0; 825 826#ifdef CONFIG_GIGASET_DEBUG 827 bcs->emptycount = 0; 828#endif 829 830 bcs->rx_fcs = PPP_INITFCS; 831 bcs->chstate = 0; 832 833 bcs->ignore = cs->ignoreframes; 834 dev_kfree_skb(bcs->rx_skb); 835 bcs->rx_skb = NULL; 836 837 cs->ops->reinitbcshw(bcs); 838} 839 840static void cleanup_cs(struct cardstate *cs) 841{ 842 struct cmdbuf_t *cb, *tcb; 843 int i; 844 unsigned long flags; 845 846 spin_lock_irqsave(&cs->lock, flags); 847 848 cs->mode = M_UNKNOWN; 849 cs->mstate = MS_UNINITIALIZED; 850 851 clear_at_state(&cs->at_state); 852 dealloc_at_states(cs); 853 free_strings(&cs->at_state); 854 gigaset_at_init(&cs->at_state, NULL, cs, 0); 855 856 cs->inbuf->inputstate = INS_command; 857 cs->inbuf->head = 0; 858 cs->inbuf->tail = 0; 859 860 cb = cs->cmdbuf; 861 while (cb) { 862 tcb = cb; 863 cb = cb->next; 864 kfree(tcb); 865 } 866 cs->cmdbuf = cs->lastcmdbuf = NULL; 867 cs->curlen = 0; 868 cs->cmdbytes = 0; 869 cs->gotfwver = -1; 870 cs->dle = 0; 871 cs->cur_at_seq = 0; 872 cs->commands_pending = 0; 873 cs->cbytes = 0; 874 875 spin_unlock_irqrestore(&cs->lock, flags); 876 877 for (i = 0; i < cs->channels; ++i) { 878 gigaset_freebcs(cs->bcs + i); 879 if (!gigaset_initbcs(cs->bcs + i, cs, i)) 880 pr_err("could not allocate channel %d data\n", i); 881 } 882 883 if (cs->waiting) { 884 cs->cmd_result = -ENODEV; 885 cs->waiting = 0; 886 wake_up_interruptible(&cs->waitqueue); 887 } 888} 889 890 891/** 892 * gigaset_start() - start device operations 893 * @cs: device descriptor structure. 894 * 895 * Prepares the device for use by setting up communication parameters, 896 * scheduling an EV_START event to initiate device initialization, and 897 * waiting for completion of the initialization. 898 * 899 * Return value: 900 * 1 - success, 0 - error 901 */ 902int gigaset_start(struct cardstate *cs) 903{ 904 unsigned long flags; 905 906 if (mutex_lock_interruptible(&cs->mutex)) 907 return 0; 908 909 spin_lock_irqsave(&cs->lock, flags); 910 cs->connected = 1; 911 spin_unlock_irqrestore(&cs->lock, flags); 912 913 if (cs->mstate != MS_LOCKED) { 914 cs->ops->set_modem_ctrl(cs, 0, TIOCM_DTR|TIOCM_RTS); 915 cs->ops->baud_rate(cs, B115200); 916 cs->ops->set_line_ctrl(cs, CS8); 917 cs->control_state = TIOCM_DTR|TIOCM_RTS; 918 } 919 920 cs->waiting = 1; 921 922 if (!gigaset_add_event(cs, &cs->at_state, EV_START, NULL, 0, NULL)) { 923 cs->waiting = 0; 924 goto error; 925 } 926 gigaset_schedule_event(cs); 927 928 wait_event(cs->waitqueue, !cs->waiting); 929 930 mutex_unlock(&cs->mutex); 931 return 1; 932 933error: 934 mutex_unlock(&cs->mutex); 935 return 0; 936} 937EXPORT_SYMBOL_GPL(gigaset_start); 938 939/** 940 * gigaset_shutdown() - shut down device operations 941 * @cs: device descriptor structure. 942 * 943 * Deactivates the device by scheduling an EV_SHUTDOWN event and 944 * waiting for completion of the shutdown. 945 * 946 * Return value: 947 * 0 - success, -1 - error (no device associated) 948 */ 949int gigaset_shutdown(struct cardstate *cs) 950{ 951 mutex_lock(&cs->mutex); 952 953 if (!(cs->flags & VALID_MINOR)) { 954 mutex_unlock(&cs->mutex); 955 return -1; 956 } 957 958 cs->waiting = 1; 959 960 if (!gigaset_add_event(cs, &cs->at_state, EV_SHUTDOWN, NULL, 0, NULL)) 961 goto exit; 962 gigaset_schedule_event(cs); 963 964 wait_event(cs->waitqueue, !cs->waiting); 965 966 cleanup_cs(cs); 967 968exit: 969 mutex_unlock(&cs->mutex); 970 return 0; 971} 972EXPORT_SYMBOL_GPL(gigaset_shutdown); 973 974/** 975 * gigaset_stop() - stop device operations 976 * @cs: device descriptor structure. 977 * 978 * Stops operations on the device by scheduling an EV_STOP event and 979 * waiting for completion of the shutdown. 980 */ 981void gigaset_stop(struct cardstate *cs) 982{ 983 mutex_lock(&cs->mutex); 984 985 cs->waiting = 1; 986 987 if (!gigaset_add_event(cs, &cs->at_state, EV_STOP, NULL, 0, NULL)) 988 goto exit; 989 gigaset_schedule_event(cs); 990 991 wait_event(cs->waitqueue, !cs->waiting); 992 993 cleanup_cs(cs); 994 995exit: 996 mutex_unlock(&cs->mutex); 997} 998EXPORT_SYMBOL_GPL(gigaset_stop); 999 1000static LIST_HEAD(drivers); 1001static DEFINE_SPINLOCK(driver_lock); 1002 1003struct cardstate *gigaset_get_cs_by_id(int id) 1004{ 1005 unsigned long flags; 1006 struct cardstate *ret = NULL; 1007 struct cardstate *cs; 1008 struct gigaset_driver *drv; 1009 unsigned i; 1010 1011 spin_lock_irqsave(&driver_lock, flags); 1012 list_for_each_entry(drv, &drivers, list) { 1013 spin_lock(&drv->lock); 1014 for (i = 0; i < drv->minors; ++i) { 1015 cs = drv->cs + i; 1016 if ((cs->flags & VALID_ID) && cs->myid == id) { 1017 ret = cs; 1018 break; 1019 } 1020 } 1021 spin_unlock(&drv->lock); 1022 if (ret) 1023 break; 1024 } 1025 spin_unlock_irqrestore(&driver_lock, flags); 1026 return ret; 1027} 1028 1029static struct cardstate *gigaset_get_cs_by_minor(unsigned minor) 1030{ 1031 unsigned long flags; 1032 struct cardstate *ret = NULL; 1033 struct gigaset_driver *drv; 1034 unsigned index; 1035 1036 spin_lock_irqsave(&driver_lock, flags); 1037 list_for_each_entry(drv, &drivers, list) { 1038 if (minor < drv->minor || minor >= drv->minor + drv->minors) 1039 continue; 1040 index = minor - drv->minor; 1041 spin_lock(&drv->lock); 1042 if (drv->cs[index].flags & VALID_MINOR) 1043 ret = drv->cs + index; 1044 spin_unlock(&drv->lock); 1045 if (ret) 1046 break; 1047 } 1048 spin_unlock_irqrestore(&driver_lock, flags); 1049 return ret; 1050} 1051 1052struct cardstate *gigaset_get_cs_by_tty(struct tty_struct *tty) 1053{ 1054 if (tty->index < 0 || tty->index >= tty->driver->num) 1055 return NULL; 1056 return gigaset_get_cs_by_minor(tty->index + tty->driver->minor_start); 1057} 1058 1059/** 1060 * gigaset_freedriver() - free all associated ressources of a driver 1061 * @drv: driver descriptor structure. 1062 * 1063 * Unregisters the driver from the system and deallocates the driver 1064 * structure @drv and all structures referenced from it. 1065 * All devices should be shut down before calling this. 1066 */ 1067void gigaset_freedriver(struct gigaset_driver *drv) 1068{ 1069 unsigned long flags; 1070 1071 spin_lock_irqsave(&driver_lock, flags); 1072 list_del(&drv->list); 1073 spin_unlock_irqrestore(&driver_lock, flags); 1074 1075 gigaset_if_freedriver(drv); 1076 1077 kfree(drv->cs); 1078 kfree(drv); 1079} 1080EXPORT_SYMBOL_GPL(gigaset_freedriver); 1081 1082/** 1083 * gigaset_initdriver() - initialize driver structure 1084 * @minor: First minor number 1085 * @minors: Number of minors this driver can handle 1086 * @procname: Name of the driver 1087 * @devname: Name of the device files (prefix without minor number) 1088 * 1089 * Allocate and initialize gigaset_driver structure. Initialize interface. 1090 * 1091 * Return value: 1092 * Pointer to the gigaset_driver structure on success, NULL on failure. 1093 */ 1094struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors, 1095 const char *procname, 1096 const char *devname, 1097 const struct gigaset_ops *ops, 1098 struct module *owner) 1099{ 1100 struct gigaset_driver *drv; 1101 unsigned long flags; 1102 unsigned i; 1103 1104 drv = kmalloc(sizeof *drv, GFP_KERNEL); 1105 if (!drv) 1106 return NULL; 1107 1108 drv->have_tty = 0; 1109 drv->minor = minor; 1110 drv->minors = minors; 1111 spin_lock_init(&drv->lock); 1112 drv->blocked = 0; 1113 drv->ops = ops; 1114 drv->owner = owner; 1115 INIT_LIST_HEAD(&drv->list); 1116 1117 drv->cs = kmalloc(minors * sizeof *drv->cs, GFP_KERNEL); 1118 if (!drv->cs) 1119 goto error; 1120 1121 for (i = 0; i < minors; ++i) { 1122 drv->cs[i].flags = 0; 1123 drv->cs[i].driver = drv; 1124 drv->cs[i].ops = drv->ops; 1125 drv->cs[i].minor_index = i; 1126 mutex_init(&drv->cs[i].mutex); 1127 } 1128 1129 gigaset_if_initdriver(drv, procname, devname); 1130 1131 spin_lock_irqsave(&driver_lock, flags); 1132 list_add(&drv->list, &drivers); 1133 spin_unlock_irqrestore(&driver_lock, flags); 1134 1135 return drv; 1136 1137error: 1138 kfree(drv->cs); 1139 kfree(drv); 1140 return NULL; 1141} 1142EXPORT_SYMBOL_GPL(gigaset_initdriver); 1143 1144/** 1145 * gigaset_blockdriver() - block driver 1146 * @drv: driver descriptor structure. 1147 * 1148 * Prevents the driver from attaching new devices, in preparation for 1149 * deregistration. 1150 */ 1151void gigaset_blockdriver(struct gigaset_driver *drv) 1152{ 1153 drv->blocked = 1; 1154} 1155EXPORT_SYMBOL_GPL(gigaset_blockdriver); 1156 1157static int __init gigaset_init_module(void) 1158{ 1159 /* in accordance with the principle of least astonishment, 1160 * setting the 'debug' parameter to 1 activates a sensible 1161 * set of default debug levels 1162 */ 1163 if (gigaset_debuglevel == 1) 1164 gigaset_debuglevel = DEBUG_DEFAULT; 1165 1166 pr_info(DRIVER_DESC DRIVER_DESC_DEBUG "\n"); 1167 gigaset_isdn_regdrv(); 1168 return 0; 1169} 1170 1171static void __exit gigaset_exit_module(void) 1172{ 1173 gigaset_isdn_unregdrv(); 1174} 1175 1176module_init(gigaset_init_module); 1177module_exit(gigaset_exit_module); 1178 1179MODULE_AUTHOR(DRIVER_AUTHOR); 1180MODULE_DESCRIPTION(DRIVER_DESC); 1181 1182MODULE_LICENSE("GPL"); 1183