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