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