projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'staging/staging-next'
[deliverable/linux.git] / drivers / staging / i4l / pcbit / drv.c
CommitLineData
1da177e4
LT		 1/*
2 * PCBIT-D interface with isdn4linux
3 *
4 * Copyright (C) 1996 Universidade de Lisboa
475be4d8 5 *
1da177e4
LT		 6 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
7 *
475be4d8 8 * This software may be used and distributed according to the terms of
1da177e4
LT		 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.
475be4d8 17 *
1da177e4
LT		 18 */
19
20#include <linux/module.h>
21
1da177e4
LT		 22
23#include <linux/kernel.h>
24
25#include <linux/types.h>
d43c36dc 26#include <linux/sched.h>
1da177e4
LT		 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
44extern ushort last_ref_num;
45
475be4d8 46static int pcbit_ioctl(isdn_ctrl *ctl);
1da177e4 47
475be4d8 48static char *pcbit_devname[MAX_PCBIT_CARDS] = {
1da177e4
LT		 49 "pcbit0",
50 "pcbit1",
51 "pcbit2",
52 "pcbit3"
53};
54
55/*
56 * prototypes
57 */
58
475be4d8
JP		 59static int pcbit_command(isdn_ctrl *ctl);
60static int pcbit_stat(u_char __user *buf, int len, int, int);
886cca3a
AB		 61static int pcbit_xmit(int driver, int chan, int ack, struct sk_buff *skb);
62static int pcbit_writecmd(const u_char __user *, int, int, int);
1da177e4 63
475be4d8 64static int set_protocol_running(struct pcbit_dev *dev);
1da177e4
LT		 65
66static void pcbit_clear_msn(struct pcbit_dev *dev);
67static void pcbit_set_msn(struct pcbit_dev *dev, char *list);
68static int pcbit_check_msn(struct pcbit_dev *dev, char *msn);
69
70
1da177e4
LT		 71int pcbit_init_dev(int board, int mem_base, int irq)
72{
73 struct pcbit_dev *dev;
74 isdn_if *dev_if;
75
475be4d8 76 if ((dev = kzalloc(sizeof(struct pcbit_dev), GFP_KERNEL)) == NULL)
1da177e4
LT		 77 {
78 printk("pcbit_init: couldn't malloc pcbit_dev struct\n");
79 return -ENOMEM;
80 }
81
82 dev_pcbit[board] = dev;
1da177e4
LT		 83 init_waitqueue_head(&dev->set_running_wq);
84 spin_lock_init(&dev->lock);
85
475be4d8 86 if (mem_base >= 0xA0000 && mem_base <= 0xFFFFF) {
1da177e4
LT		 87 dev->ph_mem = mem_base;
88 if (!request_mem_region(dev->ph_mem, 4096, "PCBIT mem")) {
89 printk(KERN_WARNING
475be4d8
JP		 90 "PCBIT: memory region %lx-%lx already in use\n",
91 dev->ph_mem, dev->ph_mem + 4096);
1da177e4
LT		 92 kfree(dev);
93 dev_pcbit[board] = NULL;
94 return -EACCES;
95 }
96 dev->sh_mem = ioremap(dev->ph_mem, 4096);
97 }
475be4d8 98 else
1da177e4
LT		 99 {
100 printk("memory address invalid");
101 kfree(dev);
102 dev_pcbit[board] = NULL;
103 return -EACCES;
104 }
105
41f96935 106 dev->b1 = kzalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
1da177e4
LT		 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 }
475be4d8 114
41f96935 115 dev->b2 = kzalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
1da177e4
LT		 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
1da177e4
LT		 125 dev->b2->id = 1;
126
c4028958 127 INIT_WORK(&dev->qdelivery, pcbit_deliver);
1da177e4
LT		 128
129 /*
130 * interrupts
131 */
132
475be4d8 133 if (request_irq(irq, &pcbit_irq_handler, 0, pcbit_devname[board], dev) != 0)
1da177e4
LT		 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;
475be4d8
JP		 171
172 dev_if->features = (ISDN_FEATURE_P_EURO | ISDN_FEATURE_L3_TRANS |
173 ISDN_FEATURE_L2_HDLC | ISDN_FEATURE_L2_TRANS);
1da177e4
LT		 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;
475be4d8 180
1da177e4
LT		 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
212void pcbit_terminate(int board)
213{
475be4d8 214 struct pcbit_dev *dev;
1da177e4
LT		 215
216 dev = dev_pcbit[board];
217
218 if (dev) {
475be4d8 219 /* unregister_isdn(dev->dev_if); */
1da177e4
LT		 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
475be4d8 236static int pcbit_command(isdn_ctrl *ctl)
1da177e4 237{
475be4d8 238 struct pcbit_dev *dev;
1da177e4
LT		 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
475be4d8 253 switch (ctl->command) {
1da177e4
LT		 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;
5c722af4 287 }
1da177e4
LT		 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
299static void pcbit_block_timer(unsigned long data)
300{
301 struct pcbit_chan *chan;
475be4d8 302 struct pcbit_dev *dev;
1da177e4
LT		 303 isdn_ctrl ictl;
304
475be4d8 305 chan = (struct pcbit_chan *)data;
1da177e4
LT		 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");
475be4d8 319#endif
1da177e4
LT		 320 chan->queued = 0;
321 ictl.driver = dev->id;
322 ictl.command = ISDN_STAT_BSENT;
323 ictl.arg = chan->id;
475be4d8 324 dev->dev_if->statcallb(&ictl);
1da177e4
LT		 325}
326#endif
327
886cca3a 328static int pcbit_xmit(int driver, int chnum, int ack, struct sk_buff *skb)
1da177e4
LT		 329{
330 ushort hdrlen;
331 int refnum, len;
475be4d8 332 struct pcbit_chan *chan;
1da177e4
LT		 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
475be4d8 348 if (chan->queued >= MAX_QUEUED)
1da177e4
LT		 349 {
350#ifdef DEBUG_QUEUE
475be4d8 351 printk(KERN_DEBUG
1da177e4
LT		 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) {
fd2b75d8
MFW		 362 setup_timer(&chan->block_timer, &pcbit_block_timer,
363 (long)chan);
364 mod_timer(&chan->block_timer, jiffies + 1 * HZ);
1da177e4 365 }
475be4d8
JP		 366#endif
367 return 0;
1da177e4
LT		 368 }
369
370
371 chan->queued++;
475be4d8
JP		 372
373 len = skb->len;
1da177e4
LT		 374
375 hdrlen = capi_tdata_req(chan, skb);
376
377 refnum = last_ref_num++ & 0x7fffU;
378 chan->s_refnum = refnum;
379
380 pcbit_l2_write(dev, MSG_TDATA_REQ, refnum, skb, hdrlen);
381
382 return len;
383}
384
886cca3a 385static int pcbit_writecmd(const u_char __user *buf, int len, int driver, int channel)
1da177e4 386{
475be4d8 387 struct pcbit_dev *dev;
1da177e4 388 int i, j;
475be4d8
JP		 389 const u_char *loadbuf;
390 u_char *ptr = NULL;
1da177e4
LT		 391 u_char *cbuf;
392
393 int errstat;
394
395 dev = finddev(driver);
396
397 if (!dev)
398 {
399 printk("pcbit_writecmd: couldn't find device");
400 return -ENODEV;
401 }
402
475be4d8 403 switch (dev->l2_state) {
1da177e4
LT		 404 case L2_LWMODE:
405 /* check (size <= rdp_size); write buf into board */
406 if (len < 0 || len > BANK4 + 1 || len > 1024)
407 {
408 printk("pcbit_writecmd: invalid length %d\n", len);
409 return -EINVAL;
410 }
411
024cb8a6
JL		 412 cbuf = memdup_user(buf, len);
413 if (IS_ERR(cbuf))
414 return PTR_ERR(cbuf);
1da177e4 415
1da177e4
LT		 416 memcpy_toio(dev->sh_mem, cbuf, len);
417 kfree(cbuf);
418 return len;
419 case L2_FWMODE:
420 /* this is the hard part */
421 /* dumb board */
422 /* get it into kernel space */
475be4d8 423 if ((ptr = kmalloc(len, GFP_KERNEL)) == NULL)
1da177e4
LT		 424 return -ENOMEM;
425 if (copy_from_user(ptr, buf, len)) {
426 kfree(ptr);
427 return -EFAULT;
428 }
429 loadbuf = ptr;
475be4d8 430
1da177e4
LT		 431 errstat = 0;
432
475be4d8 433 for (i = 0; i < len; i++)
1da177e4 434 {
475be4d8 435 for (j = 0; j < LOAD_RETRY; j++)
1da177e4
LT		 436 if (!(readb(dev->sh_mem + dev->loadptr)))
437 break;
438
439 if (j == LOAD_RETRY)
440 {
441 errstat = -ETIME;
442 printk("TIMEOUT i=%d\n", i);
443 break;
444 }
445 writeb(loadbuf[i], dev->sh_mem + dev->loadptr + 1);
446 writeb(0x01, dev->sh_mem + dev->loadptr);
447
448 dev->loadptr += 2;
449 if (dev->loadptr > LOAD_ZONE_END)
450 dev->loadptr = LOAD_ZONE_START;
451 }
452 kfree(ptr);
453
454 return errstat ? errstat : len;
455 default:
456 return -EBUSY;
457 }
458}
459
460/*
461 * demultiplexing of messages
462 *
463 */
464
475be4d8
JP		 465void pcbit_l3_receive(struct pcbit_dev *dev, ulong msg,
466 struct sk_buff *skb,
467 ushort hdr_len, ushort refnum)
1da177e4
LT		 468{
469 struct pcbit_chan *chan;
470 struct sk_buff *skb2;
471 unsigned short len;
472 struct callb_data cbdata;
473 int complete, err;
474 isdn_ctrl ictl;
475
475be4d8 476 switch (msg) {
1da177e4
LT		 477
478 case MSG_TDATA_IND:
479 if (!(chan = capi_channel(dev, skb))) {
475be4d8 480 printk(KERN_WARNING
1da177e4
LT		 481 "CAPI header: unknown channel id\n");
482 break;
483 }
484 chan->r_refnum = skb->data[7];
485 skb_pull(skb, 8);
486
487 dev->dev_if->rcvcallb_skb(dev->id, chan->id, skb);
488
475be4d8
JP		 489 if (capi_tdata_resp(chan, &skb2) > 0)
490 pcbit_l2_write(dev, MSG_TDATA_RESP, refnum,
1da177e4
LT		 491 skb2, skb2->len);
492 return;
475be4d8 493 break;
1da177e4
LT		 494 case MSG_TDATA_CONF:
495 if (!(chan = capi_channel(dev, skb))) {
475be4d8 496 printk(KERN_WARNING
1da177e4
LT		 497 "CAPI header: unknown channel id\n");
498 break;
499 }
500
501#ifdef DEBUG
475be4d8
JP		 502 if ((*((ushort *)(skb->data + 2))) != 0) {
503 printk(KERN_DEBUG "TDATA_CONF error\n");
1da177e4
LT		 504 }
505#endif
506#ifdef BLOCK_TIMER
475be4d8
JP		 507 if (chan->queued == MAX_QUEUED) {
508 del_timer(&chan->block_timer);
1da177e4
LT		 509 chan->block_timer.function = NULL;
510 }
475be4d8
JP		 511
512#endif
1da177e4
LT		 513 chan->queued--;
514
515 ictl.driver = dev->id;
516 ictl.command = ISDN_STAT_BSENT;
517 ictl.arg = chan->id;
518 dev->dev_if->statcallb(&ictl);
519 break;
520
521 case MSG_CONN_IND:
522 /*
523 * channel: 1st not used will do
475be4d8 524 * if both are used we're in trouble
1da177e4
LT		 525 */
526
527 if (!dev->b1->fsm_state)
528 chan = dev->b1;
529 else if (!dev->b2->fsm_state)
530 chan = dev->b2;
531 else {
475be4d8 532 printk(KERN_INFO
1da177e4
LT		 533 "Incoming connection: no channels available");
534
475be4d8 535 if ((len = capi_disc_req(*(ushort *)(skb->data), &skb2, CAUSE_NOCHAN)) > 0)
1da177e4 536 pcbit_l2_write(dev, MSG_DISC_REQ, refnum, skb2, len);
475be4d8 537 break;
1da177e4
LT		 538 }
539
540 cbdata.data.setup.CalledPN = NULL;
541 cbdata.data.setup.CallingPN = NULL;
542
543 capi_decode_conn_ind(chan, skb, &cbdata);
544 cbdata.type = EV_NET_SETUP;
545
546 pcbit_fsm_event(dev, chan, EV_NET_SETUP, NULL);
547
475be4d8 548 if (pcbit_check_msn(dev, cbdata.data.setup.CallingPN))
1da177e4
LT		 549 pcbit_fsm_event(dev, chan, EV_USR_PROCED_REQ, &cbdata);
550 else
551 pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
552
3c7208f2
JJ		 553 kfree(cbdata.data.setup.CalledPN);
554 kfree(cbdata.data.setup.CallingPN);
1da177e4 555 break;
475be4d8 556
1da177e4 557 case MSG_CONN_CONF:
475be4d8 558 /*
1da177e4
LT		 559 * We should be able to find the channel by the message
560 * reference number. The current version of the firmware
561 * doesn't sent the ref number correctly.
562 */
563#ifdef DEBUG
475be4d8
JP		 564 printk(KERN_DEBUG "refnum=%04x b1=%04x b2=%04x\n", refnum,
565 dev->b1->s_refnum,
1da177e4
LT		 566 dev->b2->s_refnum);
567#endif
568 /* We just try to find a channel in the right state */
569
570 if (dev->b1->fsm_state == ST_CALL_INIT)
571 chan = dev->b1;
475be4d8 572 else {
1da177e4
LT		 573 if (dev->b2->s_refnum == ST_CALL_INIT)
574 chan = dev->b2;
475be4d8 575 else {
1da177e4
LT		 576 chan = NULL;
577 printk(KERN_WARNING "Connection Confirm - no channel in Call Init state\n");
578 break;
579 }
580 }
581 if (capi_decode_conn_conf(chan, skb, &complete)) {
582 printk(KERN_DEBUG "conn_conf indicates error\n");
583 pcbit_fsm_event(dev, chan, EV_ERROR, NULL);
584 }
585 else
586 if (complete)
587 pcbit_fsm_event(dev, chan, EV_NET_CALL_PROC, NULL);
588 else
589 pcbit_fsm_event(dev, chan, EV_NET_SETUP_ACK, NULL);
475be4d8 590 break;
1da177e4
LT		 591 case MSG_CONN_ACTV_IND:
592
593 if (!(chan = capi_channel(dev, skb))) {
475be4d8 594 printk(KERN_WARNING
1da177e4
LT		 595 "CAPI header: unknown channel id\n");
596 break;
597 }
475be4d8 598
1da177e4
LT		 599 if (capi_decode_conn_actv_ind(chan, skb)) {
600 printk("error in capi_decode_conn_actv_ind\n");
475be4d8 601 /* pcbit_fsm_event(dev, chan, EV_ERROR, NULL); */
1da177e4
LT		 602 break;
603 }
604 chan->r_refnum = refnum;
605 pcbit_fsm_event(dev, chan, EV_NET_CONN, NULL);
606 break;
607 case MSG_CONN_ACTV_CONF:
608
609 if (!(chan = capi_channel(dev, skb))) {
475be4d8 610 printk(KERN_WARNING
1da177e4
LT		 611 "CAPI header: unknown channel id\n");
612 break;
613 }
614
615 if (capi_decode_conn_actv_conf(chan, skb) == 0)
616 pcbit_fsm_event(dev, chan, EV_NET_CONN_ACK, NULL);
475be4d8 617
1da177e4
LT		 618 else
619 printk(KERN_DEBUG "decode_conn_actv_conf failed\n");
620 break;
621
622 case MSG_SELP_CONF:
623
624 if (!(chan = capi_channel(dev, skb))) {
475be4d8 625 printk(KERN_WARNING
1da177e4
LT		 626 "CAPI header: unknown channel id\n");
627 break;
628 }
629
630 if (!(err = capi_decode_sel_proto_conf(chan, skb)))
631 pcbit_fsm_event(dev, chan, EV_NET_SELP_RESP, NULL);
632 else {
633 /* Error */
634 printk("error %d - capi_decode_sel_proto_conf\n", err);
635 }
636 break;
637 case MSG_ACT_TRANSP_CONF:
638 if (!(chan = capi_channel(dev, skb))) {
475be4d8 639 printk(KERN_WARNING
1da177e4
LT		 640 "CAPI header: unknown channel id\n");
641 break;
642 }
643
644 if (!capi_decode_actv_trans_conf(chan, skb))
645 pcbit_fsm_event(dev, chan, EV_NET_ACTV_RESP, NULL);
646 break;
647
648 case MSG_DISC_IND:
649
650 if (!(chan = capi_channel(dev, skb))) {
475be4d8 651 printk(KERN_WARNING
1da177e4
LT		 652 "CAPI header: unknown channel id\n");
653 break;
654 }
655
656 if (!capi_decode_disc_ind(chan, skb))
657 pcbit_fsm_event(dev, chan, EV_NET_DISC, NULL);
658 else
659 printk(KERN_WARNING "capi_decode_disc_ind - error\n");
660 break;
661 case MSG_DISC_CONF:
662 if (!(chan = capi_channel(dev, skb))) {
475be4d8 663 printk(KERN_WARNING
1da177e4
LT		 664 "CAPI header: unknown channel id\n");
665 break;
666 }
667
668 if (!capi_decode_disc_ind(chan, skb))
669 pcbit_fsm_event(dev, chan, EV_NET_RELEASE, NULL);
670 else
671 printk(KERN_WARNING "capi_decode_disc_conf - error\n");
672 break;
673 case MSG_INFO_IND:
674#ifdef DEBUG
675 printk(KERN_DEBUG "received Info Indication - discarded\n");
676#endif
677 break;
678#ifdef DEBUG
679 case MSG_DEBUG_188:
680 capi_decode_debug_188(skb->data, skb->len);
681 break;
682
683 default:
684 printk(KERN_DEBUG "pcbit_l3_receive: unknown message %08lx\n",
685 msg);
686 break;
687#endif
688 }
689
690 kfree_skb(skb);
691
692}
693
694/*
695 * Single statbuf
696 * should be a statbuf per device
697 */
698
699static char statbuf[STATBUF_LEN];
3e735d1e
SB		 700static int stat_st;
701static int stat_end;
1da177e4 702
886cca3a 703static int pcbit_stat(u_char __user *buf, int len, int driver, int channel)
1da177e4
LT		 704{
705 int stat_count;
706 stat_count = stat_end - stat_st;
707
708 if (stat_count < 0)
709 stat_count = STATBUF_LEN - stat_st + stat_end;
710
711 /* FIXME: should we sleep and wait for more cookies ? */
475be4d8 712 if (len > stat_count)
1da177e4
LT		 713 len = stat_count;
714
715 if (stat_st < stat_end)
716 {
7786ce19
JG		 717 if (copy_to_user(buf, statbuf + stat_st, len))
718 return -EFAULT;
475be4d8 719 stat_st += len;
1da177e4
LT		 720 }
721 else
722 {
723 if (len > STATBUF_LEN - stat_st)
724 {
7786ce19 725 if (copy_to_user(buf, statbuf + stat_st,
475be4d8 726 STATBUF_LEN - stat_st))
7786ce19
JG		 727 return -EFAULT;
728 if (copy_to_user(buf, statbuf,
475be4d8 729 len - (STATBUF_LEN - stat_st)))
7786ce19 730 return -EFAULT;
1da177e4
LT		 731
732 stat_st = len - (STATBUF_LEN - stat_st);
733 }
734 else
735 {
7786ce19
JG		 736 if (copy_to_user(buf, statbuf + stat_st, len))
737 return -EFAULT;
1da177e4
LT		 738
739 stat_st += len;
475be4d8 740
1da177e4
LT		 741 if (stat_st == STATBUF_LEN)
742 stat_st = 0;
743 }
744 }
745
746 if (stat_st == stat_end)
747 stat_st = stat_end = 0;
748
749 return len;
750}
751
752static void pcbit_logstat(struct pcbit_dev *dev, char *str)
753{
754 int i;
755 isdn_ctrl ictl;
756
475be4d8 757 for (i = stat_end; i < strlen(str); i++)
1da177e4 758 {
475be4d8 759 statbuf[i] = str[i];
1da177e4
LT		 760 stat_end = (stat_end + 1) % STATBUF_LEN;
761 if (stat_end == stat_st)
762 stat_st = (stat_st + 1) % STATBUF_LEN;
763 }
764
475be4d8
JP		 765 ictl.command = ISDN_STAT_STAVAIL;
766 ictl.driver = dev->id;
767 ictl.arg = strlen(str);
1da177e4
LT		 768 dev->dev_if->statcallb(&ictl);
769}
475be4d8
JP		 770
771void pcbit_state_change(struct pcbit_dev *dev, struct pcbit_chan *chan,
1da177e4
LT		 772 unsigned short i, unsigned short ev, unsigned short f)
773{
774 char buf[256];
475be4d8 775
1da177e4 776 sprintf(buf, "change on device: %d channel:%d\n%s -> %s -> %s\n",
475be4d8 777 dev->id, chan->id,
1da177e4
LT		 778 isdn_state_table[i], strisdnevent(ev), isdn_state_table[f]
779 );
780
781#ifdef DEBUG
782 printk("%s", buf);
783#endif
784
785 pcbit_logstat(dev, buf);
786}
787
788static void set_running_timeout(unsigned long ptr)
789{
475be4d8 790 struct pcbit_dev *dev;
1da177e4
LT		 791
792#ifdef DEBUG
793 printk(KERN_DEBUG "set_running_timeout\n");
794#endif
795 dev = (struct pcbit_dev *) ptr;
796
e5b3fa15 797 dev->l2_state = L2_DOWN;
1da177e4
LT		 798 wake_up_interruptible(&dev->set_running_wq);
799}
800
475be4d8 801static int set_protocol_running(struct pcbit_dev *dev)
1da177e4
LT		 802{
803 isdn_ctrl ctl;
804
fd2b75d8 805 setup_timer(&dev->set_running_timer, &set_running_timeout, (ulong)dev);
1da177e4
LT		 806
807 /* kick it */
808
809 dev->l2_state = L2_STARTING;
810
475be4d8 811 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
1da177e4
LT		 812 dev->sh_mem + BANK4);
813
fd2b75d8 814 mod_timer(&dev->set_running_timer, jiffies + SET_RUN_TIMEOUT);
1da177e4 815
e5b3fa15
AB		 816 wait_event(dev->set_running_wq, dev->l2_state == L2_RUNNING ||
817 dev->l2_state == L2_DOWN);
1da177e4
LT		 818
819 del_timer(&dev->set_running_timer);
820
821 if (dev->l2_state == L2_RUNNING)
822 {
823 printk(KERN_DEBUG "pcbit: running\n");
824
825 dev->unack_seq = dev->send_seq;
826
827 dev->writeptr = dev->sh_mem;
828 dev->readptr = dev->sh_mem + BANK2;
475be4d8
JP		 829
830 /* tell the good news to the upper layer */
1da177e4
LT		 831 ctl.driver = dev->id;
832 ctl.command = ISDN_STAT_RUN;
833
834 dev->dev_if->statcallb(&ctl);
835 }
836 else
837 {
838 printk(KERN_DEBUG "pcbit: initialization failed\n");
839 printk(KERN_DEBUG "pcbit: firmware not loaded\n");
840
1da177e4 841#ifdef DEBUG
475be4d8 842 printk(KERN_DEBUG "Bank3 = %02x\n",
1da177e4
LT		 843 readb(dev->sh_mem + BANK3));
844#endif
845 writeb(0x40, dev->sh_mem + BANK4);
846
847 /* warn the upper layer */
848 ctl.driver = dev->id;
849 ctl.command = ISDN_STAT_STOP;
850
851 dev->dev_if->statcallb(&ctl);
852
853 return -EL2HLT; /* Level 2 halted */
854 }
855
856 return 0;
857}
858
475be4d8 859static int pcbit_ioctl(isdn_ctrl *ctl)
1da177e4 860{
475be4d8 861 struct pcbit_dev *dev;
1da177e4
LT		 862 struct pcbit_ioctl *cmd;
863
864 dev = finddev(ctl->driver);
475be4d8 865
1da177e4
LT		 866 if (!dev)
867 {
868 printk(KERN_DEBUG "pcbit_ioctl: unknown device\n");
869 return -ENODEV;
870 }
871
872 cmd = (struct pcbit_ioctl *) ctl->parm.num;
873
475be4d8 874 switch (ctl->arg) {
1da177e4
LT		 875 case PCBIT_IOCTL_GETSTAT:
876 cmd->info.l2_status = dev->l2_state;
877 break;
878
879 case PCBIT_IOCTL_STRLOAD:
880 if (dev->l2_state == L2_RUNNING)
881 return -EBUSY;
882
883 dev->unack_seq = dev->send_seq = dev->rcv_seq = 0;
884
885 dev->writeptr = dev->sh_mem;
886 dev->readptr = dev->sh_mem + BANK2;
475be4d8 887
1da177e4
LT		 888 dev->l2_state = L2_LOADING;
889 break;
890
891 case PCBIT_IOCTL_LWMODE:
892 if (dev->l2_state != L2_LOADING)
893 return -EINVAL;
894
895 dev->l2_state = L2_LWMODE;
896 break;
897
898 case PCBIT_IOCTL_FWMODE:
899 if (dev->l2_state == L2_RUNNING)
900 return -EBUSY;
901 dev->loadptr = LOAD_ZONE_START;
902 dev->l2_state = L2_FWMODE;
903
475be4d8 904 break;
1da177e4
LT		 905 case PCBIT_IOCTL_ENDLOAD:
906 if (dev->l2_state == L2_RUNNING)
907 return -EBUSY;
908 dev->l2_state = L2_DOWN;
475be4d8 909 break;
1da177e4 910
475be4d8 911 case PCBIT_IOCTL_SETBYTE:
1da177e4
LT		 912 if (dev->l2_state == L2_RUNNING)
913 return -EBUSY;
914
915 /* check addr */
916 if (cmd->info.rdp_byte.addr > BANK4)
917 return -EFAULT;
475be4d8 918
1da177e4
LT		 919 writeb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr);
920 break;
921 case PCBIT_IOCTL_GETBYTE:
922 if (dev->l2_state == L2_RUNNING)
923 return -EBUSY;
924
925 /* check addr */
926
927 if (cmd->info.rdp_byte.addr > BANK4)
928 {
929 printk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr);
930 return -EFAULT;
931 }
475be4d8
JP		 932
933 cmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr);
1da177e4 934 break;
475be4d8 935 case PCBIT_IOCTL_RUNNING:
1da177e4
LT		 936 if (dev->l2_state == L2_RUNNING)
937 return -EBUSY;
938 return set_protocol_running(dev);
939 break;
940 case PCBIT_IOCTL_WATCH188:
941 if (dev->l2_state != L2_LOADING)
942 return -EINVAL;
943 pcbit_l2_write(dev, MSG_WATCH188, 0x0001, NULL, 0);
944 break;
945 case PCBIT_IOCTL_PING188:
946 if (dev->l2_state != L2_LOADING)
947 return -EINVAL;
948 pcbit_l2_write(dev, MSG_PING188_REQ, 0x0001, NULL, 0);
949 break;
950 case PCBIT_IOCTL_APION:
951 if (dev->l2_state != L2_LOADING)
952 return -EINVAL;
953 pcbit_l2_write(dev, MSG_API_ON, 0x0001, NULL, 0);
954 break;
955 case PCBIT_IOCTL_STOP:
956 dev->l2_state = L2_DOWN;
957 writeb(0x40, dev->sh_mem + BANK4);
958 dev->rcv_seq = 0;
959 dev->send_seq = 0;
960 dev->unack_seq = 0;
961 break;
962 default:
963 printk("error: unknown ioctl\n");
964 break;
5c722af4 965 }
1da177e4
LT		 966 return 0;
967}
968
475be4d8 969/*
1da177e4
LT		 970 * MSN list handling
971 *
972 * if null reject all calls
475be4d8 973 * if first entry has null MSN accept all calls
1da177e4
LT		 974 */
975
976static void pcbit_clear_msn(struct pcbit_dev *dev)
977{
978 struct msn_entry *ptr, *back;
979
475be4d8 980 for (ptr = dev->msn_list; ptr;)
1da177e4
LT		 981 {
982 back = ptr->next;
983 kfree(ptr);
984 ptr = back;
985 }
986
475be4d8 987 dev->msn_list = NULL;
1da177e4
LT		 988}
989
990static void pcbit_set_msn(struct pcbit_dev *dev, char *list)
991{
992 struct msn_entry *ptr;
993 struct msn_entry *back = NULL;
994 char *cp, *sp;
995 int len;
996
997 if (strlen(list) == 0) {
998 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
999 if (!ptr) {
1000 printk(KERN_WARNING "kmalloc failed\n");
1001 return;
1002 }
1003
1004 ptr->msn = NULL;
1005
1006 ptr->next = dev->msn_list;
1007 dev->msn_list = ptr;
1008
1009 return;
1010 }
1011
1012 if (dev->msn_list)
475be4d8
JP		 1013 for (back = dev->msn_list; back->next; back = back->next);
1014
1da177e4
LT		 1015 sp = list;
1016
1017 do {
475be4d8 1018 cp = strchr(sp, ',');
1da177e4
LT		 1019 if (cp)
1020 len = cp - sp;
1021 else
1022 len = strlen(sp);
1023
1024 ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
1025
1026 if (!ptr) {
1027 printk(KERN_WARNING "kmalloc failed\n");
1028 return;
1029 }
1030 ptr->next = NULL;
475be4d8 1031
7bcc6738 1032 ptr->msn = kmalloc(len + 1, GFP_ATOMIC);
1da177e4
LT		 1033 if (!ptr->msn) {
1034 printk(KERN_WARNING "kmalloc failed\n");
1035 kfree(ptr);
1036 return;
1037 }
1038
7bcc6738 1039 memcpy(ptr->msn, sp, len);
1da177e4
LT		 1040 ptr->msn[len] = 0;
1041
1042#ifdef DEBUG
1043 printk(KERN_DEBUG "msn: %s\n", ptr->msn);
1044#endif
1045 if (dev->msn_list == NULL)
1046 dev->msn_list = ptr;
1047 else
1048 back->next = ptr;
1049 back = ptr;
1050 sp += len;
475be4d8 1051 } while (cp);
1da177e4
LT		 1052}
1053
1054/*
1055 * check if we do signal or reject an incoming call
1056 */
1057static int pcbit_check_msn(struct pcbit_dev *dev, char *msn)
1058{
1059 struct msn_entry *ptr;
1da177e4 1060
475be4d8
JP		 1061 for (ptr = dev->msn_list; ptr; ptr = ptr->next) {
1062
1063 if (ptr->msn == NULL)
1da177e4 1064 return 1;
475be4d8 1065
1da177e4
LT		 1066 if (strcmp(ptr->msn, msn) == 0)
1067 return 1;
1068 }
1069
1070 return 0;
1071}
Linux kernel - Deliverables
This page took 1.091065 seconds and 5 git commands to generate.