Merge remote-tracking branch 's5p/for-next'
[linux-2.6/next.git] / drivers / isdn / pcbit / drv.c
blob1507d2e83fbb0d5acf9486e37d1fdf1583fd1a48
1 /*
2 * PCBIT-D interface with isdn4linux
4 * Copyright (C) 1996 Universidade de Lisboa
5 *
6 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
8 * This software may be used and distributed according to the terms of
9 * the GNU General Public License, incorporated herein by reference.
13 * Fixes:
15 * Nuno Grilo <l38486@alfa.ist.utl.pt>
16 * fixed msn_list NULL pointer dereference.
20 #include <linux/module.h>
23 #include <linux/kernel.h>
25 #include <linux/types.h>
26 #include <linux/sched.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>
33 #include <linux/isdnif.h>
34 #include <asm/string.h>
35 #include <asm/io.h>
36 #include <linux/ioport.h>
38 #include "pcbit.h"
39 #include "edss1.h"
40 #include "layer2.h"
41 #include "capi.h"
44 extern ushort last_ref_num;
46 static int pcbit_ioctl(isdn_ctrl* ctl);
48 static char* pcbit_devname[MAX_PCBIT_CARDS] = {
49 "pcbit0",
50 "pcbit1",
51 "pcbit2",
52 "pcbit3"
56 * prototypes
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);
64 static int set_protocol_running(struct pcbit_dev * dev);
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);
71 int pcbit_init_dev(int board, int mem_base, int irq)
73 struct pcbit_dev *dev;
74 isdn_if *dev_if;
76 if ((dev=kzalloc(sizeof(struct pcbit_dev), GFP_KERNEL)) == NULL)
78 printk("pcbit_init: couldn't malloc pcbit_dev struct\n");
79 return -ENOMEM;
82 dev_pcbit[board] = dev;
83 init_waitqueue_head(&dev->set_running_wq);
84 spin_lock_init(&dev->lock);
86 if (mem_base >= 0xA0000 && mem_base <= 0xFFFFF ) {
87 dev->ph_mem = mem_base;
88 if (!request_mem_region(dev->ph_mem, 4096, "PCBIT mem")) {
89 printk(KERN_WARNING
90 "PCBIT: memory region %lx-%lx already in use\n",
91 dev->ph_mem, dev->ph_mem + 4096);
92 kfree(dev);
93 dev_pcbit[board] = NULL;
94 return -EACCES;
96 dev->sh_mem = ioremap(dev->ph_mem, 4096);
98 else
100 printk("memory address invalid");
101 kfree(dev);
102 dev_pcbit[board] = NULL;
103 return -EACCES;
106 dev->b1 = kzalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
107 if (!dev->b1) {
108 printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
109 iounmap(dev->sh_mem);
110 release_mem_region(dev->ph_mem, 4096);
111 kfree(dev);
112 return -ENOMEM;
115 dev->b2 = kzalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
116 if (!dev->b2) {
117 printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
118 kfree(dev->b1);
119 iounmap(dev->sh_mem);
120 release_mem_region(dev->ph_mem, 4096);
121 kfree(dev);
122 return -ENOMEM;
125 dev->b2->id = 1;
127 INIT_WORK(&dev->qdelivery, pcbit_deliver);
130 * interrupts
133 if (request_irq(irq, &pcbit_irq_handler, 0, pcbit_devname[board], dev) != 0)
135 kfree(dev->b1);
136 kfree(dev->b2);
137 iounmap(dev->sh_mem);
138 release_mem_region(dev->ph_mem, 4096);
139 kfree(dev);
140 dev_pcbit[board] = NULL;
141 return -EIO;
144 dev->irq = irq;
146 /* next frame to be received */
147 dev->rcv_seq = 0;
148 dev->send_seq = 0;
149 dev->unack_seq = 0;
151 dev->hl_hdrlen = 16;
153 dev_if = kmalloc(sizeof(isdn_if), GFP_KERNEL);
155 if (!dev_if) {
156 free_irq(irq, dev);
157 kfree(dev->b1);
158 kfree(dev->b2);
159 iounmap(dev->sh_mem);
160 release_mem_region(dev->ph_mem, 4096);
161 kfree(dev);
162 dev_pcbit[board] = NULL;
163 return -EIO;
166 dev->dev_if = dev_if;
168 dev_if->owner = THIS_MODULE;
170 dev_if->channels = 2;
172 dev_if->features = (ISDN_FEATURE_P_EURO | ISDN_FEATURE_L3_TRANS |
173 ISDN_FEATURE_L2_HDLC | ISDN_FEATURE_L2_TRANS );
175 dev_if->writebuf_skb = pcbit_xmit;
176 dev_if->hl_hdrlen = 16;
178 dev_if->maxbufsize = MAXBUFSIZE;
179 dev_if->command = pcbit_command;
181 dev_if->writecmd = pcbit_writecmd;
182 dev_if->readstat = pcbit_stat;
185 strcpy(dev_if->id, pcbit_devname[board]);
187 if (!register_isdn(dev_if)) {
188 free_irq(irq, dev);
189 kfree(dev->b1);
190 kfree(dev->b2);
191 iounmap(dev->sh_mem);
192 release_mem_region(dev->ph_mem, 4096);
193 kfree(dev);
194 dev_pcbit[board] = NULL;
195 return -EIO;
198 dev->id = dev_if->channels;
201 dev->l2_state = L2_DOWN;
202 dev->free = 511;
205 * set_protocol_running(dev);
208 return 0;
211 #ifdef MODULE
212 void pcbit_terminate(int board)
214 struct pcbit_dev * dev;
216 dev = dev_pcbit[board];
218 if (dev) {
219 /* unregister_isdn(dev->dev_if); */
220 free_irq(dev->irq, dev);
221 pcbit_clear_msn(dev);
222 kfree(dev->dev_if);
223 if (dev->b1->fsm_timer.function)
224 del_timer(&dev->b1->fsm_timer);
225 if (dev->b2->fsm_timer.function)
226 del_timer(&dev->b2->fsm_timer);
227 kfree(dev->b1);
228 kfree(dev->b2);
229 iounmap(dev->sh_mem);
230 release_mem_region(dev->ph_mem, 4096);
231 kfree(dev);
234 #endif
236 static int pcbit_command(isdn_ctrl* ctl)
238 struct pcbit_dev *dev;
239 struct pcbit_chan *chan;
240 struct callb_data info;
242 dev = finddev(ctl->driver);
244 if (!dev)
246 printk("pcbit_command: unknown device\n");
247 return -1;
250 chan = (ctl->arg & 0x0F) ? dev->b2 : dev->b1;
253 switch(ctl->command) {
254 case ISDN_CMD_IOCTL:
255 return pcbit_ioctl(ctl);
256 break;
257 case ISDN_CMD_DIAL:
258 info.type = EV_USR_SETUP_REQ;
259 info.data.setup.CalledPN = (char *) &ctl->parm.setup.phone;
260 pcbit_fsm_event(dev, chan, EV_USR_SETUP_REQ, &info);
261 break;
262 case ISDN_CMD_ACCEPTD:
263 pcbit_fsm_event(dev, chan, EV_USR_SETUP_RESP, NULL);
264 break;
265 case ISDN_CMD_ACCEPTB:
266 printk("ISDN_CMD_ACCEPTB - not really needed\n");
267 break;
268 case ISDN_CMD_HANGUP:
269 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
270 break;
271 case ISDN_CMD_SETL2:
272 chan->proto = (ctl->arg >> 8);
273 break;
274 case ISDN_CMD_CLREAZ:
275 pcbit_clear_msn(dev);
276 break;
277 case ISDN_CMD_SETEAZ:
278 pcbit_set_msn(dev, ctl->parm.num);
279 break;
280 case ISDN_CMD_SETL3:
281 if ((ctl->arg >> 8) != ISDN_PROTO_L3_TRANS)
282 printk(KERN_DEBUG "L3 protocol unknown\n");
283 break;
284 default:
285 printk(KERN_DEBUG "pcbit_command: unknown command\n");
286 break;
289 return 0;
293 * Another Hack :-(
294 * on some conditions the board stops sending TDATA_CONFs
295 * let's see if we can turn around the problem
298 #ifdef BLOCK_TIMER
299 static void pcbit_block_timer(unsigned long data)
301 struct pcbit_chan *chan;
302 struct pcbit_dev * dev;
303 isdn_ctrl ictl;
305 chan = (struct pcbit_chan *) data;
307 dev = chan2dev(chan);
309 if (dev == NULL) {
310 printk(KERN_DEBUG "pcbit: chan2dev failed\n");
311 return;
314 del_timer(&chan->block_timer);
315 chan->block_timer.function = NULL;
317 #ifdef DEBUG
318 printk(KERN_DEBUG "pcbit_block_timer\n");
319 #endif
320 chan->queued = 0;
321 ictl.driver = dev->id;
322 ictl.command = ISDN_STAT_BSENT;
323 ictl.arg = chan->id;
324 dev->dev_if->statcallb(&ictl);
326 #endif
328 static int pcbit_xmit(int driver, int chnum, int ack, struct sk_buff *skb)
330 ushort hdrlen;
331 int refnum, len;
332 struct pcbit_chan * chan;
333 struct pcbit_dev *dev;
335 dev = finddev(driver);
336 if (dev == NULL)
338 printk("finddev returned NULL");
339 return -1;
342 chan = chnum ? dev->b2 : dev->b1;
345 if (chan->fsm_state != ST_ACTIVE)
346 return -1;
348 if (chan->queued >= MAX_QUEUED )
350 #ifdef DEBUG_QUEUE
351 printk(KERN_DEBUG
352 "pcbit: %d packets already in queue - write fails\n",
353 chan->queued);
354 #endif
356 * packet stays on the head of the device queue
357 * since dev_start_xmit will fail
358 * see net/core/dev.c
360 #ifdef BLOCK_TIMER
361 if (chan->block_timer.function == NULL) {
362 init_timer(&chan->block_timer);
363 chan->block_timer.function = &pcbit_block_timer;
364 chan->block_timer.data = (long) chan;
365 chan->block_timer.expires = jiffies + 1 * HZ;
366 add_timer(&chan->block_timer);
368 #endif
369 return 0;
373 chan->queued++;
375 len = skb->len;
377 hdrlen = capi_tdata_req(chan, skb);
379 refnum = last_ref_num++ & 0x7fffU;
380 chan->s_refnum = refnum;
382 pcbit_l2_write(dev, MSG_TDATA_REQ, refnum, skb, hdrlen);
384 return len;
387 static int pcbit_writecmd(const u_char __user *buf, int len, int driver, int channel)
389 struct pcbit_dev * dev;
390 int i, j;
391 const u_char * loadbuf;
392 u_char * ptr = NULL;
393 u_char *cbuf;
395 int errstat;
397 dev = finddev(driver);
399 if (!dev)
401 printk("pcbit_writecmd: couldn't find device");
402 return -ENODEV;
405 switch(dev->l2_state) {
406 case L2_LWMODE:
407 /* check (size <= rdp_size); write buf into board */
408 if (len < 0 || len > BANK4 + 1 || len > 1024)
410 printk("pcbit_writecmd: invalid length %d\n", len);
411 return -EINVAL;
414 cbuf = memdup_user(buf, len);
415 if (IS_ERR(cbuf))
416 return PTR_ERR(cbuf);
418 memcpy_toio(dev->sh_mem, cbuf, len);
419 kfree(cbuf);
420 return len;
421 case L2_FWMODE:
422 /* this is the hard part */
423 /* dumb board */
424 /* get it into kernel space */
425 if ((ptr = kmalloc(len, GFP_KERNEL))==NULL)
426 return -ENOMEM;
427 if (copy_from_user(ptr, buf, len)) {
428 kfree(ptr);
429 return -EFAULT;
431 loadbuf = ptr;
433 errstat = 0;
435 for (i=0; i < len; i++)
437 for(j=0; j < LOAD_RETRY; j++)
438 if (!(readb(dev->sh_mem + dev->loadptr)))
439 break;
441 if (j == LOAD_RETRY)
443 errstat = -ETIME;
444 printk("TIMEOUT i=%d\n", i);
445 break;
447 writeb(loadbuf[i], dev->sh_mem + dev->loadptr + 1);
448 writeb(0x01, dev->sh_mem + dev->loadptr);
450 dev->loadptr += 2;
451 if (dev->loadptr > LOAD_ZONE_END)
452 dev->loadptr = LOAD_ZONE_START;
454 kfree(ptr);
456 return errstat ? errstat : len;
457 default:
458 return -EBUSY;
463 * demultiplexing of messages
467 void pcbit_l3_receive(struct pcbit_dev * dev, ulong msg,
468 struct sk_buff * skb,
469 ushort hdr_len, ushort refnum)
471 struct pcbit_chan *chan;
472 struct sk_buff *skb2;
473 unsigned short len;
474 struct callb_data cbdata;
475 int complete, err;
476 isdn_ctrl ictl;
478 switch(msg) {
480 case MSG_TDATA_IND:
481 if (!(chan = capi_channel(dev, skb))) {
482 printk(KERN_WARNING
483 "CAPI header: unknown channel id\n");
484 break;
486 chan->r_refnum = skb->data[7];
487 skb_pull(skb, 8);
489 dev->dev_if->rcvcallb_skb(dev->id, chan->id, skb);
491 if (capi_tdata_resp(chan, &skb2) > 0)
492 pcbit_l2_write(dev, MSG_TDATA_RESP, refnum,
493 skb2, skb2->len);
494 return;
495 break;
496 case MSG_TDATA_CONF:
497 if (!(chan = capi_channel(dev, skb))) {
498 printk(KERN_WARNING
499 "CAPI header: unknown channel id\n");
500 break;
503 #ifdef DEBUG
504 if ( (*((ushort *) (skb->data + 2) )) != 0) {
505 printk(KERN_DEBUG "TDATA_CONF error\n");
507 #endif
508 #ifdef BLOCK_TIMER
509 if (chan->queued == MAX_QUEUED) {
510 del_timer(&chan->block_timer);
511 chan->block_timer.function = NULL;
514 #endif
515 chan->queued--;
517 ictl.driver = dev->id;
518 ictl.command = ISDN_STAT_BSENT;
519 ictl.arg = chan->id;
520 dev->dev_if->statcallb(&ictl);
521 break;
523 case MSG_CONN_IND:
525 * channel: 1st not used will do
526 * if both are used we're in trouble
529 if (!dev->b1->fsm_state)
530 chan = dev->b1;
531 else if (!dev->b2->fsm_state)
532 chan = dev->b2;
533 else {
534 printk(KERN_INFO
535 "Incoming connection: no channels available");
537 if ((len = capi_disc_req(*(ushort*)(skb->data), &skb2, CAUSE_NOCHAN)) > 0)
538 pcbit_l2_write(dev, MSG_DISC_REQ, refnum, skb2, len);
539 break;
542 cbdata.data.setup.CalledPN = NULL;
543 cbdata.data.setup.CallingPN = NULL;
545 capi_decode_conn_ind(chan, skb, &cbdata);
546 cbdata.type = EV_NET_SETUP;
548 pcbit_fsm_event(dev, chan, EV_NET_SETUP, NULL);
550 if (pcbit_check_msn(dev, cbdata.data.setup.CallingPN))
551 pcbit_fsm_event(dev, chan, EV_USR_PROCED_REQ, &cbdata);
552 else
553 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
555 kfree(cbdata.data.setup.CalledPN);
556 kfree(cbdata.data.setup.CallingPN);
557 break;
559 case MSG_CONN_CONF:
561 * We should be able to find the channel by the message
562 * reference number. The current version of the firmware
563 * doesn't sent the ref number correctly.
565 #ifdef DEBUG
566 printk(KERN_DEBUG "refnum=%04x b1=%04x b2=%04x\n", refnum,
567 dev->b1->s_refnum,
568 dev->b2->s_refnum);
569 #endif
570 /* We just try to find a channel in the right state */
572 if (dev->b1->fsm_state == ST_CALL_INIT)
573 chan = dev->b1;
574 else {
575 if (dev->b2->s_refnum == ST_CALL_INIT)
576 chan = dev->b2;
577 else {
578 chan = NULL;
579 printk(KERN_WARNING "Connection Confirm - no channel in Call Init state\n");
580 break;
583 if (capi_decode_conn_conf(chan, skb, &complete)) {
584 printk(KERN_DEBUG "conn_conf indicates error\n");
585 pcbit_fsm_event(dev, chan, EV_ERROR, NULL);
587 else
588 if (complete)
589 pcbit_fsm_event(dev, chan, EV_NET_CALL_PROC, NULL);
590 else
591 pcbit_fsm_event(dev, chan, EV_NET_SETUP_ACK, NULL);
592 break;
593 case MSG_CONN_ACTV_IND:
595 if (!(chan = capi_channel(dev, skb))) {
596 printk(KERN_WARNING
597 "CAPI header: unknown channel id\n");
598 break;
601 if (capi_decode_conn_actv_ind(chan, skb)) {
602 printk("error in capi_decode_conn_actv_ind\n");
603 /* pcbit_fsm_event(dev, chan, EV_ERROR, NULL); */
604 break;
606 chan->r_refnum = refnum;
607 pcbit_fsm_event(dev, chan, EV_NET_CONN, NULL);
608 break;
609 case MSG_CONN_ACTV_CONF:
611 if (!(chan = capi_channel(dev, skb))) {
612 printk(KERN_WARNING
613 "CAPI header: unknown channel id\n");
614 break;
617 if (capi_decode_conn_actv_conf(chan, skb) == 0)
618 pcbit_fsm_event(dev, chan, EV_NET_CONN_ACK, NULL);
620 else
621 printk(KERN_DEBUG "decode_conn_actv_conf failed\n");
622 break;
624 case MSG_SELP_CONF:
626 if (!(chan = capi_channel(dev, skb))) {
627 printk(KERN_WARNING
628 "CAPI header: unknown channel id\n");
629 break;
632 if (!(err = capi_decode_sel_proto_conf(chan, skb)))
633 pcbit_fsm_event(dev, chan, EV_NET_SELP_RESP, NULL);
634 else {
635 /* Error */
636 printk("error %d - capi_decode_sel_proto_conf\n", err);
638 break;
639 case MSG_ACT_TRANSP_CONF:
640 if (!(chan = capi_channel(dev, skb))) {
641 printk(KERN_WARNING
642 "CAPI header: unknown channel id\n");
643 break;
646 if (!capi_decode_actv_trans_conf(chan, skb))
647 pcbit_fsm_event(dev, chan, EV_NET_ACTV_RESP, NULL);
648 break;
650 case MSG_DISC_IND:
652 if (!(chan = capi_channel(dev, skb))) {
653 printk(KERN_WARNING
654 "CAPI header: unknown channel id\n");
655 break;
658 if (!capi_decode_disc_ind(chan, skb))
659 pcbit_fsm_event(dev, chan, EV_NET_DISC, NULL);
660 else
661 printk(KERN_WARNING "capi_decode_disc_ind - error\n");
662 break;
663 case MSG_DISC_CONF:
664 if (!(chan = capi_channel(dev, skb))) {
665 printk(KERN_WARNING
666 "CAPI header: unknown channel id\n");
667 break;
670 if (!capi_decode_disc_ind(chan, skb))
671 pcbit_fsm_event(dev, chan, EV_NET_RELEASE, NULL);
672 else
673 printk(KERN_WARNING "capi_decode_disc_conf - error\n");
674 break;
675 case MSG_INFO_IND:
676 #ifdef DEBUG
677 printk(KERN_DEBUG "received Info Indication - discarded\n");
678 #endif
679 break;
680 #ifdef DEBUG
681 case MSG_DEBUG_188:
682 capi_decode_debug_188(skb->data, skb->len);
683 break;
685 default:
686 printk(KERN_DEBUG "pcbit_l3_receive: unknown message %08lx\n",
687 msg);
688 break;
689 #endif
692 kfree_skb(skb);
697 * Single statbuf
698 * should be a statbuf per device
701 static char statbuf[STATBUF_LEN];
702 static int stat_st = 0;
703 static int stat_end = 0;
705 static int pcbit_stat(u_char __user *buf, int len, int driver, int channel)
707 int stat_count;
708 stat_count = stat_end - stat_st;
710 if (stat_count < 0)
711 stat_count = STATBUF_LEN - stat_st + stat_end;
713 /* FIXME: should we sleep and wait for more cookies ? */
714 if (len > stat_count)
715 len = stat_count;
717 if (stat_st < stat_end)
719 if (copy_to_user(buf, statbuf + stat_st, len))
720 return -EFAULT;
721 stat_st += len;
723 else
725 if (len > STATBUF_LEN - stat_st)
727 if (copy_to_user(buf, statbuf + stat_st,
728 STATBUF_LEN - stat_st))
729 return -EFAULT;
730 if (copy_to_user(buf, statbuf,
731 len - (STATBUF_LEN - stat_st)))
732 return -EFAULT;
734 stat_st = len - (STATBUF_LEN - stat_st);
736 else
738 if (copy_to_user(buf, statbuf + stat_st, len))
739 return -EFAULT;
741 stat_st += len;
743 if (stat_st == STATBUF_LEN)
744 stat_st = 0;
748 if (stat_st == stat_end)
749 stat_st = stat_end = 0;
751 return len;
754 static void pcbit_logstat(struct pcbit_dev *dev, char *str)
756 int i;
757 isdn_ctrl ictl;
759 for (i=stat_end; i<strlen(str); i++)
761 statbuf[i]=str[i];
762 stat_end = (stat_end + 1) % STATBUF_LEN;
763 if (stat_end == stat_st)
764 stat_st = (stat_st + 1) % STATBUF_LEN;
767 ictl.command=ISDN_STAT_STAVAIL;
768 ictl.driver=dev->id;
769 ictl.arg=strlen(str);
770 dev->dev_if->statcallb(&ictl);
773 void pcbit_state_change(struct pcbit_dev * dev, struct pcbit_chan * chan,
774 unsigned short i, unsigned short ev, unsigned short f)
776 char buf[256];
778 sprintf(buf, "change on device: %d channel:%d\n%s -> %s -> %s\n",
779 dev->id, chan->id,
780 isdn_state_table[i], strisdnevent(ev), isdn_state_table[f]
783 #ifdef DEBUG
784 printk("%s", buf);
785 #endif
787 pcbit_logstat(dev, buf);
790 static void set_running_timeout(unsigned long ptr)
792 struct pcbit_dev * dev;
794 #ifdef DEBUG
795 printk(KERN_DEBUG "set_running_timeout\n");
796 #endif
797 dev = (struct pcbit_dev *) ptr;
799 wake_up_interruptible(&dev->set_running_wq);
802 static int set_protocol_running(struct pcbit_dev * dev)
804 isdn_ctrl ctl;
806 init_timer(&dev->set_running_timer);
808 dev->set_running_timer.function = &set_running_timeout;
809 dev->set_running_timer.data = (ulong) dev;
810 dev->set_running_timer.expires = jiffies + SET_RUN_TIMEOUT;
812 /* kick it */
814 dev->l2_state = L2_STARTING;
816 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
817 dev->sh_mem + BANK4);
819 add_timer(&dev->set_running_timer);
821 interruptible_sleep_on(&dev->set_running_wq);
823 del_timer(&dev->set_running_timer);
825 if (dev->l2_state == L2_RUNNING)
827 printk(KERN_DEBUG "pcbit: running\n");
829 dev->unack_seq = dev->send_seq;
831 dev->writeptr = dev->sh_mem;
832 dev->readptr = dev->sh_mem + BANK2;
834 /* tell the good news to the upper layer */
835 ctl.driver = dev->id;
836 ctl.command = ISDN_STAT_RUN;
838 dev->dev_if->statcallb(&ctl);
840 else
842 printk(KERN_DEBUG "pcbit: initialization failed\n");
843 printk(KERN_DEBUG "pcbit: firmware not loaded\n");
845 dev->l2_state = L2_DOWN;
847 #ifdef DEBUG
848 printk(KERN_DEBUG "Bank3 = %02x\n",
849 readb(dev->sh_mem + BANK3));
850 #endif
851 writeb(0x40, dev->sh_mem + BANK4);
853 /* warn the upper layer */
854 ctl.driver = dev->id;
855 ctl.command = ISDN_STAT_STOP;
857 dev->dev_if->statcallb(&ctl);
859 return -EL2HLT; /* Level 2 halted */
862 return 0;
865 static int pcbit_ioctl(isdn_ctrl* ctl)
867 struct pcbit_dev * dev;
868 struct pcbit_ioctl *cmd;
870 dev = finddev(ctl->driver);
872 if (!dev)
874 printk(KERN_DEBUG "pcbit_ioctl: unknown device\n");
875 return -ENODEV;
878 cmd = (struct pcbit_ioctl *) ctl->parm.num;
880 switch(ctl->arg) {
881 case PCBIT_IOCTL_GETSTAT:
882 cmd->info.l2_status = dev->l2_state;
883 break;
885 case PCBIT_IOCTL_STRLOAD:
886 if (dev->l2_state == L2_RUNNING)
887 return -EBUSY;
889 dev->unack_seq = dev->send_seq = dev->rcv_seq = 0;
891 dev->writeptr = dev->sh_mem;
892 dev->readptr = dev->sh_mem + BANK2;
894 dev->l2_state = L2_LOADING;
895 break;
897 case PCBIT_IOCTL_LWMODE:
898 if (dev->l2_state != L2_LOADING)
899 return -EINVAL;
901 dev->l2_state = L2_LWMODE;
902 break;
904 case PCBIT_IOCTL_FWMODE:
905 if (dev->l2_state == L2_RUNNING)
906 return -EBUSY;
907 dev->loadptr = LOAD_ZONE_START;
908 dev->l2_state = L2_FWMODE;
910 break;
911 case PCBIT_IOCTL_ENDLOAD:
912 if (dev->l2_state == L2_RUNNING)
913 return -EBUSY;
914 dev->l2_state = L2_DOWN;
915 break;
917 case PCBIT_IOCTL_SETBYTE:
918 if (dev->l2_state == L2_RUNNING)
919 return -EBUSY;
921 /* check addr */
922 if (cmd->info.rdp_byte.addr > BANK4)
923 return -EFAULT;
925 writeb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr);
926 break;
927 case PCBIT_IOCTL_GETBYTE:
928 if (dev->l2_state == L2_RUNNING)
929 return -EBUSY;
931 /* check addr */
933 if (cmd->info.rdp_byte.addr > BANK4)
935 printk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr);
936 return -EFAULT;
939 cmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr);
940 break;
941 case PCBIT_IOCTL_RUNNING:
942 if (dev->l2_state == L2_RUNNING)
943 return -EBUSY;
944 return set_protocol_running(dev);
945 break;
946 case PCBIT_IOCTL_WATCH188:
947 if (dev->l2_state != L2_LOADING)
948 return -EINVAL;
949 pcbit_l2_write(dev, MSG_WATCH188, 0x0001, NULL, 0);
950 break;
951 case PCBIT_IOCTL_PING188:
952 if (dev->l2_state != L2_LOADING)
953 return -EINVAL;
954 pcbit_l2_write(dev, MSG_PING188_REQ, 0x0001, NULL, 0);
955 break;
956 case PCBIT_IOCTL_APION:
957 if (dev->l2_state != L2_LOADING)
958 return -EINVAL;
959 pcbit_l2_write(dev, MSG_API_ON, 0x0001, NULL, 0);
960 break;
961 case PCBIT_IOCTL_STOP:
962 dev->l2_state = L2_DOWN;
963 writeb(0x40, dev->sh_mem + BANK4);
964 dev->rcv_seq = 0;
965 dev->send_seq = 0;
966 dev->unack_seq = 0;
967 break;
968 default:
969 printk("error: unknown ioctl\n");
970 break;
972 return 0;
976 * MSN list handling
978 * if null reject all calls
979 * if first entry has null MSN accept all calls
982 static void pcbit_clear_msn(struct pcbit_dev *dev)
984 struct msn_entry *ptr, *back;
986 for (ptr=dev->msn_list; ptr; )
988 back = ptr->next;
989 kfree(ptr);
990 ptr = back;
993 dev->msn_list = NULL;
996 static void pcbit_set_msn(struct pcbit_dev *dev, char *list)
998 struct msn_entry *ptr;
999 struct msn_entry *back = NULL;
1000 char *cp, *sp;
1001 int len;
1003 if (strlen(list) == 0) {
1004 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1005 if (!ptr) {
1006 printk(KERN_WARNING "kmalloc failed\n");
1007 return;
1010 ptr->msn = NULL;
1012 ptr->next = dev->msn_list;
1013 dev->msn_list = ptr;
1015 return;
1018 if (dev->msn_list)
1019 for (back=dev->msn_list; back->next; back=back->next);
1021 sp = list;
1023 do {
1024 cp=strchr(sp, ',');
1025 if (cp)
1026 len = cp - sp;
1027 else
1028 len = strlen(sp);
1030 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1032 if (!ptr) {
1033 printk(KERN_WARNING "kmalloc failed\n");
1034 return;
1036 ptr->next = NULL;
1038 ptr->msn = kmalloc(len, GFP_ATOMIC);
1039 if (!ptr->msn) {
1040 printk(KERN_WARNING "kmalloc failed\n");
1041 kfree(ptr);
1042 return;
1045 memcpy(ptr->msn, sp, len - 1);
1046 ptr->msn[len] = 0;
1048 #ifdef DEBUG
1049 printk(KERN_DEBUG "msn: %s\n", ptr->msn);
1050 #endif
1051 if (dev->msn_list == NULL)
1052 dev->msn_list = ptr;
1053 else
1054 back->next = ptr;
1055 back = ptr;
1056 sp += len;
1057 } while(cp);
1061 * check if we do signal or reject an incoming call
1063 static int pcbit_check_msn(struct pcbit_dev *dev, char *msn)
1065 struct msn_entry *ptr;
1067 for (ptr=dev->msn_list; ptr; ptr=ptr->next) {
1069 if (ptr->msn == NULL)
1070 return 1;
1072 if (strcmp(ptr->msn, msn) == 0)
1073 return 1;
1076 return 0;