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