drivers/isdn/gigaset/common.c

   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/ctype.h>
  18 #include <linux/module.h>
  19 #include <linux/moduleparam.h>
  20
  21 /* Version Information */
  22 #define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Tilman Schmidt <tilman@imap.cc>, Stefan Eilers"
  23 #define DRIVER_DESC "Driver for Gigaset 307x"
  24
  25 /* Module parameters */
  26 int gigaset_debuglevel = DEBUG_DEFAULT;
  27 EXPORT_SYMBOL_GPL(gigaset_debuglevel);
  28 module_param_named(debug, gigaset_debuglevel, int, S_IRUGO|S_IWUSR);
  29 MODULE_PARM_DESC(debug, "debug level");
  30
  31 /* driver state flags */
  32 #define VALID_MINOR     0x01
  33 #define VALID_ID        0x02
  34 #define ASSIGNED        0x04
  35
  36 /* bitwise byte inversion table */
  37 __u8 gigaset_invtab[256] = {
  38         0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
  39         0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
  40         0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
  41         0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
  42         0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
  43         0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
  44         0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
  45         0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
  46         0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
  47         0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
  48         0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
  49         0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
  50         0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
  51         0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
  52         0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
  53         0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
  54         0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
  55         0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
  56         0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
  57         0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
  58         0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
  59         0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
  60         0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
  61         0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
  62         0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
  63         0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
  64         0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
  65         0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
  66         0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
  67         0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
  68         0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
  69         0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
  70 };
  71 EXPORT_SYMBOL_GPL(gigaset_invtab);
  72
  73 void gigaset_dbg_buffer(enum debuglevel level, const unsigned char *msg,
  74                         size_t len, const unsigned char *buf)
  75 {
  76         unsigned char outbuf[80];
  77         unsigned char c;
  78         size_t space = sizeof outbuf - 1;
  79         unsigned char *out = outbuf;
  80         size_t numin = len;
  81
  82         while (numin--) {
  83                 c = *buf++;
  84                 if (c == '~' || c == '^' || c == '\\') {
  85                         if (!space--)
  86                                 break;
  87                         *out++ = '\\';
  88                 }
  89                 if (c & 0x80) {
  90                         if (!space--)
  91                                 break;
  92                         *out++ = '~';
  93                         c ^= 0x80;
  94                 }
  95                 if (c < 0x20 || c == 0x7f) {
  96                         if (!space--)
  97                                 break;
  98                         *out++ = '^';
  99                         c ^= 0x40;
 100                 }
 101                 if (!space--)
 102                         break;
 103                 *out++ = c;
 104         }
 105         *out = 0;
 106
 107         gig_dbg(level, "%s (%u bytes): %s", msg, (unsigned) len, outbuf);
 108 }
 109 EXPORT_SYMBOL_GPL(gigaset_dbg_buffer);
 110
 111 static int setflags(struct cardstate *cs, unsigned flags, unsigned delay)
 112 {
 113         int r;
 114
 115         r = cs->ops->set_modem_ctrl(cs, cs->control_state, flags);
 116         cs->control_state = flags;
 117         if (r < 0)
 118                 return r;
 119
 120         if (delay) {
 121                 set_current_state(TASK_INTERRUPTIBLE);
 122                 schedule_timeout(delay * HZ / 1000);
 123         }
 124
 125         return 0;
 126 }
 127
 128 int gigaset_enterconfigmode(struct cardstate *cs)
 129 {
 130         int i, r;
 131
 132         cs->control_state = TIOCM_RTS; //FIXME
 133
 134         r = setflags(cs, TIOCM_DTR, 200);
 135         if (r < 0)
 136                 goto error;
 137         r = setflags(cs, 0, 200);
 138         if (r < 0)
 139                 goto error;
 140         for (i = 0; i < 5; ++i) {
 141                 r = setflags(cs, TIOCM_RTS, 100);
 142                 if (r < 0)
 143                         goto error;
 144                 r = setflags(cs, 0, 100);
 145                 if (r < 0)
 146                         goto error;
 147         }
 148         r = setflags(cs, TIOCM_RTS|TIOCM_DTR, 800);
 149         if (r < 0)
 150                 goto error;
 151
 152         return 0;
 153
 154 error:
 155         dev_err(cs->dev, "error %d on setuartbits\n", -r);
 156         cs->control_state = TIOCM_RTS|TIOCM_DTR; // FIXME is this a good value?
 157         cs->ops->set_modem_ctrl(cs, 0, TIOCM_RTS|TIOCM_DTR);
 158
 159         return -1; //r
 160 }
 161
 162 static int test_timeout(struct at_state_t *at_state)
 163 {
 164         if (!at_state->timer_expires)
 165                 return 0;
 166
 167         if (--at_state->timer_expires) {
 168                 gig_dbg(DEBUG_MCMD, "decreased timer of %p to %lu",
 169                         at_state, at_state->timer_expires);
 170                 return 0;
 171         }
 172
 173         if (!gigaset_add_event(at_state->cs, at_state, EV_TIMEOUT, NULL,
 174                                at_state->timer_index, NULL)) {
 175                 //FIXME what should we do?
 176         }
 177
 178         return 1;
 179 }
 180
 181 static void timer_tick(unsigned long data)
 182 {
 183         struct cardstate *cs = (struct cardstate *) data;
 184         unsigned long flags;
 185         unsigned channel;
 186         struct at_state_t *at_state;
 187         int timeout = 0;
 188
 189         spin_lock_irqsave(&cs->lock, flags);
 190
 191         for (channel = 0; channel < cs->channels; ++channel)
 192                 if (test_timeout(&cs->bcs[channel].at_state))
 193                         timeout = 1;
 194
 195         if (test_timeout(&cs->at_state))
 196                 timeout = 1;
 197
 198         list_for_each_entry(at_state, &cs->temp_at_states, list)
 199                 if (test_timeout(at_state))
 200                         timeout = 1;
 201
 202         if (cs->running) {
 203                 mod_timer(&cs->timer, jiffies + msecs_to_jiffies(GIG_TICK));
 204                 if (timeout) {
 205                         gig_dbg(DEBUG_CMD, "scheduling timeout");
 206                         tasklet_schedule(&cs->event_tasklet);
 207                 }
 208         }
 209
 210         spin_unlock_irqrestore(&cs->lock, flags);
 211 }
 212
 213 int gigaset_get_channel(struct bc_state *bcs)
 214 {
 215         unsigned long flags;
 216
 217         spin_lock_irqsave(&bcs->cs->lock, flags);
 218         if (bcs->use_count) {
 219                 gig_dbg(DEBUG_ANY, "could not allocate channel %d",
 220                         bcs->channel);
 221                 spin_unlock_irqrestore(&bcs->cs->lock, flags);
 222                 return 0;
 223         }
 224         ++bcs->use_count;
 225         bcs->busy = 1;
 226         gig_dbg(DEBUG_ANY, "allocated channel %d", bcs->channel);
 227         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 228         return 1;
 229 }
 230
 231 void gigaset_free_channel(struct bc_state *bcs)
 232 {
 233         unsigned long flags;
 234
 235         spin_lock_irqsave(&bcs->cs->lock, flags);
 236         if (!bcs->busy) {
 237                 gig_dbg(DEBUG_ANY, "could not free channel %d", bcs->channel);
 238                 spin_unlock_irqrestore(&bcs->cs->lock, flags);
 239                 return;
 240         }
 241         --bcs->use_count;
 242         bcs->busy = 0;
 243         gig_dbg(DEBUG_ANY, "freed channel %d", bcs->channel);
 244         spin_unlock_irqrestore(&bcs->cs->lock, flags);
 245 }
 246
 247 int gigaset_get_channels(struct cardstate *cs)
 248 {
 249         unsigned long flags;
 250         int i;
 251
 252         spin_lock_irqsave(&cs->lock, flags);
 253         for (i = 0; i < cs->channels; ++i)
 254                 if (cs->bcs[i].use_count) {
 255                         spin_unlock_irqrestore(&cs->lock, flags);
 256                         gig_dbg(DEBUG_ANY, "could not allocate all channels");
 257                         return 0;
 258                 }
 259         for (i = 0; i < cs->channels; ++i)
 260                 ++cs->bcs[i].use_count;
 261         spin_unlock_irqrestore(&cs->lock, flags);
 262
 263         gig_dbg(DEBUG_ANY, "allocated all channels");
 264
 265         return 1;
 266 }
 267
 268 void gigaset_free_channels(struct cardstate *cs)
 269 {
 270         unsigned long flags;
 271         int i;
 272
 273         gig_dbg(DEBUG_ANY, "unblocking all channels");
 274         spin_lock_irqsave(&cs->lock, flags);
 275         for (i = 0; i < cs->channels; ++i)
 276                 --cs->bcs[i].use_count;
 277         spin_unlock_irqrestore(&cs->lock, flags);
 278 }
 279
 280 void gigaset_block_channels(struct cardstate *cs)
 281 {
 282         unsigned long flags;
 283         int i;
 284
 285         gig_dbg(DEBUG_ANY, "blocking all channels");
 286         spin_lock_irqsave(&cs->lock, flags);
 287         for (i = 0; i < cs->channels; ++i)
 288                 ++cs->bcs[i].use_count;
 289         spin_unlock_irqrestore(&cs->lock, flags);
 290 }
 291
 292 static void clear_events(struct cardstate *cs)
 293 {
 294         struct event_t *ev;
 295         unsigned head, tail;
 296         unsigned long flags;
 297
 298         spin_lock_irqsave(&cs->ev_lock, flags);
 299
 300         head = cs->ev_head;
 301         tail = cs->ev_tail;
 302
 303         while (tail != head) {
 304                 ev = cs->events + head;
 305                 kfree(ev->ptr);
 306                 head = (head + 1) % MAX_EVENTS;
 307         }
 308
 309         cs->ev_head = tail;
 310
 311         spin_unlock_irqrestore(&cs->ev_lock, flags);
 312 }
 313
 314 struct event_t *gigaset_add_event(struct cardstate *cs,
 315                                   struct at_state_t *at_state, int type,
 316                                   void *ptr, int parameter, void *arg)
 317 {
 318         unsigned long flags;
 319         unsigned next, tail;
 320         struct event_t *event = NULL;
 321
 322         spin_lock_irqsave(&cs->ev_lock, flags);
 323
 324         tail = cs->ev_tail;
 325         next = (tail + 1) % MAX_EVENTS;
 326         if (unlikely(next == cs->ev_head))
 327                 err("event queue full");
 328         else {
 329                 event = cs->events + tail;
 330                 event->type = type;
 331                 event->at_state = at_state;
 332                 event->cid = -1;
 333                 event->ptr = ptr;
 334                 event->arg = arg;
 335                 event->parameter = parameter;
 336                 cs->ev_tail = next;
 337         }
 338
 339         spin_unlock_irqrestore(&cs->ev_lock, flags);
 340
 341         return event;
 342 }
 343 EXPORT_SYMBOL_GPL(gigaset_add_event);
 344
 345 static void free_strings(struct at_state_t *at_state)
 346 {
 347         int i;
 348
 349         for (i = 0; i < STR_NUM; ++i) {
 350                 kfree(at_state->str_var[i]);
 351                 at_state->str_var[i] = NULL;
 352         }
 353 }
 354
 355 static void clear_at_state(struct at_state_t *at_state)
 356 {
 357         free_strings(at_state);
 358 }
 359
 360 static void dealloc_at_states(struct cardstate *cs)
 361 {
 362         struct at_state_t *cur, *next;
 363
 364         list_for_each_entry_safe(cur, next, &cs->temp_at_states, list) {
 365                 list_del(&cur->list);
 366                 free_strings(cur);
 367                 kfree(cur);
 368         }
 369 }
 370
 371 static void gigaset_freebcs(struct bc_state *bcs)
 372 {
 373         int i;
 374
 375         gig_dbg(DEBUG_INIT, "freeing bcs[%d]->hw", bcs->channel);
 376         if (!bcs->cs->ops->freebcshw(bcs)) {
 377                 gig_dbg(DEBUG_INIT, "failed");
 378         }
 379
 380         gig_dbg(DEBUG_INIT, "clearing bcs[%d]->at_state", bcs->channel);
 381         clear_at_state(&bcs->at_state);
 382         gig_dbg(DEBUG_INIT, "freeing bcs[%d]->skb", bcs->channel);
 383
 384         if (bcs->skb)
 385                 dev_kfree_skb(bcs->skb);
 386         for (i = 0; i < AT_NUM; ++i) {
 387                 kfree(bcs->commands[i]);
 388                 bcs->commands[i] = NULL;
 389         }
 390 }
 391
 392 static struct cardstate *alloc_cs(struct gigaset_driver *drv)
 393 {
 394         unsigned long flags;
 395         unsigned i;
 396         static struct cardstate *ret = NULL;
 397
 398         spin_lock_irqsave(&drv->lock, flags);
 399         for (i = 0; i < drv->minors; ++i) {
 400                 if (!(drv->flags[i] & VALID_MINOR)) {
 401                         drv->flags[i] = VALID_MINOR;
 402                         ret = drv->cs + i;
 403                 }
 404                 if (ret)
 405                         break;
 406         }
 407         spin_unlock_irqrestore(&drv->lock, flags);
 408         return ret;
 409 }
 410
 411 static void free_cs(struct cardstate *cs)
 412 {
 413         unsigned long flags;
 414         struct gigaset_driver *drv = cs->driver;
 415         spin_lock_irqsave(&drv->lock, flags);
 416         drv->flags[cs->minor_index] = 0;
 417         spin_unlock_irqrestore(&drv->lock, flags);
 418 }
 419
 420 static void make_valid(struct cardstate *cs, unsigned mask)
 421 {
 422         unsigned long flags;
 423         struct gigaset_driver *drv = cs->driver;
 424         spin_lock_irqsave(&drv->lock, flags);
 425         drv->flags[cs->minor_index] |= mask;
 426         spin_unlock_irqrestore(&drv->lock, flags);
 427 }
 428
 429 static void make_invalid(struct cardstate *cs, unsigned mask)
 430 {
 431         unsigned long flags;
 432         struct gigaset_driver *drv = cs->driver;
 433         spin_lock_irqsave(&drv->lock, flags);
 434         drv->flags[cs->minor_index] &= ~mask;
 435         spin_unlock_irqrestore(&drv->lock, flags);
 436 }
 437
 438 void gigaset_freecs(struct cardstate *cs)
 439 {
 440         int i;
 441         unsigned long flags;
 442
 443         if (!cs)
 444                 return;
 445
 446         mutex_lock(&cs->mutex);
 447
 448         if (!cs->bcs)
 449                 goto f_cs;
 450         if (!cs->inbuf)
 451                 goto f_bcs;
 452
 453         spin_lock_irqsave(&cs->lock, flags);
 454         cs->running = 0;
 455         spin_unlock_irqrestore(&cs->lock, flags); /* event handler and timer are
 456                                                      not rescheduled below */
 457
 458         tasklet_kill(&cs->event_tasklet);
 459         del_timer_sync(&cs->timer);
 460
 461         switch (cs->cs_init) {
 462         default:
 463                 gigaset_if_free(cs);
 464
 465                 gig_dbg(DEBUG_INIT, "clearing hw");
 466                 cs->ops->freecshw(cs);
 467
 468                 //FIXME cmdbuf
 469
 470                 /* fall through */
 471         case 2: /* error in initcshw */
 472                 /* Deregister from LL */
 473                 make_invalid(cs, VALID_ID);
 474                 gig_dbg(DEBUG_INIT, "clearing iif");
 475                 gigaset_i4l_cmd(cs, ISDN_STAT_UNLOAD);
 476
 477                 /* fall through */
 478         case 1: /* error when regestering to LL */
 479                 gig_dbg(DEBUG_INIT, "clearing at_state");
 480                 clear_at_state(&cs->at_state);
 481                 dealloc_at_states(cs);
 482
 483                 /* fall through */
 484         case 0: /* error in one call to initbcs */
 485                 for (i = 0; i < cs->channels; ++i) {
 486                         gig_dbg(DEBUG_INIT, "clearing bcs[%d]", i);
 487                         gigaset_freebcs(cs->bcs + i);
 488                 }
 489
 490                 clear_events(cs);
 491                 gig_dbg(DEBUG_INIT, "freeing inbuf");
 492                 kfree(cs->inbuf);
 493         }
 494 f_bcs:  gig_dbg(DEBUG_INIT, "freeing bcs[]");
 495         kfree(cs->bcs);
 496 f_cs:   gig_dbg(DEBUG_INIT, "freeing cs");
 497         mutex_unlock(&cs->mutex);
 498         free_cs(cs);
 499 }
 500 EXPORT_SYMBOL_GPL(gigaset_freecs);
 501
 502 void gigaset_at_init(struct at_state_t *at_state, struct bc_state *bcs,
 503                      struct cardstate *cs, int cid)
 504 {
 505         int i;
 506
 507         INIT_LIST_HEAD(&at_state->list);
 508         at_state->waiting = 0;
 509         at_state->getstring = 0;
 510         at_state->pending_commands = 0;
 511         at_state->timer_expires = 0;
 512         at_state->timer_active = 0;
 513         at_state->timer_index = 0;
 514         at_state->seq_index = 0;
 515         at_state->ConState = 0;
 516         for (i = 0; i < STR_NUM; ++i)
 517                 at_state->str_var[i] = NULL;
 518         at_state->int_var[VAR_ZDLE] = 0;
 519         at_state->int_var[VAR_ZCTP] = -1;
 520         at_state->int_var[VAR_ZSAU] = ZSAU_NULL;
 521         at_state->cs = cs;
 522         at_state->bcs = bcs;
 523         at_state->cid = cid;
 524         if (!cid)
 525                 at_state->replystruct = cs->tabnocid;
 526         else
 527                 at_state->replystruct = cs->tabcid;
 528 }
 529
 530
 531 static void gigaset_inbuf_init(struct inbuf_t *inbuf, struct bc_state *bcs,
 532                                struct cardstate *cs, int inputstate)
 533 /* inbuf->read must be allocated before! */
 534 {
 535         atomic_set(&inbuf->head, 0);
 536         atomic_set(&inbuf->tail, 0);
 537         inbuf->cs = cs;
 538         inbuf->bcs = bcs; /*base driver: NULL*/
 539         inbuf->rcvbuf = NULL; //FIXME
 540         inbuf->inputstate = inputstate;
 541 }
 542
 543 /* append received bytes to inbuf */
 544 int gigaset_fill_inbuf(struct inbuf_t *inbuf, const unsigned char *src,
 545                        unsigned numbytes)
 546 {
 547         unsigned n, head, tail, bytesleft;
 548
 549         gig_dbg(DEBUG_INTR, "received %u bytes", numbytes);
 550
 551         if (!numbytes)
 552                 return 0;
 553
 554         bytesleft = numbytes;
 555         tail = atomic_read(&inbuf->tail);
 556         head = atomic_read(&inbuf->head);
 557         gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
 558
 559         while (bytesleft) {
 560                 if (head > tail)
 561                         n = head - 1 - tail;
 562                 else if (head == 0)
 563                         n = (RBUFSIZE-1) - tail;
 564                 else
 565                         n = RBUFSIZE - tail;
 566                 if (!n) {
 567                         dev_err(inbuf->cs->dev,
 568                                 "buffer overflow (%u bytes lost)", bytesleft);
 569                         break;
 570                 }
 571                 if (n > bytesleft)
 572                         n = bytesleft;
 573                 memcpy(inbuf->data + tail, src, n);
 574                 bytesleft -= n;
 575                 tail = (tail + n) % RBUFSIZE;
 576                 src += n;
 577         }
 578         gig_dbg(DEBUG_INTR, "setting tail to %u", tail);
 579         atomic_set(&inbuf->tail, tail);
 580         return numbytes != bytesleft;
 581 }
 582 EXPORT_SYMBOL_GPL(gigaset_fill_inbuf);
 583
 584 /* Initialize the b-channel structure */
 585 static struct bc_state *gigaset_initbcs(struct bc_state *bcs,
 586                                         struct cardstate *cs, int channel)
 587 {
 588         int i;
 589
 590         bcs->tx_skb = NULL; //FIXME -> hw part
 591
 592         skb_queue_head_init(&bcs->squeue);
 593
 594         bcs->corrupted = 0;
 595         bcs->trans_down = 0;
 596         bcs->trans_up = 0;
 597
 598         gig_dbg(DEBUG_INIT, "setting up bcs[%d]->at_state", channel);
 599         gigaset_at_init(&bcs->at_state, bcs, cs, -1);
 600
 601         bcs->rcvbytes = 0;
 602
 603 #ifdef CONFIG_GIGASET_DEBUG
 604         bcs->emptycount = 0;
 605 #endif
 606
 607         gig_dbg(DEBUG_INIT, "allocating bcs[%d]->skb", channel);
 608         bcs->fcs = PPP_INITFCS;
 609         bcs->inputstate = 0;
 610         if (cs->ignoreframes) {
 611                 bcs->inputstate |= INS_skip_frame;
 612                 bcs->skb = NULL;
 613         } else if ((bcs->skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)
 614                 skb_reserve(bcs->skb, HW_HDR_LEN);
 615         else {
 616                 dev_warn(cs->dev, "could not allocate skb\n");
 617                 bcs->inputstate |= INS_skip_frame;
 618         }
 619
 620         bcs->channel = channel;
 621         bcs->cs = cs;
 622
 623         bcs->chstate = 0;
 624         bcs->use_count = 1;
 625         bcs->busy = 0;
 626         bcs->ignore = cs->ignoreframes;
 627
 628         for (i = 0; i < AT_NUM; ++i)
 629                 bcs->commands[i] = NULL;
 630
 631         gig_dbg(DEBUG_INIT, "  setting up bcs[%d]->hw", channel);
 632         if (cs->ops->initbcshw(bcs))
 633                 return bcs;
 634
 635         gig_dbg(DEBUG_INIT, "  failed");
 636
 637         gig_dbg(DEBUG_INIT, "  freeing bcs[%d]->skb", channel);
 638         if (bcs->skb)
 639                 dev_kfree_skb(bcs->skb);
 640
 641         return NULL;
 642 }
 643
 644 /* gigaset_initcs
 645  * Allocate and initialize cardstate structure for Gigaset driver
 646  * Calls hardware dependent gigaset_initcshw() function
 647  * Calls B channel initialization function gigaset_initbcs() for each B channel
 648  * parameters:
 649  *      drv             hardware driver the device belongs to
 650  *      channels        number of B channels supported by device
 651  *      onechannel      !=0: B channel data and AT commands share one
 652  *                           communication channel
 653  *                      ==0: B channels have separate communication channels
 654  *      ignoreframes    number of frames to ignore after setting up B channel
 655  *      cidmode         !=0: start in CallID mode
 656  *      modulename      name of driver module (used for I4L registration)
 657  * return value:
 658  *      pointer to cardstate structure
 659  */
 660 struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
 661                                  int onechannel, int ignoreframes,
 662                                  int cidmode, const char *modulename)
 663 {
 664         struct cardstate *cs = NULL;
 665         unsigned long flags;
 666         int i;
 667
 668         gig_dbg(DEBUG_INIT, "allocating cs");
 669         cs = alloc_cs(drv);
 670         if (!cs)
 671                 goto error;
 672         gig_dbg(DEBUG_INIT, "allocating bcs[0..%d]", channels - 1);
 673         cs->bcs = kmalloc(channels * sizeof(struct bc_state), GFP_KERNEL);
 674         if (!cs->bcs)
 675                 goto error;
 676         gig_dbg(DEBUG_INIT, "allocating inbuf");
 677         cs->inbuf = kmalloc(sizeof(struct inbuf_t), GFP_KERNEL);
 678         if (!cs->inbuf)
 679                 goto error;
 680
 681         cs->cs_init = 0;
 682         cs->channels = channels;
 683         cs->onechannel = onechannel;
 684         cs->ignoreframes = ignoreframes;
 685         INIT_LIST_HEAD(&cs->temp_at_states);
 686         cs->running = 0;
 687         init_timer(&cs->timer); /* clear next & prev */
 688         spin_lock_init(&cs->ev_lock);
 689         cs->ev_tail = 0;
 690         cs->ev_head = 0;
 691         mutex_init(&cs->mutex);
 692         mutex_lock(&cs->mutex);
 693
 694         tasklet_init(&cs->event_tasklet, &gigaset_handle_event,
 695                      (unsigned long) cs);
 696         atomic_set(&cs->commands_pending, 0);
 697         cs->cur_at_seq = 0;
 698         cs->gotfwver = -1;
 699         cs->open_count = 0;
 700         cs->dev = NULL;
 701         cs->tty = NULL;
 702         cs->cidmode = cidmode != 0;
 703
 704         //if(onechannel) { //FIXME
 705                 cs->tabnocid = gigaset_tab_nocid_m10x;
 706                 cs->tabcid = gigaset_tab_cid_m10x;
 707         //} else {
 708         //      cs->tabnocid = gigaset_tab_nocid;
 709         //      cs->tabcid = gigaset_tab_cid;
 710         //}
 711
 712         init_waitqueue_head(&cs->waitqueue);
 713         cs->waiting = 0;
 714
 715         atomic_set(&cs->mode, M_UNKNOWN);
 716         atomic_set(&cs->mstate, MS_UNINITIALIZED);
 717
 718         for (i = 0; i < channels; ++i) {
 719                 gig_dbg(DEBUG_INIT, "setting up bcs[%d].read", i);
 720                 if (!gigaset_initbcs(cs->bcs + i, cs, i))
 721                         goto error;
 722         }
 723
 724         ++cs->cs_init;
 725
 726         gig_dbg(DEBUG_INIT, "setting up at_state");
 727         spin_lock_init(&cs->lock);
 728         gigaset_at_init(&cs->at_state, NULL, cs, 0);
 729         cs->dle = 0;
 730         cs->cbytes = 0;
 731
 732         gig_dbg(DEBUG_INIT, "setting up inbuf");
 733         if (onechannel) {                       //FIXME distinction necessary?
 734                 gigaset_inbuf_init(cs->inbuf, cs->bcs, cs, INS_command);
 735         } else
 736                 gigaset_inbuf_init(cs->inbuf, NULL,    cs, INS_command);
 737
 738         cs->connected = 0;
 739         cs->isdn_up = 0;
 740
 741         gig_dbg(DEBUG_INIT, "setting up cmdbuf");
 742         cs->cmdbuf = cs->lastcmdbuf = NULL;
 743         spin_lock_init(&cs->cmdlock);
 744         cs->curlen = 0;
 745         cs->cmdbytes = 0;
 746
 747         gig_dbg(DEBUG_INIT, "setting up iif");
 748         if (!gigaset_register_to_LL(cs, modulename)) {
 749                 err("register_isdn failed");
 750                 goto error;
 751         }
 752
 753         make_valid(cs, VALID_ID);
 754         ++cs->cs_init;
 755         gig_dbg(DEBUG_INIT, "setting up hw");
 756         if (!cs->ops->initcshw(cs))
 757                 goto error;
 758
 759         ++cs->cs_init;
 760
 761         gigaset_if_init(cs);
 762
 763         spin_lock_irqsave(&cs->lock, flags);
 764         cs->running = 1;
 765         spin_unlock_irqrestore(&cs->lock, flags);
 766         setup_timer(&cs->timer, timer_tick, (unsigned long) cs);
 767         cs->timer.expires = jiffies + msecs_to_jiffies(GIG_TICK);
 768         /* FIXME: can jiffies increase too much until the timer is added?
 769          * Same problem(?) with mod_timer() in timer_tick(). */
 770         add_timer(&cs->timer);
 771
 772         gig_dbg(DEBUG_INIT, "cs initialized");
 773         mutex_unlock(&cs->mutex);
 774         return cs;
 775
 776 error:  if (cs)
 777                 mutex_unlock(&cs->mutex);
 778         gig_dbg(DEBUG_INIT, "failed");
 779         gigaset_freecs(cs);
 780         return NULL;
 781 }
 782 EXPORT_SYMBOL_GPL(gigaset_initcs);
 783
 784 /* ReInitialize the b-channel structure on hangup */
 785 void gigaset_bcs_reinit(struct bc_state *bcs)
 786 {
 787         struct sk_buff *skb;
 788         struct cardstate *cs = bcs->cs;
 789         unsigned long flags;
 790
 791         while ((skb = skb_dequeue(&bcs->squeue)) != NULL)
 792                 dev_kfree_skb(skb);
 793
 794         spin_lock_irqsave(&cs->lock, flags);
 795         clear_at_state(&bcs->at_state);
 796         bcs->at_state.ConState = 0;
 797         bcs->at_state.timer_active = 0;
 798         bcs->at_state.timer_expires = 0;
 799         bcs->at_state.cid = -1;                 /* No CID defined */
 800         spin_unlock_irqrestore(&cs->lock, flags);
 801
 802         bcs->inputstate = 0;
 803
 804 #ifdef CONFIG_GIGASET_DEBUG
 805         bcs->emptycount = 0;
 806 #endif
 807
 808         bcs->fcs = PPP_INITFCS;
 809         bcs->chstate = 0;
 810
 811         bcs->ignore = cs->ignoreframes;
 812         if (bcs->ignore)
 813                 bcs->inputstate |= INS_skip_frame;
 814
 815
 816         cs->ops->reinitbcshw(bcs);
 817 }
 818
 819 static void cleanup_cs(struct cardstate *cs)
 820 {
 821         struct cmdbuf_t *cb, *tcb;
 822         int i;
 823         unsigned long flags;
 824
 825         spin_lock_irqsave(&cs->lock, flags);
 826
 827         atomic_set(&cs->mode, M_UNKNOWN);
 828         atomic_set(&cs->mstate, MS_UNINITIALIZED);
 829
 830         clear_at_state(&cs->at_state);
 831         dealloc_at_states(cs);
 832         free_strings(&cs->at_state);
 833         gigaset_at_init(&cs->at_state, NULL, cs, 0);
 834
 835         kfree(cs->inbuf->rcvbuf);
 836         cs->inbuf->rcvbuf = NULL;
 837         cs->inbuf->inputstate = INS_command;
 838         atomic_set(&cs->inbuf->head, 0);
 839         atomic_set(&cs->inbuf->tail, 0);
 840
 841         cb = cs->cmdbuf;
 842         while (cb) {
 843                 tcb = cb;
 844                 cb = cb->next;
 845                 kfree(tcb);
 846         }
 847         cs->cmdbuf = cs->lastcmdbuf = NULL;
 848         cs->curlen = 0;
 849         cs->cmdbytes = 0;
 850         cs->gotfwver = -1;
 851         cs->dle = 0;
 852         cs->cur_at_seq = 0;
 853         atomic_set(&cs->commands_pending, 0);
 854         cs->cbytes = 0;
 855
 856         spin_unlock_irqrestore(&cs->lock, flags);
 857
 858         for (i = 0; i < cs->channels; ++i) {
 859                 gigaset_freebcs(cs->bcs + i);
 860                 if (!gigaset_initbcs(cs->bcs + i, cs, i))
 861                         break;                  //FIXME error handling
 862         }
 863
 864         if (cs->waiting) {
 865                 cs->cmd_result = -ENODEV;
 866                 cs->waiting = 0;
 867                 wake_up_interruptible(&cs->waitqueue);
 868         }
 869 }
 870
 871
 872 int gigaset_start(struct cardstate *cs)
 873 {
 874         unsigned long flags;
 875
 876         if (mutex_lock_interruptible(&cs->mutex))
 877                 return 0;
 878
 879         spin_lock_irqsave(&cs->lock, flags);
 880         cs->connected = 1;
 881         spin_unlock_irqrestore(&cs->lock, flags);
 882
 883         if (atomic_read(&cs->mstate) != MS_LOCKED) {
 884                 cs->ops->set_modem_ctrl(cs, 0, TIOCM_DTR|TIOCM_RTS);
 885                 cs->ops->baud_rate(cs, B115200);
 886                 cs->ops->set_line_ctrl(cs, CS8);
 887                 cs->control_state = TIOCM_DTR|TIOCM_RTS;
 888         } else {
 889                 //FIXME use some saved values?
 890         }
 891
 892         cs->waiting = 1;
 893
 894         if (!gigaset_add_event(cs, &cs->at_state, EV_START, NULL, 0, NULL)) {
 895                 cs->waiting = 0;
 896                 //FIXME what should we do?
 897                 goto error;
 898         }
 899
 900         gig_dbg(DEBUG_CMD, "scheduling START");
 901         gigaset_schedule_event(cs);
 902
 903         wait_event(cs->waitqueue, !cs->waiting);
 904
 905         /* set up device sysfs */
 906         gigaset_init_dev_sysfs(cs);
 907
 908         mutex_unlock(&cs->mutex);
 909         return 1;
 910
 911 error:
 912         mutex_unlock(&cs->mutex);
 913         return 0;
 914 }
 915 EXPORT_SYMBOL_GPL(gigaset_start);
 916
 917 void gigaset_shutdown(struct cardstate *cs)
 918 {
 919         mutex_lock(&cs->mutex);
 920
 921         cs->waiting = 1;
 922
 923         if (!gigaset_add_event(cs, &cs->at_state, EV_SHUTDOWN, NULL, 0, NULL)) {
 924                 //FIXME what should we do?
 925                 goto exit;
 926         }
 927
 928         gig_dbg(DEBUG_CMD, "scheduling SHUTDOWN");
 929         gigaset_schedule_event(cs);
 930
 931         if (wait_event_interruptible(cs->waitqueue, !cs->waiting)) {
 932                 warn("%s: aborted", __func__);
 933                 //FIXME
 934         }
 935
 936         if (atomic_read(&cs->mstate) != MS_LOCKED) {
 937                 //FIXME?
 938                 //gigaset_baud_rate(cs, B115200);
 939                 //gigaset_set_line_ctrl(cs, CS8);
 940                 //gigaset_set_modem_ctrl(cs, TIOCM_DTR|TIOCM_RTS, 0);
 941                 //cs->control_state = 0;
 942         } else {
 943                 //FIXME use some saved values?
 944         }
 945
 946         cleanup_cs(cs);
 947
 948 exit:
 949         mutex_unlock(&cs->mutex);
 950 }
 951 EXPORT_SYMBOL_GPL(gigaset_shutdown);
 952
 953 void gigaset_stop(struct cardstate *cs)
 954 {
 955         mutex_lock(&cs->mutex);
 956
 957         cs->waiting = 1;
 958
 959         if (!gigaset_add_event(cs, &cs->at_state, EV_STOP, NULL, 0, NULL)) {
 960                 //FIXME what should we do?
 961                 goto exit;
 962         }
 963
 964         gig_dbg(DEBUG_CMD, "scheduling STOP");
 965         gigaset_schedule_event(cs);
 966
 967         if (wait_event_interruptible(cs->waitqueue, !cs->waiting)) {
 968                 warn("%s: aborted", __func__);
 969                 //FIXME
 970         }
 971
 972         /* clear device sysfs */
 973         gigaset_free_dev_sysfs(cs);
 974
 975         cleanup_cs(cs);
 976
 977 exit:
 978         mutex_unlock(&cs->mutex);
 979 }
 980 EXPORT_SYMBOL_GPL(gigaset_stop);
 981
 982 static LIST_HEAD(drivers);
 983 static spinlock_t driver_lock = SPIN_LOCK_UNLOCKED;
 984
 985 struct cardstate *gigaset_get_cs_by_id(int id)
 986 {
 987         unsigned long flags;
 988         static struct cardstate *ret = NULL;
 989         static struct cardstate *cs;
 990         struct gigaset_driver *drv;
 991         unsigned i;
 992
 993         spin_lock_irqsave(&driver_lock, flags);
 994         list_for_each_entry(drv, &drivers, list) {
 995                 spin_lock(&drv->lock);
 996                 for (i = 0; i < drv->minors; ++i) {
 997                         if (drv->flags[i] & VALID_ID) {
 998                                 cs = drv->cs + i;
 999                                 if (cs->myid == id)
1000                                         ret = cs;
1001                         }
1002                         if (ret)
1003                                 break;
1004                 }
1005                 spin_unlock(&drv->lock);
1006                 if (ret)
1007                         break;
1008         }
1009         spin_unlock_irqrestore(&driver_lock, flags);
1010         return ret;
1011 }
1012
1013 void gigaset_debugdrivers(void)
1014 {
1015         unsigned long flags;
1016         static struct cardstate *cs;
1017         struct gigaset_driver *drv;
1018         unsigned i;
1019
1020         spin_lock_irqsave(&driver_lock, flags);
1021         list_for_each_entry(drv, &drivers, list) {
1022                 gig_dbg(DEBUG_DRIVER, "driver %p", drv);
1023                 spin_lock(&drv->lock);
1024                 for (i = 0; i < drv->minors; ++i) {
1025                         gig_dbg(DEBUG_DRIVER, "  index %u", i);
1026                         gig_dbg(DEBUG_DRIVER, "    flags 0x%02x",
1027                                 drv->flags[i]);
1028                         cs = drv->cs + i;
1029                         gig_dbg(DEBUG_DRIVER, "    cardstate %p", cs);
1030                         gig_dbg(DEBUG_DRIVER, "    minor_index %u",
1031                                 cs->minor_index);
1032                         gig_dbg(DEBUG_DRIVER, "    driver %p", cs->driver);
1033                         gig_dbg(DEBUG_DRIVER, "    i4l id %d", cs->myid);
1034                 }
1035                 spin_unlock(&drv->lock);
1036         }
1037         spin_unlock_irqrestore(&driver_lock, flags);
1038 }
1039
1040 static struct cardstate *gigaset_get_cs_by_minor(unsigned minor)
1041 {
1042         unsigned long flags;
1043         static struct cardstate *ret = NULL;
1044         struct gigaset_driver *drv;
1045         unsigned index;
1046
1047         spin_lock_irqsave(&driver_lock, flags);
1048         list_for_each_entry(drv, &drivers, list) {
1049                 if (minor < drv->minor || minor >= drv->minor + drv->minors)
1050                         continue;
1051                 index = minor - drv->minor;
1052                 spin_lock(&drv->lock);
1053                 if (drv->flags[index] & VALID_MINOR)
1054                         ret = drv->cs + index;
1055                 spin_unlock(&drv->lock);
1056                 if (ret)
1057                         break;
1058         }
1059         spin_unlock_irqrestore(&driver_lock, flags);
1060         return ret;
1061 }
1062
1063 struct cardstate *gigaset_get_cs_by_tty(struct tty_struct *tty)
1064 {
1065         if (tty->index < 0 || tty->index >= tty->driver->num)
1066                 return NULL;
1067         return gigaset_get_cs_by_minor(tty->index + tty->driver->minor_start);
1068 }
1069
1070 void gigaset_freedriver(struct gigaset_driver *drv)
1071 {
1072         unsigned long flags;
1073
1074         spin_lock_irqsave(&driver_lock, flags);
1075         list_del(&drv->list);
1076         spin_unlock_irqrestore(&driver_lock, flags);
1077
1078         gigaset_if_freedriver(drv);
1079         module_put(drv->owner);
1080
1081         kfree(drv->cs);
1082         kfree(drv->flags);
1083         kfree(drv);
1084 }
1085 EXPORT_SYMBOL_GPL(gigaset_freedriver);
1086
1087 /* gigaset_initdriver
1088  * Allocate and initialize gigaset_driver structure. Initialize interface.
1089  * parameters:
1090  *      minor           First minor number
1091  *      minors          Number of minors this driver can handle
1092  *      procname        Name of the driver
1093  *      devname         Name of the device files (prefix without minor number)
1094  *      devfsname       Devfs name of the device files without %d
1095  * return value:
1096  *      Pointer to the gigaset_driver structure on success, NULL on failure.
1097  */
1098 struct gigaset_driver *gigaset_initdriver(unsigned minor, unsigned minors,
1099                                           const char *procname,
1100                                           const char *devname,
1101                                           const char *devfsname,
1102                                           const struct gigaset_ops *ops,
1103                                           struct module *owner)
1104 {
1105         struct gigaset_driver *drv;
1106         unsigned long flags;
1107         unsigned i;
1108
1109         drv = kmalloc(sizeof *drv, GFP_KERNEL);
1110         if (!drv)
1111                 return NULL;
1112
1113         if (!try_module_get(owner))
1114                 goto out1;
1115
1116         drv->cs = NULL;
1117         drv->have_tty = 0;
1118         drv->minor = minor;
1119         drv->minors = minors;
1120         spin_lock_init(&drv->lock);
1121         drv->blocked = 0;
1122         drv->ops = ops;
1123         drv->owner = owner;
1124         INIT_LIST_HEAD(&drv->list);
1125
1126         drv->cs = kmalloc(minors * sizeof *drv->cs, GFP_KERNEL);
1127         if (!drv->cs)
1128                 goto out2;
1129
1130         drv->flags = kmalloc(minors * sizeof *drv->flags, GFP_KERNEL);
1131         if (!drv->flags)
1132                 goto out3;
1133
1134         for (i = 0; i < minors; ++i) {
1135                 drv->flags[i] = 0;
1136                 drv->cs[i].driver = drv;
1137                 drv->cs[i].ops = drv->ops;
1138                 drv->cs[i].minor_index = i;
1139         }
1140
1141         gigaset_if_initdriver(drv, procname, devname, devfsname);
1142
1143         spin_lock_irqsave(&driver_lock, flags);
1144         list_add(&drv->list, &drivers);
1145         spin_unlock_irqrestore(&driver_lock, flags);
1146
1147         return drv;
1148
1149 out3:
1150         kfree(drv->cs);
1151 out2:
1152         module_put(owner);
1153 out1:
1154         kfree(drv);
1155         return NULL;
1156 }
1157 EXPORT_SYMBOL_GPL(gigaset_initdriver);
1158
1159 /* For drivers without fixed assignment device<->cardstate (usb) */
1160 struct cardstate *gigaset_getunassignedcs(struct gigaset_driver *drv)
1161 {
1162         unsigned long flags;
1163         struct cardstate *cs = NULL;
1164         unsigned i;
1165
1166         spin_lock_irqsave(&drv->lock, flags);
1167         if (drv->blocked)
1168                 goto exit;
1169         for (i = 0; i < drv->minors; ++i) {
1170                 if ((drv->flags[i] & VALID_MINOR) &&
1171                     !(drv->flags[i] & ASSIGNED)) {
1172                         drv->flags[i] |= ASSIGNED;
1173                         cs = drv->cs + i;
1174                         break;
1175                 }
1176         }
1177 exit:
1178         spin_unlock_irqrestore(&drv->lock, flags);
1179         return cs;
1180 }
1181 EXPORT_SYMBOL_GPL(gigaset_getunassignedcs);
1182
1183 void gigaset_unassign(struct cardstate *cs)
1184 {
1185         unsigned long flags;
1186         unsigned *minor_flags;
1187         struct gigaset_driver *drv;
1188
1189         if (!cs)
1190                 return;
1191         drv = cs->driver;
1192         spin_lock_irqsave(&drv->lock, flags);
1193         minor_flags = drv->flags + cs->minor_index;
1194         if (*minor_flags & VALID_MINOR)
1195                 *minor_flags &= ~ASSIGNED;
1196         spin_unlock_irqrestore(&drv->lock, flags);
1197 }
1198 EXPORT_SYMBOL_GPL(gigaset_unassign);
1199
1200 void gigaset_blockdriver(struct gigaset_driver *drv)
1201 {
1202         unsigned long flags;
1203         spin_lock_irqsave(&drv->lock, flags);
1204         drv->blocked = 1;
1205         spin_unlock_irqrestore(&drv->lock, flags);
1206 }
1207 EXPORT_SYMBOL_GPL(gigaset_blockdriver);
1208
1209 static int __init gigaset_init_module(void)
1210 {
1211         /* in accordance with the principle of least astonishment,
1212          * setting the 'debug' parameter to 1 activates a sensible
1213          * set of default debug levels
1214          */
1215         if (gigaset_debuglevel == 1)
1216                 gigaset_debuglevel = DEBUG_DEFAULT;
1217
1218         info(DRIVER_AUTHOR);
1219         info(DRIVER_DESC);
1220         return 0;
1221 }
1222
1223 static void __exit gigaset_exit_module(void)
1224 {
1225 }
1226
1227 module_init(gigaset_init_module);
1228 module_exit(gigaset_exit_module);
1229
1230 MODULE_AUTHOR(DRIVER_AUTHOR);
1231 MODULE_DESCRIPTION(DRIVER_DESC);
1232
1233 MODULE_LICENSE("GPL");