?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / isdn / pcbit / drv.c
blob5de861f4081605ec66d0c375291dda166c8bae80
1 /*
2 * PCBIT-D interface with isdn4linux
3 *
4 * Copyright (C) 1996 Universidade de Lisboa
5 *
6 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
7 *
8 * This software may be used and distributed according to the terms of
9 * the GNU General Public License, incorporated herein by reference.
10 */
11
12 /*
13 * Fixes:
14 *
15 * Nuno Grilo <l38486@alfa.ist.utl.pt>
16 * fixed msn_list NULL pointer dereference.
17 *
18 */
19
20 #include <linux/module.h>
21
22 #include <linux/sched.h>
23
24 #include <linux/kernel.h>
25
26 #include <linux/types.h>
27 #include <linux/slab.h>
28 #include <linux/mm.h>
29 #include <linux/interrupt.h>
30 #include <linux/string.h>
31 #include <linux/skbuff.h>
32
33 #include <linux/isdnif.h>
34 #include <asm/string.h>
35 #include <asm/io.h>
36 #include <linux/ioport.h>
37
38 #include "pcbit.h"
39 #include "edss1.h"
40 #include "layer2.h"
41 #include "capi.h"
42
43
44 extern ushort last_ref_num;
45
46 static int pcbit_ioctl(isdn_ctrl* ctl);
47
48 static char* pcbit_devname[MAX_PCBIT_CARDS] = {
49 "pcbit0",
50 "pcbit1",
51 "pcbit2",
52 "pcbit3"
53 };
54
55 /*
56 * prototypes
57 */
58
59 static int pcbit_command(isdn_ctrl* ctl);
60 static int pcbit_stat(u_char __user * buf, int len, int, int);
61 static int pcbit_xmit(int driver, int chan, int ack, struct sk_buff *skb);
62 static int pcbit_writecmd(const u_char __user *, int, int, int);
63
64 static int set_protocol_running(struct pcbit_dev * dev);
65
66 static void pcbit_clear_msn(struct pcbit_dev *dev);
67 static void pcbit_set_msn(struct pcbit_dev *dev, char *list);
68 static int pcbit_check_msn(struct pcbit_dev *dev, char *msn);
69
70
71 extern void pcbit_deliver(void * data);
72
73 int pcbit_init_dev(int board, int mem_base, int irq)
74 {
75 struct pcbit_dev *dev;
76 isdn_if *dev_if;
77
78 if ((dev=kmalloc(sizeof(struct pcbit_dev), GFP_KERNEL)) == NULL)
79 {
80 printk("pcbit_init: couldn't malloc pcbit_dev struct\n");
81 return -ENOMEM;
82 }
83
84 dev_pcbit[board] = dev;
85 memset(dev, 0, sizeof(struct pcbit_dev));
86 init_waitqueue_head(&dev->set_running_wq);
87 spin_lock_init(&dev->lock);
88
89 if (mem_base >= 0xA0000 && mem_base <= 0xFFFFF ) {
90 dev->ph_mem = mem_base;
91 if (!request_mem_region(dev->ph_mem, 4096, "PCBIT mem")) {
92 printk(KERN_WARNING
93 "PCBIT: memory region %lx-%lx already in use\n",
94 dev->ph_mem, dev->ph_mem + 4096);
95 kfree(dev);
96 dev_pcbit[board] = NULL;
97 return -EACCES;
98 }
99 dev->sh_mem = ioremap(dev->ph_mem, 4096);
100 }
101 else
102 {
103 printk("memory address invalid");
104 kfree(dev);
105 dev_pcbit[board] = NULL;
106 return -EACCES;
107 }
108
109 dev->b1 = kmalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
110 if (!dev->b1) {
111 printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
112 iounmap(dev->sh_mem);
113 release_mem_region(dev->ph_mem, 4096);
114 kfree(dev);
115 return -ENOMEM;
116 }
117
118 dev->b2 = kmalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
119 if (!dev->b2) {
120 printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
121 kfree(dev->b1);
122 iounmap(dev->sh_mem);
123 release_mem_region(dev->ph_mem, 4096);
124 kfree(dev);
125 return -ENOMEM;
126 }
127
128 memset(dev->b1, 0, sizeof(struct pcbit_chan));
129 memset(dev->b2, 0, sizeof(struct pcbit_chan));
130 dev->b2->id = 1;
131
132 INIT_WORK(&dev->qdelivery, pcbit_deliver, dev);
133
134 /*
135 * interrupts
136 */
137
138 if (request_irq(irq, &pcbit_irq_handler, 0, pcbit_devname[board], dev) != 0)
139 {
140 kfree(dev->b1);
141 kfree(dev->b2);
142 iounmap(dev->sh_mem);
143 release_mem_region(dev->ph_mem, 4096);
144 kfree(dev);
145 dev_pcbit[board] = NULL;
146 return -EIO;
147 }
148
149 dev->irq = irq;
150
151 /* next frame to be received */
152 dev->rcv_seq = 0;
153 dev->send_seq = 0;
154 dev->unack_seq = 0;
155
156 dev->hl_hdrlen = 16;
157
158 dev_if = kmalloc(sizeof(isdn_if), GFP_KERNEL);
159
160 if (!dev_if) {
161 free_irq(irq, dev);
162 kfree(dev->b1);
163 kfree(dev->b2);
164 iounmap(dev->sh_mem);
165 release_mem_region(dev->ph_mem, 4096);
166 kfree(dev);
167 dev_pcbit[board] = NULL;
168 return -EIO;
169 }
170
171 dev->dev_if = dev_if;
172
173 dev_if->owner = THIS_MODULE;
174
175 dev_if->channels = 2;
176
177 dev_if->features = (ISDN_FEATURE_P_EURO | ISDN_FEATURE_L3_TRANS |
178 ISDN_FEATURE_L2_HDLC | ISDN_FEATURE_L2_TRANS );
179
180 dev_if->writebuf_skb = pcbit_xmit;
181 dev_if->hl_hdrlen = 16;
182
183 dev_if->maxbufsize = MAXBUFSIZE;
184 dev_if->command = pcbit_command;
185
186 dev_if->writecmd = pcbit_writecmd;
187 dev_if->readstat = pcbit_stat;
188
189
190 strcpy(dev_if->id, pcbit_devname[board]);
191
192 if (!register_isdn(dev_if)) {
193 free_irq(irq, dev);
194 kfree(dev->b1);
195 kfree(dev->b2);
196 iounmap(dev->sh_mem);
197 release_mem_region(dev->ph_mem, 4096);
198 kfree(dev);
199 dev_pcbit[board] = NULL;
200 return -EIO;
201 }
202
203 dev->id = dev_if->channels;
204
205
206 dev->l2_state = L2_DOWN;
207 dev->free = 511;
208
209 /*
210 * set_protocol_running(dev);
211 */
212
213 return 0;
214 }
215
216 #ifdef MODULE
217 void pcbit_terminate(int board)
218 {
219 struct pcbit_dev * dev;
220
221 dev = dev_pcbit[board];
222
223 if (dev) {
224 /* unregister_isdn(dev->dev_if); */
225 free_irq(dev->irq, dev);
226 pcbit_clear_msn(dev);
227 kfree(dev->dev_if);
228 if (dev->b1->fsm_timer.function)
229 del_timer(&dev->b1->fsm_timer);
230 if (dev->b2->fsm_timer.function)
231 del_timer(&dev->b2->fsm_timer);
232 kfree(dev->b1);
233 kfree(dev->b2);
234 iounmap(dev->sh_mem);
235 release_mem_region(dev->ph_mem, 4096);
236 kfree(dev);
237 }
238 }
239 #endif
240
241 static int pcbit_command(isdn_ctrl* ctl)
242 {
243 struct pcbit_dev *dev;
244 struct pcbit_chan *chan;
245 struct callb_data info;
246
247 dev = finddev(ctl->driver);
248
249 if (!dev)
250 {
251 printk("pcbit_command: unknown device\n");
252 return -1;
253 }
254
255 chan = (ctl->arg & 0x0F) ? dev->b2 : dev->b1;
256
257
258 switch(ctl->command) {
259 case ISDN_CMD_IOCTL:
260 return pcbit_ioctl(ctl);
261 break;
262 case ISDN_CMD_DIAL:
263 info.type = EV_USR_SETUP_REQ;
264 info.data.setup.CalledPN = (char *) &ctl->parm.setup.phone;
265 pcbit_fsm_event(dev, chan, EV_USR_SETUP_REQ, &info);
266 break;
267 case ISDN_CMD_ACCEPTD:
268 pcbit_fsm_event(dev, chan, EV_USR_SETUP_RESP, NULL);
269 break;
270 case ISDN_CMD_ACCEPTB:
271 printk("ISDN_CMD_ACCEPTB - not really needed\n");
272 break;
273 case ISDN_CMD_HANGUP:
274 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
275 break;
276 case ISDN_CMD_SETL2:
277 chan->proto = (ctl->arg >> 8);
278 break;
279 case ISDN_CMD_CLREAZ:
280 pcbit_clear_msn(dev);
281 break;
282 case ISDN_CMD_SETEAZ:
283 pcbit_set_msn(dev, ctl->parm.num);
284 break;
285 case ISDN_CMD_SETL3:
286 if ((ctl->arg >> 8) != ISDN_PROTO_L3_TRANS)
287 printk(KERN_DEBUG "L3 protocol unknown\n");
288 break;
289 default:
290 printk(KERN_DEBUG "pcbit_command: unknown command\n");
291 break;
292 };
293
294 return 0;
295 }
296
297 /*
298 * Another Hack :-(
299 * on some conditions the board stops sending TDATA_CONFs
300 * let's see if we can turn around the problem
301 */
302
303 #ifdef BLOCK_TIMER
304 static void pcbit_block_timer(unsigned long data)
305 {
306 struct pcbit_chan *chan;
307 struct pcbit_dev * dev;
308 isdn_ctrl ictl;
309
310 chan = (struct pcbit_chan *) data;
311
312 dev = chan2dev(chan);
313
314 if (dev == NULL) {
315 printk(KERN_DEBUG "pcbit: chan2dev failed\n");
316 return;
317 }
318
319 del_timer(&chan->block_timer);
320 chan->block_timer.function = NULL;
321
322 #ifdef DEBUG
323 printk(KERN_DEBUG "pcbit_block_timer\n");
324 #endif
325 chan->queued = 0;
326 ictl.driver = dev->id;
327 ictl.command = ISDN_STAT_BSENT;
328 ictl.arg = chan->id;
329 dev->dev_if->statcallb(&ictl);
330 }
331 #endif
332
333 static int pcbit_xmit(int driver, int chnum, int ack, struct sk_buff *skb)
334 {
335 ushort hdrlen;
336 int refnum, len;
337 struct pcbit_chan * chan;
338 struct pcbit_dev *dev;
339
340 dev = finddev(driver);
341 if (dev == NULL)
342 {
343 printk("finddev returned NULL");
344 return -1;
345 }
346
347 chan = chnum ? dev->b2 : dev->b1;
348
349
350 if (chan->fsm_state != ST_ACTIVE)
351 return -1;
352
353 if (chan->queued >= MAX_QUEUED )
354 {
355 #ifdef DEBUG_QUEUE
356 printk(KERN_DEBUG
357 "pcbit: %d packets already in queue - write fails\n",
358 chan->queued);
359 #endif
360 /*
361 * packet stays on the head of the device queue
362 * since dev_start_xmit will fail
363 * see net/core/dev.c
364 */
365 #ifdef BLOCK_TIMER
366 if (chan->block_timer.function == NULL) {
367 init_timer(&chan->block_timer);
368 chan->block_timer.function = &pcbit_block_timer;
369 chan->block_timer.data = (long) chan;
370 chan->block_timer.expires = jiffies + 1 * HZ;
371 add_timer(&chan->block_timer);
372 }
373 #endif
374 return 0;
375 }
376
377
378 chan->queued++;
379
380 len = skb->len;
381
382 hdrlen = capi_tdata_req(chan, skb);
383
384 refnum = last_ref_num++ & 0x7fffU;
385 chan->s_refnum = refnum;
386
387 pcbit_l2_write(dev, MSG_TDATA_REQ, refnum, skb, hdrlen);
388
389 return len;
390 }
391
392 static int pcbit_writecmd(const u_char __user *buf, int len, int driver, int channel)
393 {
394 struct pcbit_dev * dev;
395 int i, j;
396 const u_char * loadbuf;
397 u_char * ptr = NULL;
398 u_char *cbuf;
399
400 int errstat;
401
402 dev = finddev(driver);
403
404 if (!dev)
405 {
406 printk("pcbit_writecmd: couldn't find device");
407 return -ENODEV;
408 }
409
410 switch(dev->l2_state) {
411 case L2_LWMODE:
412 /* check (size <= rdp_size); write buf into board */
413 if (len < 0 || len > BANK4 + 1 || len > 1024)
414 {
415 printk("pcbit_writecmd: invalid length %d\n", len);
416 return -EINVAL;
417 }
418
419 cbuf = kmalloc(len, GFP_KERNEL);
420 if (!cbuf)
421 return -ENOMEM;
422
423 if (copy_from_user(cbuf, buf, len)) {
424 kfree(cbuf);
425 return -EFAULT;
426 }
427 memcpy_toio(dev->sh_mem, cbuf, len);
428 kfree(cbuf);
429 return len;
430 case L2_FWMODE:
431 /* this is the hard part */
432 /* dumb board */
433 /* get it into kernel space */
434 if ((ptr = kmalloc(len, GFP_KERNEL))==NULL)
435 return -ENOMEM;
436 if (copy_from_user(ptr, buf, len)) {
437 kfree(ptr);
438 return -EFAULT;
439 }
440 loadbuf = ptr;
441
442 errstat = 0;
443
444 for (i=0; i < len; i++)
445 {
446 for(j=0; j < LOAD_RETRY; j++)
447 if (!(readb(dev->sh_mem + dev->loadptr)))
448 break;
449
450 if (j == LOAD_RETRY)
451 {
452 errstat = -ETIME;
453 printk("TIMEOUT i=%d\n", i);
454 break;
455 }
456 writeb(loadbuf[i], dev->sh_mem + dev->loadptr + 1);
457 writeb(0x01, dev->sh_mem + dev->loadptr);
458
459 dev->loadptr += 2;
460 if (dev->loadptr > LOAD_ZONE_END)
461 dev->loadptr = LOAD_ZONE_START;
462 }
463 kfree(ptr);
464
465 return errstat ? errstat : len;
466 default:
467 return -EBUSY;
468 }
469 }
470
471 /*
472 * demultiplexing of messages
473 *
474 */
475
476 void pcbit_l3_receive(struct pcbit_dev * dev, ulong msg,
477 struct sk_buff * skb,
478 ushort hdr_len, ushort refnum)
479 {
480 struct pcbit_chan *chan;
481 struct sk_buff *skb2;
482 unsigned short len;
483 struct callb_data cbdata;
484 int complete, err;
485 isdn_ctrl ictl;
486
487 switch(msg) {
488
489 case MSG_TDATA_IND:
490 if (!(chan = capi_channel(dev, skb))) {
491 printk(KERN_WARNING
492 "CAPI header: unknown channel id\n");
493 break;
494 }
495 chan->r_refnum = skb->data[7];
496 skb_pull(skb, 8);
497
498 dev->dev_if->rcvcallb_skb(dev->id, chan->id, skb);
499
500 if (capi_tdata_resp(chan, &skb2) > 0)
501 pcbit_l2_write(dev, MSG_TDATA_RESP, refnum,
502 skb2, skb2->len);
503 return;
504 break;
505 case MSG_TDATA_CONF:
506 if (!(chan = capi_channel(dev, skb))) {
507 printk(KERN_WARNING
508 "CAPI header: unknown channel id\n");
509 break;
510 }
511
512 #ifdef DEBUG
513 if ( (*((ushort *) (skb->data + 2) )) != 0) {
514 printk(KERN_DEBUG "TDATA_CONF error\n");
515 }
516 #endif
517 #ifdef BLOCK_TIMER
518 if (chan->queued == MAX_QUEUED) {
519 del_timer(&chan->block_timer);
520 chan->block_timer.function = NULL;
521 }
522
523 #endif
524 chan->queued--;
525
526 ictl.driver = dev->id;
527 ictl.command = ISDN_STAT_BSENT;
528 ictl.arg = chan->id;
529 dev->dev_if->statcallb(&ictl);
530 break;
531
532 case MSG_CONN_IND:
533 /*
534 * channel: 1st not used will do
535 * if both are used we're in trouble
536 */
537
538 if (!dev->b1->fsm_state)
539 chan = dev->b1;
540 else if (!dev->b2->fsm_state)
541 chan = dev->b2;
542 else {
543 printk(KERN_INFO
544 "Incoming connection: no channels available");
545
546 if ((len = capi_disc_req(*(ushort*)(skb->data), &skb2, CAUSE_NOCHAN)) > 0)
547 pcbit_l2_write(dev, MSG_DISC_REQ, refnum, skb2, len);
548 break;
549 }
550
551 cbdata.data.setup.CalledPN = NULL;
552 cbdata.data.setup.CallingPN = NULL;
553
554 capi_decode_conn_ind(chan, skb, &cbdata);
555 cbdata.type = EV_NET_SETUP;
556
557 pcbit_fsm_event(dev, chan, EV_NET_SETUP, NULL);
558
559 if (pcbit_check_msn(dev, cbdata.data.setup.CallingPN))
560 pcbit_fsm_event(dev, chan, EV_USR_PROCED_REQ, &cbdata);
561 else
562 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
563
564 if (cbdata.data.setup.CalledPN)
565 kfree(cbdata.data.setup.CalledPN);
566 if (cbdata.data.setup.CallingPN)
567 kfree(cbdata.data.setup.CallingPN);
568 break;
569
570 case MSG_CONN_CONF:
571 /*
572 * We should be able to find the channel by the message
573 * reference number. The current version of the firmware
574 * doesn't sent the ref number correctly.
575 */
576 #ifdef DEBUG
577 printk(KERN_DEBUG "refnum=%04x b1=%04x b2=%04x\n", refnum,
578 dev->b1->s_refnum,
579 dev->b2->s_refnum);
580 #endif
581 /* We just try to find a channel in the right state */
582
583 if (dev->b1->fsm_state == ST_CALL_INIT)
584 chan = dev->b1;
585 else {
586 if (dev->b2->s_refnum == ST_CALL_INIT)
587 chan = dev->b2;
588 else {
589 chan = NULL;
590 printk(KERN_WARNING "Connection Confirm - no channel in Call Init state\n");
591 break;
592 }
593 }
594 if (capi_decode_conn_conf(chan, skb, &complete)) {
595 printk(KERN_DEBUG "conn_conf indicates error\n");
596 pcbit_fsm_event(dev, chan, EV_ERROR, NULL);
597 }
598 else
599 if (complete)
600 pcbit_fsm_event(dev, chan, EV_NET_CALL_PROC, NULL);
601 else
602 pcbit_fsm_event(dev, chan, EV_NET_SETUP_ACK, NULL);
603 break;
604 case MSG_CONN_ACTV_IND:
605
606 if (!(chan = capi_channel(dev, skb))) {
607 printk(KERN_WARNING
608 "CAPI header: unknown channel id\n");
609 break;
610 }
611
612 if (capi_decode_conn_actv_ind(chan, skb)) {
613 printk("error in capi_decode_conn_actv_ind\n");
614 /* pcbit_fsm_event(dev, chan, EV_ERROR, NULL); */
615 break;
616 }
617 chan->r_refnum = refnum;
618 pcbit_fsm_event(dev, chan, EV_NET_CONN, NULL);
619 break;
620 case MSG_CONN_ACTV_CONF:
621
622 if (!(chan = capi_channel(dev, skb))) {
623 printk(KERN_WARNING
624 "CAPI header: unknown channel id\n");
625 break;
626 }
627
628 if (capi_decode_conn_actv_conf(chan, skb) == 0)
629 pcbit_fsm_event(dev, chan, EV_NET_CONN_ACK, NULL);
630
631 else
632 printk(KERN_DEBUG "decode_conn_actv_conf failed\n");
633 break;
634
635 case MSG_SELP_CONF:
636
637 if (!(chan = capi_channel(dev, skb))) {
638 printk(KERN_WARNING
639 "CAPI header: unknown channel id\n");
640 break;
641 }
642
643 if (!(err = capi_decode_sel_proto_conf(chan, skb)))
644 pcbit_fsm_event(dev, chan, EV_NET_SELP_RESP, NULL);
645 else {
646 /* Error */
647 printk("error %d - capi_decode_sel_proto_conf\n", err);
648 }
649 break;
650 case MSG_ACT_TRANSP_CONF:
651 if (!(chan = capi_channel(dev, skb))) {
652 printk(KERN_WARNING
653 "CAPI header: unknown channel id\n");
654 break;
655 }
656
657 if (!capi_decode_actv_trans_conf(chan, skb))
658 pcbit_fsm_event(dev, chan, EV_NET_ACTV_RESP, NULL);
659 break;
660
661 case MSG_DISC_IND:
662
663 if (!(chan = capi_channel(dev, skb))) {
664 printk(KERN_WARNING
665 "CAPI header: unknown channel id\n");
666 break;
667 }
668
669 if (!capi_decode_disc_ind(chan, skb))
670 pcbit_fsm_event(dev, chan, EV_NET_DISC, NULL);
671 else
672 printk(KERN_WARNING "capi_decode_disc_ind - error\n");
673 break;
674 case MSG_DISC_CONF:
675 if (!(chan = capi_channel(dev, skb))) {
676 printk(KERN_WARNING
677 "CAPI header: unknown channel id\n");
678 break;
679 }
680
681 if (!capi_decode_disc_ind(chan, skb))
682 pcbit_fsm_event(dev, chan, EV_NET_RELEASE, NULL);
683 else
684 printk(KERN_WARNING "capi_decode_disc_conf - error\n");
685 break;
686 case MSG_INFO_IND:
687 #ifdef DEBUG
688 printk(KERN_DEBUG "received Info Indication - discarded\n");
689 #endif
690 break;
691 #ifdef DEBUG
692 case MSG_DEBUG_188:
693 capi_decode_debug_188(skb->data, skb->len);
694 break;
695
696 default:
697 printk(KERN_DEBUG "pcbit_l3_receive: unknown message %08lx\n",
698 msg);
699 break;
700 #endif
701 }
702
703 kfree_skb(skb);
704
705 }
706
707 /*
708 * Single statbuf
709 * should be a statbuf per device
710 */
711
712 static char statbuf[STATBUF_LEN];
713 static int stat_st = 0;
714 static int stat_end = 0;
715
716 static int pcbit_stat(u_char __user *buf, int len, int driver, int channel)
717 {
718 int stat_count;
719 stat_count = stat_end - stat_st;
720
721 if (stat_count < 0)
722 stat_count = STATBUF_LEN - stat_st + stat_end;
723
724 /* FIXME: should we sleep and wait for more cookies ? */
725 if (len > stat_count)
726 len = stat_count;
727
728 if (stat_st < stat_end)
729 {
730 copy_to_user(buf, statbuf + stat_st, len);
731 stat_st += len;
732 }
733 else
734 {
735 if (len > STATBUF_LEN - stat_st)
736 {
737 copy_to_user(buf, statbuf + stat_st,
738 STATBUF_LEN - stat_st);
739 copy_to_user(buf, statbuf,
740 len - (STATBUF_LEN - stat_st));
741
742 stat_st = len - (STATBUF_LEN - stat_st);
743 }
744 else
745 {
746 copy_to_user(buf, statbuf + stat_st, len);
747
748 stat_st += len;
749
750 if (stat_st == STATBUF_LEN)
751 stat_st = 0;
752 }
753 }
754
755 if (stat_st == stat_end)
756 stat_st = stat_end = 0;
757
758 return len;
759 }
760
761 static void pcbit_logstat(struct pcbit_dev *dev, char *str)
762 {
763 int i;
764 isdn_ctrl ictl;
765
766 for (i=stat_end; i<strlen(str); i++)
767 {
768 statbuf[i]=str[i];
769 stat_end = (stat_end + 1) % STATBUF_LEN;
770 if (stat_end == stat_st)
771 stat_st = (stat_st + 1) % STATBUF_LEN;
772 }
773
774 ictl.command=ISDN_STAT_STAVAIL;
775 ictl.driver=dev->id;
776 ictl.arg=strlen(str);
777 dev->dev_if->statcallb(&ictl);
778 }
779
780 extern char * isdn_state_table[];
781 extern char * strisdnevent(unsigned short);
782
783
784 void pcbit_state_change(struct pcbit_dev * dev, struct pcbit_chan * chan,
785 unsigned short i, unsigned short ev, unsigned short f)
786 {
787 char buf[256];
788
789 sprintf(buf, "change on device: %d channel:%d\n%s -> %s -> %s\n",
790 dev->id, chan->id,
791 isdn_state_table[i], strisdnevent(ev), isdn_state_table[f]
792 );
793
794 #ifdef DEBUG
795 printk("%s", buf);
796 #endif
797
798 pcbit_logstat(dev, buf);
799 }
800
801 static void set_running_timeout(unsigned long ptr)
802 {
803 struct pcbit_dev * dev;
804
805 #ifdef DEBUG
806 printk(KERN_DEBUG "set_running_timeout\n");
807 #endif
808 dev = (struct pcbit_dev *) ptr;
809
810 wake_up_interruptible(&dev->set_running_wq);
811 }
812
813 static int set_protocol_running(struct pcbit_dev * dev)
814 {
815 isdn_ctrl ctl;
816
817 init_timer(&dev->set_running_timer);
818
819 dev->set_running_timer.function = &set_running_timeout;
820 dev->set_running_timer.data = (ulong) dev;
821 dev->set_running_timer.expires = jiffies + SET_RUN_TIMEOUT;
822
823 /* kick it */
824
825 dev->l2_state = L2_STARTING;
826
827 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
828 dev->sh_mem + BANK4);
829
830 add_timer(&dev->set_running_timer);
831
832 interruptible_sleep_on(&dev->set_running_wq);
833
834 del_timer(&dev->set_running_timer);
835
836 if (dev->l2_state == L2_RUNNING)
837 {
838 printk(KERN_DEBUG "pcbit: running\n");
839
840 dev->unack_seq = dev->send_seq;
841
842 dev->writeptr = dev->sh_mem;
843 dev->readptr = dev->sh_mem + BANK2;
844
845 /* tell the good news to the upper layer */
846 ctl.driver = dev->id;
847 ctl.command = ISDN_STAT_RUN;
848
849 dev->dev_if->statcallb(&ctl);
850 }
851 else
852 {
853 printk(KERN_DEBUG "pcbit: initialization failed\n");
854 printk(KERN_DEBUG "pcbit: firmware not loaded\n");
855
856 dev->l2_state = L2_DOWN;
857
858 #ifdef DEBUG
859 printk(KERN_DEBUG "Bank3 = %02x\n",
860 readb(dev->sh_mem + BANK3));
861 #endif
862 writeb(0x40, dev->sh_mem + BANK4);
863
864 /* warn the upper layer */
865 ctl.driver = dev->id;
866 ctl.command = ISDN_STAT_STOP;
867
868 dev->dev_if->statcallb(&ctl);
869
870 return -EL2HLT; /* Level 2 halted */
871 }
872
873 return 0;
874 }
875
876 static int pcbit_ioctl(isdn_ctrl* ctl)
877 {
878 struct pcbit_dev * dev;
879 struct pcbit_ioctl *cmd;
880
881 dev = finddev(ctl->driver);
882
883 if (!dev)
884 {
885 printk(KERN_DEBUG "pcbit_ioctl: unknown device\n");
886 return -ENODEV;
887 }
888
889 cmd = (struct pcbit_ioctl *) ctl->parm.num;
890
891 switch(ctl->arg) {
892 case PCBIT_IOCTL_GETSTAT:
893 cmd->info.l2_status = dev->l2_state;
894 break;
895
896 case PCBIT_IOCTL_STRLOAD:
897 if (dev->l2_state == L2_RUNNING)
898 return -EBUSY;
899
900 dev->unack_seq = dev->send_seq = dev->rcv_seq = 0;
901
902 dev->writeptr = dev->sh_mem;
903 dev->readptr = dev->sh_mem + BANK2;
904
905 dev->l2_state = L2_LOADING;
906 break;
907
908 case PCBIT_IOCTL_LWMODE:
909 if (dev->l2_state != L2_LOADING)
910 return -EINVAL;
911
912 dev->l2_state = L2_LWMODE;
913 break;
914
915 case PCBIT_IOCTL_FWMODE:
916 if (dev->l2_state == L2_RUNNING)
917 return -EBUSY;
918 dev->loadptr = LOAD_ZONE_START;
919 dev->l2_state = L2_FWMODE;
920
921 break;
922 case PCBIT_IOCTL_ENDLOAD:
923 if (dev->l2_state == L2_RUNNING)
924 return -EBUSY;
925 dev->l2_state = L2_DOWN;
926 break;
927
928 case PCBIT_IOCTL_SETBYTE:
929 if (dev->l2_state == L2_RUNNING)
930 return -EBUSY;
931
932 /* check addr */
933 if (cmd->info.rdp_byte.addr > BANK4)
934 return -EFAULT;
935
936 writeb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr);
937 break;
938 case PCBIT_IOCTL_GETBYTE:
939 if (dev->l2_state == L2_RUNNING)
940 return -EBUSY;
941
942 /* check addr */
943
944 if (cmd->info.rdp_byte.addr > BANK4)
945 {
946 printk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr);
947 return -EFAULT;
948 }
949
950 cmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr);
951 break;
952 case PCBIT_IOCTL_RUNNING:
953 if (dev->l2_state == L2_RUNNING)
954 return -EBUSY;
955 return set_protocol_running(dev);
956 break;
957 case PCBIT_IOCTL_WATCH188:
958 if (dev->l2_state != L2_LOADING)
959 return -EINVAL;
960 pcbit_l2_write(dev, MSG_WATCH188, 0x0001, NULL, 0);
961 break;
962 case PCBIT_IOCTL_PING188:
963 if (dev->l2_state != L2_LOADING)
964 return -EINVAL;
965 pcbit_l2_write(dev, MSG_PING188_REQ, 0x0001, NULL, 0);
966 break;
967 case PCBIT_IOCTL_APION:
968 if (dev->l2_state != L2_LOADING)
969 return -EINVAL;
970 pcbit_l2_write(dev, MSG_API_ON, 0x0001, NULL, 0);
971 break;
972 case PCBIT_IOCTL_STOP:
973 dev->l2_state = L2_DOWN;
974 writeb(0x40, dev->sh_mem + BANK4);
975 dev->rcv_seq = 0;
976 dev->send_seq = 0;
977 dev->unack_seq = 0;
978 break;
979 default:
980 printk("error: unknown ioctl\n");
981 break;
982 };
983 return 0;
984 }
985
986 /*
987 * MSN list handling
988 *
989 * if null reject all calls
990 * if first entry has null MSN accept all calls
991 */
992
993 static void pcbit_clear_msn(struct pcbit_dev *dev)
994 {
995 struct msn_entry *ptr, *back;
996
997 for (ptr=dev->msn_list; ptr; )
998 {
999 back = ptr->next;
1000 kfree(ptr);
1001 ptr = back;
1002 }
1003
1004 dev->msn_list = NULL;
1005 }
1006
1007 static void pcbit_set_msn(struct pcbit_dev *dev, char *list)
1008 {
1009 struct msn_entry *ptr;
1010 struct msn_entry *back = NULL;
1011 char *cp, *sp;
1012 int len;
1013
1014 if (strlen(list) == 0) {
1015 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1016 if (!ptr) {
1017 printk(KERN_WARNING "kmalloc failed\n");
1018 return;
1019 }
1020
1021 ptr->msn = NULL;
1022
1023 ptr->next = dev->msn_list;
1024 dev->msn_list = ptr;
1025
1026 return;
1027 }
1028
1029 if (dev->msn_list)
1030 for (back=dev->msn_list; back->next; back=back->next);
1031
1032 sp = list;
1033
1034 do {
1035 cp=strchr(sp, ',');
1036 if (cp)
1037 len = cp - sp;
1038 else
1039 len = strlen(sp);
1040
1041 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1042
1043 if (!ptr) {
1044 printk(KERN_WARNING "kmalloc failed\n");
1045 return;
1046 }
1047 ptr->next = NULL;
1048
1049 ptr->msn = kmalloc(len, GFP_ATOMIC);
1050 if (!ptr->msn) {
1051 printk(KERN_WARNING "kmalloc failed\n");
1052 kfree(ptr);
1053 return;
1054 }
1055
1056 memcpy(ptr->msn, sp, len - 1);
1057 ptr->msn[len] = 0;
1058
1059 #ifdef DEBUG
1060 printk(KERN_DEBUG "msn: %s\n", ptr->msn);
1061 #endif
1062 if (dev->msn_list == NULL)
1063 dev->msn_list = ptr;
1064 else
1065 back->next = ptr;
1066 back = ptr;
1067 sp += len;
1068 } while(cp);
1069 }
1070
1071 /*
1072 * check if we do signal or reject an incoming call
1073 */
1074 static int pcbit_check_msn(struct pcbit_dev *dev, char *msn)
1075 {
1076 struct msn_entry *ptr;
1077
1078 for (ptr=dev->msn_list; ptr; ptr=ptr->next) {
1079
1080 if (ptr->msn == NULL)
1081 return 1;
1082
1083 if (strcmp(ptr->msn, msn) == 0)
1084 return 1;
1085 }
1086
1087 return 0;
1088 }
Verdex Pro support