Merge branch 'for-linus' of master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6] / drivers / isdn / pcbit / drv.c
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 }