Merge branch 'upstream' into max-sect
[linux-2.6] / 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");