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