File: /usr/src/linux/drivers/isdn/pcbit/layer2.c
1 /*
2 * Copyright (C) 1996 Universidade de Lisboa
3 *
4 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
5 *
6 * This software may be used and distributed according to the terms of
7 * the GNU General Public License, incorporated herein by reference.
8 */
9
10 /*
11 * 19991203 - Fernando Carvalho - takion@superbofh.org
12 * Hacked to compile with egcs and run with current version of isdn modules
13 */
14
15 /*
16 * PCBIT-D low-layer interface
17 */
18
19 /*
20 * Based on documentation provided by Inesc:
21 * - "Interface com bus do PC para o PCBIT e PCBIT-D", Inesc, Jan 93
22 */
23
24 /*
25 * TODO: better handling of errors
26 * re-write/remove debug printks
27 */
28
29 #define __NO_VERSION__
30
31
32 #ifdef MODULE
33 #define INCLUDE_INLINE_FUNCS
34 #endif
35
36
37 #include <linux/module.h>
38
39 #include <linux/sched.h>
40 #include <linux/string.h>
41 #include <linux/kernel.h>
42 #include <linux/types.h>
43 #include <linux/slab.h>
44 #include <linux/interrupt.h>
45 #include <linux/tqueue.h>
46 #include <linux/mm.h>
47 #include <linux/skbuff.h>
48
49 #include <linux/isdnif.h>
50
51 #include <asm/system.h>
52 #include <asm/io.h>
53
54
55 #include "pcbit.h"
56 #include "layer2.h"
57 #include "edss1.h"
58
59 #undef DEBUG_FRAG
60
61
62
63 /*
64 * task queue struct
65 */
66
67
68
69 /*
70 * Layer 3 packet demultiplexer
71 * drv.c
72 */
73
74 extern void pcbit_l3_receive(struct pcbit_dev *dev, ulong msg,
75 struct sk_buff *skb,
76 ushort hdr_len, ushort refnum);
77
78 /*
79 * Prototypes
80 */
81
82 void pcbit_deliver(void *data);
83 static void pcbit_transmit(struct pcbit_dev *dev);
84
85 static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack);
86
87 static void pcbit_l2_error(struct pcbit_dev *dev);
88 static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info);
89 static void pcbit_l2_err_recover(unsigned long data);
90
91 static void pcbit_firmware_bug(struct pcbit_dev *dev);
92
93 static __inline__ void
94 pcbit_sched_delivery(struct pcbit_dev *dev)
95 {
96 queue_task(&dev->qdelivery, &tq_immediate);
97 mark_bh(IMMEDIATE_BH);
98 }
99
100
101 /*
102 * Called from layer3
103 */
104
105 int
106 pcbit_l2_write(struct pcbit_dev *dev, ulong msg, ushort refnum,
107 struct sk_buff *skb, unsigned short hdr_len)
108 {
109 struct frame_buf *frame,
110 *ptr;
111 unsigned long flags;
112
113 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
114 dev_kfree_skb(skb);
115 return -1;
116 }
117 if ((frame = (struct frame_buf *) kmalloc(sizeof(struct frame_buf),
118 GFP_ATOMIC)) == NULL) {
119 printk(KERN_WARNING "pcbit_2_write: kmalloc failed\n");
120 dev_kfree_skb(skb);
121 return -1;
122 }
123 frame->msg = msg;
124 frame->refnum = refnum;
125 frame->copied = 0;
126 frame->hdr_len = hdr_len;
127
128 if (skb)
129 frame->dt_len = skb->len - hdr_len;
130 else
131 frame->dt_len = 0;
132
133 frame->skb = skb;
134
135 frame->next = NULL;
136
137 save_flags(flags);
138 cli();
139
140 if (dev->write_queue == NULL) {
141 dev->write_queue = frame;
142 restore_flags(flags);
143 pcbit_transmit(dev);
144 } else {
145 for (ptr = dev->write_queue; ptr->next; ptr = ptr->next);
146 ptr->next = frame;
147
148 restore_flags(flags);
149 }
150 return 0;
151 }
152
153 static __inline__ void
154 pcbit_tx_update(struct pcbit_dev *dev, ushort len)
155 {
156 u_char info;
157
158 dev->send_seq = (dev->send_seq + 1) % 8;
159
160 dev->fsize[dev->send_seq] = len;
161 info = 0;
162 info |= dev->rcv_seq << 3;
163 info |= dev->send_seq;
164
165 writeb(info, dev->sh_mem + BANK4);
166
167 }
168
169 /*
170 * called by interrupt service routine or by write_2
171 */
172
173 static void
174 pcbit_transmit(struct pcbit_dev *dev)
175 {
176 struct frame_buf *frame = NULL;
177 unsigned char unacked;
178 int flen; /* fragment frame length including all headers */
179 int free;
180 int count,
181 cp_len;
182 unsigned long flags;
183 unsigned short tt;
184
185 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
186 return;
187
188 unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07;
189
190 save_flags(flags);
191 cli();
192
193 if (dev->free > 16 && dev->write_queue && unacked < 7) {
194
195 if (!dev->w_busy)
196 dev->w_busy = 1;
197 else {
198 restore_flags(flags);
199 return;
200 }
201
202
203 frame = dev->write_queue;
204 free = dev->free;
205
206 restore_flags(flags);
207
208 if (frame->copied == 0) {
209
210 /* Type 0 frame */
211
212 ulong msg;
213
214 if (frame->skb)
215 flen = FRAME_HDR_LEN + PREHDR_LEN + frame->skb->len;
216 else
217 flen = FRAME_HDR_LEN + PREHDR_LEN;
218
219 if (flen > free)
220 flen = free;
221
222 msg = frame->msg;
223
224 /*
225 * Board level 2 header
226 */
227
228 pcbit_writew(dev, flen - FRAME_HDR_LEN);
229
230 pcbit_writeb(dev, GET_MSG_CPU(msg));
231
232 pcbit_writeb(dev, GET_MSG_PROC(msg));
233
234 /* TH */
235 pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
236
237 /* TD */
238 pcbit_writew(dev, frame->dt_len);
239
240
241 /*
242 * Board level 3 fixed-header
243 */
244
245 /* LEN = TH */
246 pcbit_writew(dev, frame->hdr_len + PREHDR_LEN);
247
248 /* XX */
249 pcbit_writew(dev, 0);
250
251 /* C + S */
252 pcbit_writeb(dev, GET_MSG_CMD(msg));
253 pcbit_writeb(dev, GET_MSG_SCMD(msg));
254
255 /* NUM */
256 pcbit_writew(dev, frame->refnum);
257
258 count = FRAME_HDR_LEN + PREHDR_LEN;
259 } else {
260 /* Type 1 frame */
261
262 flen = 2 + (frame->skb->len - frame->copied);
263
264 if (flen > free)
265 flen = free;
266
267 /* TT */
268 tt = ((ushort) (flen - 2)) | 0x8000U; /* Type 1 */
269 pcbit_writew(dev, tt);
270
271 count = 2;
272 }
273
274 if (frame->skb) {
275 cp_len = frame->skb->len - frame->copied;
276 if (cp_len > flen - count)
277 cp_len = flen - count;
278
279 memcpy_topcbit(dev, frame->skb->data + frame->copied,
280 cp_len);
281 frame->copied += cp_len;
282 }
283 /* bookkeeping */
284 dev->free -= flen;
285 pcbit_tx_update(dev, flen);
286
287 save_flags(flags);
288 cli();
289
290
291 if (frame->skb == NULL || frame->copied == frame->skb->len) {
292
293 dev->write_queue = frame->next;
294
295 if (frame->skb != NULL) {
296 /* free frame */
297 dev_kfree_skb(frame->skb);
298 }
299 kfree(frame);
300 }
301 dev->w_busy = 0;
302 restore_flags(flags);
303 } else {
304 restore_flags(flags);
305 #ifdef DEBUG
306 printk(KERN_DEBUG "unacked %d free %d write_queue %s\n",
307 unacked, dev->free, dev->write_queue ? "not empty" :
308 "empty");
309 #endif
310 }
311 }
312
313
314 /*
315 * deliver a queued frame to the upper layer
316 */
317
318 void
319 pcbit_deliver(void *data)
320 {
321 struct frame_buf *frame;
322 unsigned long flags, msg;
323 struct pcbit_dev *dev = (struct pcbit_dev *) data;
324
325 save_flags(flags);
326 cli();
327
328 while ((frame = dev->read_queue)) {
329 dev->read_queue = frame->next;
330 restore_flags(flags);
331
332 SET_MSG_CPU(msg, 0);
333 SET_MSG_PROC(msg, 0);
334 SET_MSG_CMD(msg, frame->skb->data[2]);
335 SET_MSG_SCMD(msg, frame->skb->data[3]);
336
337 frame->refnum = *((ushort *) frame->skb->data + 4);
338 frame->msg = *((ulong *) & msg);
339
340 skb_pull(frame->skb, 6);
341
342 pcbit_l3_receive(dev, frame->msg, frame->skb, frame->hdr_len,
343 frame->refnum);
344
345 kfree(frame);
346
347 save_flags(flags);
348 cli();
349 }
350
351 restore_flags(flags);
352 }
353
354 /*
355 * Reads BANK 2 & Reassembles
356 */
357
358 static void
359 pcbit_receive(struct pcbit_dev *dev)
360 {
361 unsigned short tt;
362 u_char cpu,
363 proc;
364 struct frame_buf *frame = NULL;
365 unsigned long flags;
366 u_char type1;
367
368 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING)
369 return;
370
371 tt = pcbit_readw(dev);
372
373 if ((tt & 0x7fffU) > 511) {
374 printk(KERN_INFO "pcbit: invalid frame length -> TT=%04x\n",
375 tt);
376 pcbit_l2_error(dev);
377 return;
378 }
379 if (!(tt & 0x8000U)) { /* Type 0 */
380 type1 = 0;
381
382 if (dev->read_frame) {
383 printk(KERN_DEBUG "pcbit_receive: Type 0 frame and read_frame != NULL\n");
384 /* discard previous queued frame */
385 if (dev->read_frame->skb)
386 kfree_skb(dev->read_frame->skb);
387 kfree(dev->read_frame);
388 dev->read_frame = NULL;
389 }
390 frame = kmalloc(sizeof(struct frame_buf), GFP_ATOMIC);
391
392 if (frame == NULL) {
393 printk(KERN_WARNING "kmalloc failed\n");
394 return;
395 }
396 memset(frame, 0, sizeof(struct frame_buf));
397
398 cpu = pcbit_readb(dev);
399 proc = pcbit_readb(dev);
400
401
402 if (cpu != 0x06 && cpu != 0x02) {
403 printk(KERN_DEBUG "pcbit: invalid cpu value\n");
404 kfree(frame);
405 pcbit_l2_error(dev);
406 return;
407 }
408 /*
409 * we discard cpu & proc on receiving
410 * but we read it to update the pointer
411 */
412
413 frame->hdr_len = pcbit_readw(dev);
414 frame->dt_len = pcbit_readw(dev);
415
416 /*
417 * 0 sized packet
418 * I don't know if they are an error or not...
419 * But they are very frequent
420 * Not documented
421 */
422
423 if (frame->hdr_len == 0) {
424 kfree(frame);
425 #ifdef DEBUG
426 printk(KERN_DEBUG "0 sized frame\n");
427 #endif
428 pcbit_firmware_bug(dev);
429 return;
430 }
431 /* sanity check the length values */
432 if (frame->hdr_len > 1024 || frame->dt_len > 2048) {
433 #ifdef DEBUG
434 printk(KERN_DEBUG "length problem: ");
435 printk(KERN_DEBUG "TH=%04x TD=%04x\n",
436 frame->hdr_len,
437 frame->dt_len);
438 #endif
439 pcbit_l2_error(dev);
440 kfree(frame);
441 return;
442 }
443 /* minimum frame read */
444
445 frame->skb = dev_alloc_skb(frame->hdr_len + frame->dt_len +
446 ((frame->hdr_len + 15) & ~15));
447
448 if (!frame->skb) {
449 printk(KERN_DEBUG "pcbit_receive: out of memory\n");
450 kfree(frame);
451 return;
452 }
453 /* 16 byte alignment for IP */
454 if (frame->dt_len)
455 skb_reserve(frame->skb, (frame->hdr_len + 15) & ~15);
456
457 } else {
458 /* Type 1 */
459 type1 = 1;
460 tt &= 0x7fffU;
461
462 if (!(frame = dev->read_frame)) {
463 printk("Type 1 frame and no frame queued\n");
464 /* usually after an error: toss frame */
465 dev->readptr += tt;
466 if (dev->readptr > dev->sh_mem + BANK2 + BANKLEN)
467 dev->readptr -= BANKLEN;
468 return;
469
470 }
471 }
472
473 memcpy_frompcbit(dev, skb_put(frame->skb, tt), tt);
474
475 frame->copied += tt;
476
477 if (frame->copied == frame->hdr_len + frame->dt_len) {
478
479 save_flags(flags);
480 cli();
481
482 if (type1) {
483 dev->read_frame = NULL;
484 }
485 if (dev->read_queue) {
486 struct frame_buf *ptr;
487 for (ptr = dev->read_queue; ptr->next; ptr = ptr->next);
488 ptr->next = frame;
489 } else
490 dev->read_queue = frame;
491
492 restore_flags(flags);
493
494 } else {
495 save_flags(flags);
496 cli();
497 dev->read_frame = frame;
498 restore_flags(flags);
499 }
500 }
501
502 /*
503 * The board sends 0 sized frames
504 * They are TDATA_CONFs that get messed up somehow
505 * gotta send a fake acknowledgment to the upper layer somehow
506 */
507
508 static __inline__ void
509 pcbit_fake_conf(struct pcbit_dev *dev, struct pcbit_chan *chan)
510 {
511 isdn_ctrl ictl;
512
513 if (chan->queued) {
514 chan->queued--;
515
516 ictl.driver = dev->id;
517 ictl.command = ISDN_STAT_BSENT;
518 ictl.arg = chan->id;
519 dev->dev_if->statcallb(&ictl);
520 }
521 }
522
523 static void
524 pcbit_firmware_bug(struct pcbit_dev *dev)
525 {
526 struct pcbit_chan *chan;
527
528 chan = dev->b1;
529
530 if (chan->fsm_state == ST_ACTIVE) {
531 pcbit_fake_conf(dev, chan);
532 }
533 chan = dev->b2;
534
535 if (chan->fsm_state == ST_ACTIVE) {
536 pcbit_fake_conf(dev, chan);
537 }
538 }
539
540 void
541 pcbit_irq_handler(int interrupt, void *devptr, struct pt_regs *regs)
542 {
543 struct pcbit_dev *dev;
544 u_char info,
545 ack_seq,
546 read_seq;
547
548 dev = (struct pcbit_dev *) devptr;
549
550 if (!dev) {
551 printk(KERN_WARNING "pcbit_irq_handler: wrong device\n");
552 return;
553 }
554 if (dev->interrupt) {
555 printk(KERN_DEBUG "pcbit: reentering interrupt hander\n");
556 return;
557 }
558 dev->interrupt = 1;
559
560 info = readb(dev->sh_mem + BANK3);
561
562 if (dev->l2_state == L2_STARTING || dev->l2_state == L2_ERROR) {
563 pcbit_l2_active_conf(dev, info);
564 dev->interrupt = 0;
565 return;
566 }
567 if (info & 0x40U) { /* E bit set */
568 #ifdef DEBUG
569 printk(KERN_DEBUG "pcbit_irq_handler: E bit on\n");
570 #endif
571 pcbit_l2_error(dev);
572 dev->interrupt = 0;
573 return;
574 }
575 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) {
576 dev->interrupt = 0;
577 return;
578 }
579 ack_seq = (info >> 3) & 0x07U;
580 read_seq = (info & 0x07U);
581
582 dev->interrupt = 0;
583
584 if (read_seq != dev->rcv_seq) {
585 while (read_seq != dev->rcv_seq) {
586 pcbit_receive(dev);
587 dev->rcv_seq = (dev->rcv_seq + 1) % 8;
588 }
589 pcbit_sched_delivery(dev);
590 }
591 if (ack_seq != dev->unack_seq) {
592 pcbit_recv_ack(dev, ack_seq);
593 }
594 info = dev->rcv_seq << 3;
595 info |= dev->send_seq;
596
597 writeb(info, dev->sh_mem + BANK4);
598 }
599
600
601 static void
602 pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info)
603 {
604 u_char state;
605
606 state = dev->l2_state;
607
608 #ifdef DEBUG
609 printk(KERN_DEBUG "layer2_active_confirm\n");
610 #endif
611
612
613 if (info & 0x80U) {
614 dev->rcv_seq = info & 0x07U;
615 dev->l2_state = L2_RUNNING;
616 } else
617 dev->l2_state = L2_DOWN;
618
619 if (state == L2_STARTING)
620 wake_up_interruptible(&dev->set_running_wq);
621
622 if (state == L2_ERROR && dev->l2_state == L2_RUNNING) {
623 pcbit_transmit(dev);
624 }
625 }
626
627 static void
628 pcbit_l2_err_recover(unsigned long data)
629 {
630
631 struct pcbit_dev *dev;
632 struct frame_buf *frame;
633
634 dev = (struct pcbit_dev *) data;
635
636 del_timer(&dev->error_recover_timer);
637 if (dev->w_busy || dev->r_busy) {
638 init_timer(&dev->error_recover_timer);
639 dev->error_recover_timer.expires = jiffies + ERRTIME;
640 add_timer(&dev->error_recover_timer);
641 return;
642 }
643 dev->w_busy = dev->r_busy = 1;
644
645 if (dev->read_frame) {
646 if (dev->read_frame->skb)
647 kfree_skb(dev->read_frame->skb);
648 kfree(dev->read_frame);
649 dev->read_frame = NULL;
650 }
651 if (dev->write_queue) {
652 frame = dev->write_queue;
653 #ifdef FREE_ON_ERROR
654 dev->write_queue = dev->write_queue->next;
655
656 if (frame->skb) {
657 dev_kfree_skb(frame->skb);
658 }
659 kfree(frame);
660 #else
661 frame->copied = 0;
662 #endif
663 }
664 dev->rcv_seq = dev->send_seq = dev->unack_seq = 0;
665 dev->free = 511;
666 dev->l2_state = L2_ERROR;
667
668 /* this is an hack... */
669 pcbit_firmware_bug(dev);
670
671 dev->writeptr = dev->sh_mem;
672 dev->readptr = dev->sh_mem + BANK2;
673
674 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
675 dev->sh_mem + BANK4);
676 dev->w_busy = dev->r_busy = 0;
677
678 }
679
680 static void
681 pcbit_l2_error(struct pcbit_dev *dev)
682 {
683 if (dev->l2_state == L2_RUNNING) {
684
685 printk(KERN_INFO "pcbit: layer 2 error\n");
686
687 #ifdef DEBUG
688 log_state(dev);
689 #endif
690
691 dev->l2_state = L2_DOWN;
692
693 init_timer(&dev->error_recover_timer);
694 dev->error_recover_timer.function = &pcbit_l2_err_recover;
695 dev->error_recover_timer.data = (ulong) dev;
696 dev->error_recover_timer.expires = jiffies + ERRTIME;
697 add_timer(&dev->error_recover_timer);
698 }
699 }
700
701 /*
702 * Description:
703 * if board acks frames
704 * update dev->free
705 * call pcbit_transmit to write possible queued frames
706 */
707
708 static void
709 pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack)
710 {
711 int i,
712 count;
713 int unacked;
714
715 unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07;
716
717 /* dev->unack_seq < ack <= dev->send_seq; */
718
719 if (unacked) {
720
721 if (dev->send_seq > dev->unack_seq) {
722 if (ack <= dev->unack_seq || ack > dev->send_seq) {
723 printk(KERN_DEBUG
724 "layer 2 ack unacceptable - dev %d",
725 dev->id);
726
727 pcbit_l2_error(dev);
728 } else if (ack > dev->send_seq && ack <= dev->unack_seq) {
729 printk(KERN_DEBUG
730 "layer 2 ack unacceptable - dev %d",
731 dev->id);
732 pcbit_l2_error(dev);
733 }
734 }
735 /* ack is acceptable */
736
737
738 i = dev->unack_seq;
739
740 do {
741 dev->unack_seq = i = (i + 1) % 8;
742 dev->free += dev->fsize[i];
743 } while (i != ack);
744
745 count = 0;
746 while (count < 7 && dev->write_queue) {
747 u8 lsend_seq = dev->send_seq;
748
749 pcbit_transmit(dev);
750
751 if (dev->send_seq == lsend_seq)
752 break;
753 count++;
754 }
755 } else
756 printk(KERN_DEBUG "recv_ack: unacked = 0\n");
757 }
758