?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[CONNECTOR]: Initialize subsystem earlier.
[linux-2.6/verdex.git] / drivers / isdn / gigaset / common.c
blobe55767b2ccd3cc8d3f8fab741aec3e37a900b8bf
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");
Verdex Pro support