Merge master.kernel.org:/pub/scm/linux/kernel/git/perex/alsa
[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 #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                 copy_to_user(buf, statbuf + stat_st, len);
729                 stat_st += len;    
730         }
731         else
732         {
733                 if (len > STATBUF_LEN - stat_st)
734                 {
735                         copy_to_user(buf, statbuf + stat_st, 
736                                        STATBUF_LEN - stat_st);
737                         copy_to_user(buf, statbuf, 
738                                        len - (STATBUF_LEN - stat_st));
739
740                         stat_st = len - (STATBUF_LEN - stat_st);
741                 }
742                 else
743                 {
744                         copy_to_user(buf, statbuf + stat_st, len);
745
746                         stat_st += len;
747                         
748                         if (stat_st == STATBUF_LEN)
749                                 stat_st = 0;
750                 }
751         }
752
753         if (stat_st == stat_end)
754                 stat_st = stat_end = 0;
755
756         return len;
757 }
758
759 static void pcbit_logstat(struct pcbit_dev *dev, char *str)
760 {
761         int i;
762         isdn_ctrl ictl;
763
764         for (i=stat_end; i<strlen(str); i++)
765         {
766                 statbuf[i]=str[i];
767                 stat_end = (stat_end + 1) % STATBUF_LEN;
768                 if (stat_end == stat_st)
769                         stat_st = (stat_st + 1) % STATBUF_LEN;
770         }
771
772         ictl.command=ISDN_STAT_STAVAIL;
773         ictl.driver=dev->id;
774         ictl.arg=strlen(str);
775         dev->dev_if->statcallb(&ictl);
776 }
777         
778 extern char * isdn_state_table[];
779 extern char * strisdnevent(unsigned short);
780
781
782 void pcbit_state_change(struct pcbit_dev * dev, struct pcbit_chan * chan, 
783                         unsigned short i, unsigned short ev, unsigned short f)
784 {
785         char buf[256];
786   
787         sprintf(buf, "change on device: %d channel:%d\n%s -> %s -> %s\n",
788                 dev->id, chan->id, 
789                 isdn_state_table[i], strisdnevent(ev), isdn_state_table[f]
790                 );
791
792 #ifdef DEBUG
793         printk("%s", buf);
794 #endif
795
796         pcbit_logstat(dev, buf);
797 }
798
799 static void set_running_timeout(unsigned long ptr)
800 {
801         struct pcbit_dev * dev;
802
803 #ifdef DEBUG
804         printk(KERN_DEBUG "set_running_timeout\n");
805 #endif
806         dev = (struct pcbit_dev *) ptr;
807
808         wake_up_interruptible(&dev->set_running_wq);
809 }
810
811 static int set_protocol_running(struct pcbit_dev * dev)
812 {
813         isdn_ctrl ctl;
814
815         init_timer(&dev->set_running_timer);
816
817         dev->set_running_timer.function = &set_running_timeout;
818         dev->set_running_timer.data = (ulong) dev;
819         dev->set_running_timer.expires = jiffies + SET_RUN_TIMEOUT;
820
821         /* kick it */
822
823         dev->l2_state = L2_STARTING;
824
825         writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)), 
826                dev->sh_mem + BANK4);
827
828         add_timer(&dev->set_running_timer);
829
830         interruptible_sleep_on(&dev->set_running_wq);
831
832         del_timer(&dev->set_running_timer);
833
834         if (dev->l2_state == L2_RUNNING)
835         {
836                 printk(KERN_DEBUG "pcbit: running\n");
837
838                 dev->unack_seq = dev->send_seq;
839
840                 dev->writeptr = dev->sh_mem;
841                 dev->readptr = dev->sh_mem + BANK2;
842     
843                 /* tell the good news to the upper layer */  
844                 ctl.driver = dev->id;
845                 ctl.command = ISDN_STAT_RUN;
846
847                 dev->dev_if->statcallb(&ctl);
848         }
849         else
850         {
851                 printk(KERN_DEBUG "pcbit: initialization failed\n");
852                 printk(KERN_DEBUG "pcbit: firmware not loaded\n");
853
854                 dev->l2_state = L2_DOWN;
855
856 #ifdef DEBUG
857                 printk(KERN_DEBUG "Bank3 = %02x\n", 
858                        readb(dev->sh_mem + BANK3));
859 #endif
860                 writeb(0x40, dev->sh_mem + BANK4);
861
862                 /* warn the upper layer */
863                 ctl.driver = dev->id;
864                 ctl.command = ISDN_STAT_STOP;
865
866                 dev->dev_if->statcallb(&ctl);
867
868                 return -EL2HLT; /* Level 2 halted */
869         }
870
871         return 0;
872 }
873
874 static int pcbit_ioctl(isdn_ctrl* ctl)
875 {
876         struct pcbit_dev * dev;
877         struct pcbit_ioctl *cmd;
878
879         dev = finddev(ctl->driver);
880   
881         if (!dev)
882         {
883                 printk(KERN_DEBUG "pcbit_ioctl: unknown device\n");
884                 return -ENODEV;
885         }
886
887         cmd = (struct pcbit_ioctl *) ctl->parm.num;
888
889         switch(ctl->arg) {
890         case PCBIT_IOCTL_GETSTAT:
891                 cmd->info.l2_status = dev->l2_state;
892                 break;
893
894         case PCBIT_IOCTL_STRLOAD:
895                 if (dev->l2_state == L2_RUNNING)
896                         return -EBUSY;
897
898                 dev->unack_seq = dev->send_seq = dev->rcv_seq = 0;
899
900                 dev->writeptr = dev->sh_mem;
901                 dev->readptr = dev->sh_mem + BANK2;
902     
903                 dev->l2_state = L2_LOADING;
904                 break;
905
906         case PCBIT_IOCTL_LWMODE:
907                 if (dev->l2_state != L2_LOADING)
908                         return -EINVAL;
909
910                 dev->l2_state = L2_LWMODE;
911                 break;
912
913         case PCBIT_IOCTL_FWMODE:
914                 if (dev->l2_state == L2_RUNNING)
915                         return -EBUSY;
916                 dev->loadptr = LOAD_ZONE_START;
917                 dev->l2_state = L2_FWMODE;
918
919                 break; 
920         case PCBIT_IOCTL_ENDLOAD:
921                 if (dev->l2_state == L2_RUNNING)
922                         return -EBUSY;
923                 dev->l2_state = L2_DOWN;
924                 break; 
925
926         case PCBIT_IOCTL_SETBYTE: 
927                 if (dev->l2_state == L2_RUNNING)
928                         return -EBUSY;
929
930                 /* check addr */
931                 if (cmd->info.rdp_byte.addr > BANK4)
932                         return -EFAULT;
933                 
934                 writeb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr);
935                 break;
936         case PCBIT_IOCTL_GETBYTE:
937                 if (dev->l2_state == L2_RUNNING)
938                         return -EBUSY;
939
940                 /* check addr */
941
942                 if (cmd->info.rdp_byte.addr > BANK4)
943                 {
944                         printk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr);
945                         return -EFAULT;
946                 }
947                 
948                 cmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr); 
949                 break;
950         case PCBIT_IOCTL_RUNNING: 
951                 if (dev->l2_state == L2_RUNNING)
952                         return -EBUSY;
953                 return set_protocol_running(dev);
954                 break;
955         case PCBIT_IOCTL_WATCH188:
956                 if (dev->l2_state != L2_LOADING)
957                         return -EINVAL;
958                 pcbit_l2_write(dev, MSG_WATCH188, 0x0001, NULL, 0);
959                 break;
960         case PCBIT_IOCTL_PING188:
961                 if (dev->l2_state != L2_LOADING)
962                         return -EINVAL;
963                 pcbit_l2_write(dev, MSG_PING188_REQ, 0x0001, NULL, 0);
964                 break;
965         case PCBIT_IOCTL_APION:
966                 if (dev->l2_state != L2_LOADING)
967                         return -EINVAL;
968                 pcbit_l2_write(dev, MSG_API_ON, 0x0001, NULL, 0);
969                 break;
970         case PCBIT_IOCTL_STOP:
971                 dev->l2_state = L2_DOWN;
972                 writeb(0x40, dev->sh_mem + BANK4);
973                 dev->rcv_seq = 0;
974                 dev->send_seq = 0;
975                 dev->unack_seq = 0;
976                 break;
977         default:
978                 printk("error: unknown ioctl\n");
979                 break;
980         };
981         return 0;
982 }
983
984 /* 
985  *        MSN list handling
986  *
987  *        if null reject all calls
988  *        if first entry has null MSN accept all calls 
989  */
990
991 static void pcbit_clear_msn(struct pcbit_dev *dev)
992 {
993         struct msn_entry *ptr, *back;
994
995         for (ptr=dev->msn_list; ptr; )
996         {
997                 back = ptr->next;
998                 kfree(ptr);
999                 ptr = back;
1000         }
1001
1002         dev->msn_list = NULL; 
1003 }
1004
1005 static void pcbit_set_msn(struct pcbit_dev *dev, char *list)
1006 {
1007         struct msn_entry *ptr;
1008         struct msn_entry *back = NULL;
1009         char *cp, *sp;
1010         int len;
1011
1012         if (strlen(list) == 0) {
1013                 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1014                 if (!ptr) {
1015                         printk(KERN_WARNING "kmalloc failed\n");
1016                         return;
1017                 }
1018
1019                 ptr->msn = NULL;
1020
1021                 ptr->next = dev->msn_list;
1022                 dev->msn_list = ptr;
1023
1024                 return;
1025         }
1026
1027         if (dev->msn_list)
1028                 for (back=dev->msn_list; back->next; back=back->next);
1029         
1030         sp = list;
1031
1032         do {
1033                 cp=strchr(sp, ',');
1034                 if (cp)
1035                         len = cp - sp;
1036                 else
1037                         len = strlen(sp);
1038
1039                 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1040
1041                 if (!ptr) {
1042                         printk(KERN_WARNING "kmalloc failed\n");
1043                         return;
1044                 }
1045                 ptr->next = NULL;
1046                 
1047                 ptr->msn = kmalloc(len, GFP_ATOMIC);
1048                 if (!ptr->msn) {
1049                         printk(KERN_WARNING "kmalloc failed\n");
1050                         kfree(ptr);
1051                         return;
1052                 }
1053
1054                 memcpy(ptr->msn, sp, len - 1);
1055                 ptr->msn[len] = 0;
1056
1057 #ifdef DEBUG
1058                 printk(KERN_DEBUG "msn: %s\n", ptr->msn);
1059 #endif
1060                 if (dev->msn_list == NULL)
1061                         dev->msn_list = ptr;
1062                 else
1063                         back->next = ptr;
1064                 back = ptr;
1065                 sp += len;
1066         } while(cp);
1067 }
1068
1069 /*
1070  *  check if we do signal or reject an incoming call
1071  */
1072 static int pcbit_check_msn(struct pcbit_dev *dev, char *msn)
1073 {
1074         struct msn_entry *ptr;
1075         
1076         for (ptr=dev->msn_list; ptr; ptr=ptr->next) {
1077
1078                 if (ptr->msn == NULL) 
1079                         return 1;
1080                 
1081                 if (strcmp(ptr->msn, msn) == 0)
1082                         return 1;
1083         }
1084
1085         return 0;
1086 }