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