This source file includes following definitions.
- pcbit_init_dev
- pcbit_terminate
- pcbit_command
- pcbit_block_timer
- pcbit_xmit
- pcbit_writecmd
- pcbit_l3_receive
- pcbit_stat
- pcbit_logstat
- pcbit_state_change
- set_running_timeout
- set_protocol_running
- pcbit_ioctl
- pcbit_clear_msn
- pcbit_set_msn
- pcbit_check_msn
1
2
3
4
5
6
7
8
9
10
11
12
13
14 #define __NO_VERSION__
15
16 #include <linux/module.h>
17
18 #include <linux/sched.h>
19
20 #include <linux/kernel.h>
21
22 #include <linux/types.h>
23 #include <linux/malloc.h>
24 #include <linux/mm.h>
25 #include <linux/interrupt.h>
26 #include <linux/string.h>
27 #include <linux/skbuff.h>
28
29 #include <linux/isdnif.h>
30 #include <asm/string.h>
31 #include <asm/io.h>
32
33 #include "pcbit.h"
34 #include "edss1.h"
35 #include "layer2.h"
36 #include "capi.h"
37
38
39 extern ushort last_ref_num;
40
41 static int pcbit_ioctl(isdn_ctrl* ctl);
42
43 static char* pcbit_devname[MAX_PCBIT_CARDS] = {
44 "pcbit0",
45 "pcbit1",
46 "pcbit2",
47 "pcbit3"
48 };
49
50
51
52
53
54 int pcbit_command(isdn_ctrl* ctl);
55 int pcbit_stat(u_char* buf, int len, int user);
56 int pcbit_xmit(int driver, int chan, struct sk_buff *skb);
57 int pcbit_writecmd(const u_char*, int, int);
58
59 static int set_protocol_running(struct pcbit_dev * dev);
60
61 static void pcbit_clear_msn(struct pcbit_dev *dev);
62 static void pcbit_set_msn(struct pcbit_dev *dev, char *list);
63 static int pcbit_check_msn(struct pcbit_dev *dev, char *msn);
64
65
66 extern void pcbit_deliver(void * data);
67
68 int pcbit_init_dev(int board, int mem_base, int irq)
69 {
70 struct pcbit_dev *dev;
71 isdn_if *dev_if;
72
73 if ((dev=kmalloc(sizeof(struct pcbit_dev), GFP_KERNEL)) == NULL)
74 {
75 printk("pcbit_init: couldn't malloc pcbit_dev struct\n");
76 return -ENOMEM;
77 }
78
79 dev_pcbit[board] = dev;
80 memset(dev, 0, sizeof(struct pcbit_dev));
81
82 if (mem_base >= 0xA0000 && mem_base <= 0xFFFFF )
83 dev->sh_mem = (unsigned char*) mem_base;
84 else
85 {
86 printk("memory address invalid");
87 kfree(dev);
88 dev_pcbit[board] = NULL;
89 return -EACCES;
90 }
91
92 dev->b1 = kmalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
93 if (!dev->b1) {
94 printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
95 kfree(dev);
96 return -ENOMEM;
97 }
98
99 dev->b2 = kmalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
100 if (!dev->b2) {
101 printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
102 kfree(dev->b1);
103 kfree(dev);
104 return -ENOMEM;
105 }
106
107 memset(dev->b1, 0, sizeof(struct pcbit_chan));
108 memset(dev->b2, 0, sizeof(struct pcbit_chan));
109 dev->b2->id = 1;
110
111
112 dev->qdelivery.next = 0;
113 dev->qdelivery.sync = 0;
114 dev->qdelivery.routine = pcbit_deliver;
115 dev->qdelivery.data = dev;
116
117
118
119
120
121 if (request_irq(irq, &pcbit_irq_handler, 0, pcbit_devname[board], dev) != 0)
122 {
123 kfree(dev->b1);
124 kfree(dev->b2);
125 kfree(dev);
126 dev_pcbit[board] = NULL;
127 return -EIO;
128 }
129
130 dev->irq = irq;
131
132
133 dev->rcv_seq = 0;
134 dev->send_seq = 0;
135 dev->unack_seq = 0;
136
137 dev->hl_hdrlen = 10;
138
139 dev_if = kmalloc(sizeof(isdn_if), GFP_KERNEL);
140
141 if (!dev_if) {
142 free_irq(irq, dev);
143 kfree(dev->b1);
144 kfree(dev->b2);
145 kfree(dev);
146 dev_pcbit[board] = NULL;
147 return -EIO;
148 }
149
150 dev->dev_if = dev_if;
151
152 dev_if->channels = 2;
153
154
155 dev_if->features = ISDN_FEATURE_P_EURO | ISDN_FEATURE_L3_TRANS |
156 ISDN_FEATURE_L2_HDLC;
157
158 dev_if->writebuf_skb = pcbit_xmit;
159 dev_if->writebuf = NULL;
160 dev_if->hl_hdrlen = 10;
161
162 dev_if->maxbufsize = MAXBUFSIZE;
163 dev_if->command = pcbit_command;
164
165 dev_if->writecmd = pcbit_writecmd;
166 dev_if->readstat = pcbit_stat;
167
168
169 strcpy(dev_if->id, pcbit_devname[board]);
170
171 if (!register_isdn(dev_if)) {
172 free_irq(irq, dev);
173 kfree(dev->b1);
174 kfree(dev->b2);
175 kfree(dev);
176 dev_pcbit[board] = NULL;
177 return -EIO;
178 }
179
180 dev->id = dev_if->channels;
181
182
183 dev->l2_state = L2_DOWN;
184 dev->free = 511;
185
186
187
188
189
190 return 0;
191 }
192
193 #ifdef MODULE
194 void pcbit_terminate(int board)
195 {
196 struct pcbit_dev * dev;
197
198 dev = dev_pcbit[board];
199
200 if (dev) {
201
202 free_irq(dev->irq, dev);
203 pcbit_clear_msn(dev);
204 kfree(dev->dev_if);
205 if (dev->b1->fsm_timer.function)
206 del_timer(&dev->b1->fsm_timer);
207 if (dev->b2->fsm_timer.function)
208 del_timer(&dev->b2->fsm_timer);
209 kfree(dev->b1);
210 kfree(dev->b2);
211 kfree(dev);
212 }
213 }
214 #endif
215
216 int pcbit_command(isdn_ctrl* ctl)
217 {
218 struct pcbit_dev *dev;
219 struct pcbit_chan *chan;
220 struct callb_data info;
221 char *cp;
222
223 dev = finddev(ctl->driver);
224
225 if (!dev)
226 {
227 printk("pcbit_command: unknown device\n");
228 return -1;
229 }
230
231 chan = (ctl->arg & 0x0F) ? dev->b2 : dev->b1;
232
233
234 switch(ctl->command) {
235 case ISDN_CMD_IOCTL:
236 return pcbit_ioctl(ctl);
237 break;
238 case ISDN_CMD_DIAL:
239 info.type = EV_USR_SETUP_REQ;
240 info.data.setup.CalledPN = (char *) &ctl->num;
241 cp = strchr(info.data.setup.CalledPN, ',');
242 if (cp)
243 *cp = 0;
244 else {
245 printk(KERN_DEBUG "DIAL: error in CalledPN\n");
246 return -1;
247 }
248 pcbit_fsm_event(dev, chan, EV_USR_SETUP_REQ, &info);
249 break;
250 case ISDN_CMD_ACCEPTD:
251 pcbit_fsm_event(dev, chan, EV_USR_SETUP_RESP, NULL);
252 break;
253 case ISDN_CMD_ACCEPTB:
254 printk("ISDN_CMD_ACCEPTB - not really needed\n");
255 break;
256 case ISDN_CMD_HANGUP:
257 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
258 break;
259 case ISDN_CMD_SETL2:
260 chan->proto = (ctl->arg >> 8);
261 break;
262 case ISDN_CMD_GETL2:
263 return chan->proto;
264 break;
265 case ISDN_CMD_LOCK:
266 MOD_INC_USE_COUNT;
267 break;
268 case ISDN_CMD_UNLOCK:
269 MOD_DEC_USE_COUNT;
270 break;
271 case ISDN_CMD_CLREAZ:
272 pcbit_clear_msn(dev);
273 break;
274 case ISDN_CMD_SETEAZ:
275 pcbit_set_msn(dev, ctl->num);
276 break;
277 case ISDN_CMD_SETL3:
278 if ((ctl->arg >> 8) != ISDN_PROTO_L3_TRANS)
279 printk(KERN_DEBUG "L3 protocol unknown\n");
280 break;
281 case ISDN_CMD_GETL3:
282 return ISDN_PROTO_L3_TRANS;
283 break;
284 case ISDN_CMD_GETEAZ:
285 case ISDN_CMD_SETSIL:
286 case ISDN_CMD_GETSIL:
287 printk(KERN_DEBUG "pcbit_command: code %d not implemented yet\n", ctl->command);
288 break;
289 default:
290 printk(KERN_DEBUG "pcbit_command: unknown command\n");
291 break;
292 };
293
294 return 0;
295 }
296
297
298
299
300
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 int pcbit_xmit(int driver, int chnum, 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
362
363
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
393 int pcbit_writecmd(const u_char* buf, int len, int user)
394 {
395 struct pcbit_dev * dev;
396 int board, i, j;
397 const u_char * loadbuf;
398 u_char * ptr = NULL;
399
400 int errstat;
401
402
403 board = 0;
404
405 dev = dev_pcbit[board];
406
407 if (!dev)
408 {
409 printk("pcbit_writecmd: couldn't find device");
410 return -ENODEV;
411 }
412
413 switch(dev->l2_state) {
414 case L2_LWMODE:
415
416 if (len > BANK4 + 1)
417 {
418 printk("pcbit_writecmd: invalid length %d\n", len);
419 return -EFAULT;
420 }
421
422 if (user)
423 {
424 u_char cbuf[1024];
425
426 memcpy_fromfs(cbuf, buf, len);
427 for (i=0; i<len; i++)
428 writeb(cbuf[i], dev->sh_mem + i);
429 }
430 else
431 memcpy_toio(dev->sh_mem, buf, len);
432 return len;
433 break;
434 case L2_FWMODE:
435
436
437 if (len < 0)
438 return -EINVAL;
439
440 if (user) {
441
442 if ((ptr = kmalloc(len, GFP_KERNEL))==NULL)
443 return -ENOMEM;
444 memcpy_fromfs(ptr, buf, len);
445 loadbuf = ptr;
446 }
447 else
448 loadbuf = buf;
449
450 errstat = 0;
451
452 for (i=0; i < len; i++)
453 {
454 for(j=0; j < LOAD_RETRY; j++)
455 {
456 __volatile__ unsigned char * ptr;
457
458 ptr = dev->sh_mem + dev->loadptr;
459 if (*ptr == 0)
460 break;
461
462 }
463
464 if (j == LOAD_RETRY)
465 {
466 errstat = -ETIME;
467 printk("TIMEOUT i=%d\n", i);
468 break;
469 }
470 writeb(loadbuf[i], dev->sh_mem + dev->loadptr + 1);
471 writeb(0x01, dev->sh_mem + dev->loadptr);
472
473 dev->loadptr += 2;
474 if (dev->loadptr > LOAD_ZONE_END)
475 dev->loadptr = LOAD_ZONE_START;
476 }
477
478 if (user)
479 kfree(ptr);
480
481 return errstat ? errstat : len;
482
483 break;
484 default:
485 return -EBUSY;
486 }
487 return 0;
488 }
489
490
491
492
493
494
495 void pcbit_l3_receive(struct pcbit_dev * dev, ulong msg,
496 struct sk_buff * skb,
497 ushort hdr_len, ushort refnum)
498 {
499 struct pcbit_chan *chan;
500 struct sk_buff *skb2;
501 unsigned short len;
502 struct callb_data cbdata;
503 int complete, err;
504 isdn_ctrl ictl;
505 #ifdef DEBUG
506 struct msg_fmt * fmsg;
507 #endif
508
509 switch(msg) {
510
511 case MSG_TDATA_IND:
512 if (!(chan = capi_channel(dev, skb))) {
513 printk(KERN_WARNING
514 "CAPI header: unknown channel id\n");
515 break;
516 }
517 chan->r_refnum = skb->data[7];
518 skb_pull(skb, 8);
519
520 dev->dev_if->rcvcallb_skb(dev->id, chan->id, skb);
521
522 if (capi_tdata_resp(chan, &skb2) > 0)
523 pcbit_l2_write(dev, MSG_TDATA_RESP, refnum,
524 skb2, skb2->len);
525 return;
526 break;
527 case MSG_TDATA_CONF:
528 if (!(chan = capi_channel(dev, skb))) {
529 printk(KERN_WARNING
530 "CAPI header: unknown channel id\n");
531 break;
532 }
533
534 #ifdef DEBUG
535 if ( (*((ushort *) (skb->data + 2) )) != 0) {
536 printk(KERN_DEBUG "TDATA_CONF error\n");
537 }
538 #endif
539 #ifdef BLOCK_TIMER
540 if (chan->queued == MAX_QUEUED) {
541 del_timer(&chan->block_timer);
542 chan->block_timer.function = NULL;
543 }
544
545 #endif
546 chan->queued--;
547
548 ictl.driver = dev->id;
549 ictl.command = ISDN_STAT_BSENT;
550 ictl.arg = chan->id;
551 dev->dev_if->statcallb(&ictl);
552 break;
553
554 case MSG_CONN_IND:
555
556
557
558
559
560 if (!dev->b1->fsm_state)
561 chan = dev->b1;
562 else if (!dev->b2->fsm_state)
563 chan = dev->b2;
564 else {
565 printk(KERN_INFO
566 "Incoming connection: no channels available");
567
568 if ((len = capi_disc_req(*(ushort*)(skb->data), &skb2, CAUSE_NOCHAN)) > 0)
569 pcbit_l2_write(dev, MSG_DISC_REQ, refnum, skb2, len);
570 break;
571 }
572
573 cbdata.data.setup.CalledPN = NULL;
574 cbdata.data.setup.CallingPN = NULL;
575
576 capi_decode_conn_ind(chan, skb, &cbdata);
577 cbdata.type = EV_NET_SETUP;
578
579 pcbit_fsm_event(dev, chan, EV_NET_SETUP, NULL);
580
581 if (pcbit_check_msn(dev, cbdata.data.setup.CallingPN))
582 pcbit_fsm_event(dev, chan, EV_USR_PROCED_REQ, &cbdata);
583 else
584 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
585
586 if (cbdata.data.setup.CalledPN)
587 kfree(cbdata.data.setup.CalledPN);
588 if (cbdata.data.setup.CallingPN)
589 kfree(cbdata.data.setup.CallingPN);
590 break;
591
592 case MSG_CONN_CONF:
593
594
595
596
597
598 #ifdef DEBUG
599 printk(KERN_DEBUG "refnum=%04x b1=%04x b2=%04x\n", refnum,
600 dev->b1->s_refnum,
601 dev->b2->s_refnum);
602 #endif
603 #if 0
604 if (dev->b1->s_refnum == refnum)
605 chan = dev->b1;
606 else {
607
608 if (dev->b2->s_refnum == refnum)
609 chan = dev->b2;
610 else {
611 chan = NULL;
612 printk(KERN_WARNING "Connection Confirm - refnum doesn't match chan\n");
613 break;
614 }
615 }
616 #else
617
618
619 if (dev->b1->fsm_state == ST_CALL_INIT)
620 chan = dev->b1;
621 else {
622 if (dev->b2->s_refnum == ST_CALL_INIT)
623 chan = dev->b2;
624 else {
625 chan = NULL;
626 printk(KERN_WARNING "Connection Confirm - no channel in Call Init state\n");
627 break;
628 }
629 }
630 #endif
631 if (capi_decode_conn_conf(chan, skb, &complete)) {
632 printk(KERN_DEBUG "conn_conf indicates error\n");
633 pcbit_fsm_event(dev, chan, EV_ERROR, NULL);
634 }
635 else
636 if (complete)
637 pcbit_fsm_event(dev, chan, EV_NET_CALL_PROC, NULL);
638 else
639 pcbit_fsm_event(dev, chan, EV_NET_SETUP_ACK, NULL);
640 break;
641 case MSG_CONN_ACTV_IND:
642
643 if (!(chan = capi_channel(dev, skb))) {
644 printk(KERN_WARNING
645 "CAPI header: unknown channel id\n");
646 break;
647 }
648
649 if (capi_decode_conn_actv_ind(chan, skb)) {
650 printk("error in capi_decode_conn_actv_ind\n");
651
652 break;
653 }
654 chan->r_refnum = refnum;
655 pcbit_fsm_event(dev, chan, EV_NET_CONN, NULL);
656 break;
657 case MSG_CONN_ACTV_CONF:
658
659 if (!(chan = capi_channel(dev, skb))) {
660 printk(KERN_WARNING
661 "CAPI header: unknown channel id\n");
662 break;
663 }
664
665 if (capi_decode_conn_actv_conf(chan, skb) == 0)
666 pcbit_fsm_event(dev, chan, EV_NET_CONN_ACK, NULL);
667
668 else
669 printk(KERN_DEBUG "decode_conn_actv_conf failed\n");
670 break;
671
672 case MSG_SELP_CONF:
673
674 if (!(chan = capi_channel(dev, skb))) {
675 printk(KERN_WARNING
676 "CAPI header: unknown channel id\n");
677 break;
678 }
679
680 if (!(err = capi_decode_sel_proto_conf(chan, skb)))
681 pcbit_fsm_event(dev, chan, EV_NET_SELP_RESP, NULL);
682 else {
683
684 printk("error %d - capi_decode_sel_proto_conf\n", err);
685 }
686 break;
687 case MSG_ACT_TRANSP_CONF:
688 if (!(chan = capi_channel(dev, skb))) {
689 printk(KERN_WARNING
690 "CAPI header: unknown channel id\n");
691 break;
692 }
693
694 if (!capi_decode_actv_trans_conf(chan, skb))
695 pcbit_fsm_event(dev, chan, EV_NET_ACTV_RESP, NULL);
696 break;
697
698 case MSG_DISC_IND:
699
700 if (!(chan = capi_channel(dev, skb))) {
701 printk(KERN_WARNING
702 "CAPI header: unknown channel id\n");
703 break;
704 }
705
706 if (!capi_decode_disc_ind(chan, skb))
707 pcbit_fsm_event(dev, chan, EV_NET_DISC, NULL);
708 else
709 printk(KERN_WARNING "capi_decode_disc_ind - error\n");
710 break;
711 case MSG_DISC_CONF:
712 if (!(chan = capi_channel(dev, skb))) {
713 printk(KERN_WARNING
714 "CAPI header: unknown channel id\n");
715 break;
716 }
717
718 if (!capi_decode_disc_ind(chan, skb))
719 pcbit_fsm_event(dev, chan, EV_NET_RELEASE, NULL);
720 else
721 printk(KERN_WARNING "capi_decode_disc_conf - error\n");
722 break;
723 case MSG_INFO_IND:
724 #ifdef DEBUG
725 printk(KERN_DEBUG "received Info Indication - discarded\n");
726 #endif
727 break;
728 #ifdef DEBUG
729 case MSG_DEBUG_188:
730 capi_decode_debug_188(skb->data, skb->len);
731 break;
732
733 default:
734 printk(KERN_DEBUG "pcbit_l3_receive: unknown message %08lx\n",
735 msg);
736 fmsg = (struct msg_fmt *) &msg;
737 printk(KERN_DEBUG "cmd=%02x sub=%02x\n",
738 fmsg->cmd, fmsg->scmd);
739 break;
740 #endif
741 }
742
743 skb->free = 1;
744
745 kfree_skb(skb, FREE_READ);
746
747 }
748
749
750
751
752
753
754 static char statbuf[STATBUF_LEN];
755 static int stat_st = 0;
756 static int stat_end = 0;
757
758
759 #define memcpy_to_COND(flag, d, s, len) \
760 (flag ? memcpy_tofs(d, s, len) : memcpy(d, s, len))
761
762
763 int pcbit_stat(u_char* buf, int len, int user)
764 {
765 int stat_count;
766 stat_count = stat_end - stat_st;
767
768 if (stat_count < 0)
769 stat_count = STATBUF_LEN - stat_st + stat_end;
770
771
772 if (len > stat_count)
773 len = stat_count;
774
775 if (stat_st < stat_end)
776 {
777 memcpy_to_COND(user, buf, statbuf + stat_st, len);
778 stat_st += len;
779 }
780 else
781 {
782 if (len > STATBUF_LEN - stat_st)
783 {
784 memcpy_to_COND(user, buf, statbuf + stat_st,
785 STATBUF_LEN - stat_st);
786 memcpy_to_COND(user, buf, statbuf,
787 len - (STATBUF_LEN - stat_st));
788
789 stat_st = len - (STATBUF_LEN - stat_st);
790 }
791 else
792 {
793 memcpy_to_COND(user, buf, statbuf + stat_st,
794 len);
795
796 stat_st += len;
797
798 if (stat_st == STATBUF_LEN)
799 stat_st = 0;
800 }
801 }
802
803 if (stat_st == stat_end)
804 stat_st = stat_end = 0;
805
806 return len;
807 }
808
809 static void pcbit_logstat(struct pcbit_dev *dev, char *str)
810 {
811 int i;
812 isdn_ctrl ictl;
813
814 for (i=stat_end; i<strlen(str); i++)
815 {
816 statbuf[i]=str[i];
817 stat_end = (stat_end + 1) % STATBUF_LEN;
818 if (stat_end == stat_st)
819 stat_st = (stat_st + 1) % STATBUF_LEN;
820 }
821
822 ictl.command=ISDN_STAT_STAVAIL;
823 ictl.driver=dev->id;
824 ictl.arg=strlen(str);
825 dev->dev_if->statcallb(&ictl);
826 }
827
828 extern char * isdn_state_table[];
829 extern char * strisdnevent(unsigned short);
830
831
832 void pcbit_state_change(struct pcbit_dev * dev, struct pcbit_chan * chan,
833 unsigned short i, unsigned short ev, unsigned short f)
834 {
835 char buf[256];
836
837 sprintf(buf, "change on device: %d channel:%d\n%s -> %s -> %s\n",
838 dev->id, chan->id,
839 isdn_state_table[i], strisdnevent(ev), isdn_state_table[f]
840 );
841
842 #ifdef DEBUG
843 printk("%s", buf);
844 #endif
845
846 pcbit_logstat(dev, buf);
847 }
848
849 static void set_running_timeout(unsigned long ptr)
850 {
851 struct pcbit_dev * dev;
852
853 #ifdef DEBUG
854 printk(KERN_DEBUG "set_running_timeout\n");
855 #endif
856 dev = (struct pcbit_dev *) ptr;
857
858 wake_up_interruptible(&dev->set_running_wq);
859 }
860
861 static int set_protocol_running(struct pcbit_dev * dev)
862 {
863 isdn_ctrl ctl;
864
865 init_timer(&dev->set_running_timer);
866
867 dev->set_running_timer.function = &set_running_timeout;
868 dev->set_running_timer.data = (ulong) dev;
869 dev->set_running_timer.expires = jiffies + SET_RUN_TIMEOUT;
870
871
872
873 dev->l2_state = L2_STARTING;
874
875 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
876 dev->sh_mem + BANK4);
877
878 add_timer(&dev->set_running_timer);
879
880 interruptible_sleep_on(&dev->set_running_wq);
881
882 del_timer(&dev->set_running_timer);
883
884 if (dev->l2_state == L2_RUNNING)
885 {
886 printk(KERN_DEBUG "pcbit: running\n");
887
888 dev->unack_seq = dev->send_seq;
889
890 dev->writeptr = dev->sh_mem;
891 dev->readptr = dev->sh_mem + BANK2;
892
893
894 ctl.driver = dev->id;
895 ctl.command = ISDN_STAT_RUN;
896
897 dev->dev_if->statcallb(&ctl);
898 }
899 else
900 {
901 printk(KERN_DEBUG "pcbit: initialization failed\n");
902 printk(KERN_DEBUG "pcbit: firmware not loaded\n");
903
904 dev->l2_state = L2_DOWN;
905
906 #ifdef DEBUG
907 printk(KERN_DEBUG "Bank3 = %02x\n",
908 readb(dev->sh_mem + BANK3));
909 #endif
910 *(dev->sh_mem + BANK4) = 0x40U;
911
912
913 ctl.driver = dev->id;
914 ctl.command = ISDN_STAT_STOP;
915
916 dev->dev_if->statcallb(&ctl);
917
918 return -EL2HLT;
919 }
920
921 return 0;
922 }
923
924 static int pcbit_ioctl(isdn_ctrl* ctl)
925 {
926 struct pcbit_dev * dev;
927 struct pcbit_ioctl *cmd;
928
929 dev = finddev(ctl->driver);
930
931 if (!dev)
932 {
933 printk(KERN_DEBUG "pcbit_ioctl: unknown device\n");
934 return -ENODEV;
935 }
936
937 cmd = (struct pcbit_ioctl *) ctl->num;
938
939 switch(ctl->arg) {
940 case PCBIT_IOCTL_GETSTAT:
941 cmd->info.l2_status = dev->l2_state;
942 break;
943
944 case PCBIT_IOCTL_STRLOAD:
945 if (dev->l2_state == L2_RUNNING)
946 return -EBUSY;
947
948 dev->unack_seq = dev->send_seq = dev->rcv_seq = 0;
949
950 dev->writeptr = dev->sh_mem;
951 dev->readptr = dev->sh_mem + BANK2;
952
953 dev->l2_state = L2_LOADING;
954 break;
955
956 case PCBIT_IOCTL_LWMODE:
957 if (dev->l2_state != L2_LOADING)
958 return -EINVAL;
959
960 dev->l2_state = L2_LWMODE;
961 break;
962
963 case PCBIT_IOCTL_FWMODE:
964 if (dev->l2_state == L2_RUNNING)
965 return -EBUSY;
966 dev->loadptr = LOAD_ZONE_START;
967 dev->l2_state = L2_FWMODE;
968
969 break;
970 case PCBIT_IOCTL_ENDLOAD:
971 if (dev->l2_state == L2_RUNNING)
972 return -EBUSY;
973 dev->l2_state = L2_DOWN;
974 break;
975
976 case PCBIT_IOCTL_SETBYTE:
977 if (dev->l2_state == L2_RUNNING)
978 return -EBUSY;
979
980
981 if (cmd->info.rdp_byte.addr > BANK4)
982 return -EFAULT;
983
984 writeb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr);
985 break;
986 case PCBIT_IOCTL_GETBYTE:
987 if (dev->l2_state == L2_RUNNING)
988 return -EBUSY;
989
990
991
992 if (cmd->info.rdp_byte.addr > BANK4)
993 {
994 printk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr);
995 return -EFAULT;
996 }
997
998 cmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr);
999 break;
1000 case PCBIT_IOCTL_RUNNING:
1001 if (dev->l2_state == L2_RUNNING)
1002 return -EBUSY;
1003 return set_protocol_running(dev);
1004 break;
1005 case PCBIT_IOCTL_WATCH188:
1006 if (dev->l2_state != L2_LOADING)
1007 return -EINVAL;
1008 pcbit_l2_write(dev, MSG_WATCH188, 0x0001, NULL, 0);
1009 break;
1010 case PCBIT_IOCTL_PING188:
1011 if (dev->l2_state != L2_LOADING)
1012 return -EINVAL;
1013 pcbit_l2_write(dev, MSG_PING188_REQ, 0x0001, NULL, 0);
1014 break;
1015 case PCBIT_IOCTL_APION:
1016 if (dev->l2_state != L2_LOADING)
1017 return -EINVAL;
1018 pcbit_l2_write(dev, MSG_API_ON, 0x0001, NULL, 0);
1019 break;
1020 case PCBIT_IOCTL_STOP:
1021 dev->l2_state = L2_DOWN;
1022 writeb(0x40, dev->sh_mem + BANK4);
1023 dev->rcv_seq = 0;
1024 dev->send_seq = 0;
1025 dev->unack_seq = 0;
1026 break;
1027 default:
1028 printk("error: unknown ioctl\n");
1029 break;
1030 };
1031 return 0;
1032 }
1033
1034
1035
1036
1037
1038
1039
1040
1041 static void pcbit_clear_msn(struct pcbit_dev *dev)
1042 {
1043 struct msn_entry *ptr, *back;
1044
1045 for (ptr=dev->msn_list; ptr; )
1046 {
1047 back = ptr->next;
1048 kfree(ptr);
1049 ptr = back;
1050 }
1051
1052 dev->msn_list = NULL;
1053 }
1054
1055 static void pcbit_set_msn(struct pcbit_dev *dev, char *list)
1056 {
1057 struct msn_entry *ptr, *back;
1058 char *cp, *sp;
1059 int len;
1060
1061 if (strlen(list) == 0) {
1062 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1063 if (!ptr) {
1064 printk(KERN_WARNING "kmalloc failed\n");
1065 return;
1066 }
1067
1068 ptr->msn = NULL;
1069
1070 ptr->next = dev->msn_list;
1071 dev->msn_list = ptr;
1072
1073 return;
1074 }
1075
1076 for (back=dev->msn_list; back->next; back=back->next);
1077
1078 sp = list;
1079
1080 do {
1081 cp=strchr(sp, ',');
1082 if (cp)
1083 len = cp - sp;
1084 else
1085 len = strlen(sp);
1086
1087 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1088
1089 if (!ptr) {
1090 printk(KERN_WARNING "kmalloc failed\n");
1091 return;
1092 }
1093 ptr->next = NULL;
1094
1095 ptr->msn = kmalloc(len, GFP_ATOMIC);
1096 if (!ptr->msn) {
1097 printk(KERN_WARNING "kmalloc failed\n");
1098 return;
1099 }
1100
1101 memcpy(ptr->msn, sp, len - 1);
1102 ptr->msn[len] = 0;
1103
1104 #ifdef DEBUG
1105 printk(KERN_DEBUG "msn: %s\n", ptr->msn);
1106 #endif
1107 if (dev->msn_list == NULL)
1108 dev->msn_list = ptr;
1109 else
1110 back->next = ptr;
1111 back = ptr;
1112 sp += len;
1113 } while(cp);
1114 }
1115
1116
1117
1118
1119 static int pcbit_check_msn(struct pcbit_dev *dev, char *msn)
1120 {
1121 struct msn_entry *ptr;
1122
1123 for (ptr=dev->msn_list; ptr; ptr=ptr->next) {
1124
1125 if (ptr->msn == NULL)
1126 return 1;
1127
1128 if (strcmp(ptr->msn, msn) == 0)
1129 return 1;
1130 }
1131
1132 return 0;
1133 }
1134
1135
1136
1137
1138
1139
1140