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/slab.h>
31#include <linux/interrupt.h>
32#include <linux/workqueue.h>
33#include <linux/mm.h>
34#include <linux/skbuff.h>
35
36#include <linux/isdnif.h>
37
38#include <asm/system.h>
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
53static void pcbit_transmit(struct pcbit_dev *dev);
54
55static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack);
56
57static void pcbit_l2_error(struct pcbit_dev *dev);
58static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info);
59static void pcbit_l2_err_recover(unsigned long data);
60
61static void pcbit_firmware_bug(struct pcbit_dev *dev);
62
63static __inline__ void
64pcbit_sched_delivery(struct pcbit_dev *dev)
65{
66	schedule_work(&dev->qdelivery);
67}
68
69
70/*
71 *  Called from layer3
72 */
73
74int
75pcbit_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
121static __inline__ void
122pcbit_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
141static void
142pcbit_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
283void
284pcbit_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
323static void
324pcbit_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			if (dev->read_frame->skb)
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
465static __inline__ void
466pcbit_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
480static void
481pcbit_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
497irqreturn_t
498pcbit_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
559static void
560pcbit_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
585static void
586pcbit_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		if (dev->read_frame->skb)
605			kfree_skb(dev->read_frame->skb);
606		kfree(dev->read_frame);
607		dev->read_frame = NULL;
608	}
609	if (dev->write_queue) {
610		frame = dev->write_queue;
611#ifdef FREE_ON_ERROR
612		dev->write_queue = dev->write_queue->next;
613
614		if (frame->skb) {
615			dev_kfree_skb(frame->skb);
616		}
617		kfree(frame);
618#else
619		frame->copied = 0;
620#endif
621	}
622	dev->rcv_seq = dev->send_seq = dev->unack_seq = 0;
623	dev->free = 511;
624	dev->l2_state = L2_ERROR;
625
626	/* this is an hack... */
627	pcbit_firmware_bug(dev);
628
629	dev->writeptr = dev->sh_mem;
630	dev->readptr = dev->sh_mem + BANK2;
631
632	writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
633	       dev->sh_mem + BANK4);
634	dev->w_busy = dev->r_busy = 0;
635
636}
637
638static void
639pcbit_l2_error(struct pcbit_dev *dev)
640{
641	if (dev->l2_state == L2_RUNNING) {
642
643		printk(KERN_INFO "pcbit: layer 2 error\n");
644
645#ifdef DEBUG
646		log_state(dev);
647#endif
648
649		dev->l2_state = L2_DOWN;
650
651		init_timer(&dev->error_recover_timer);
652		dev->error_recover_timer.function = &pcbit_l2_err_recover;
653		dev->error_recover_timer.data = (ulong) dev;
654		dev->error_recover_timer.expires = jiffies + ERRTIME;
655		add_timer(&dev->error_recover_timer);
656	}
657}
658
659/*
660 * Description:
661 * if board acks frames
662 *   update dev->free
663 *   call pcbit_transmit to write possible queued frames
664 */
665
666static void
667pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack)
668{
669	int i,
670	 count;
671	int unacked;
672
673	unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07;
674
675	/* dev->unack_seq < ack <= dev->send_seq; */
676
677	if (unacked) {
678
679		if (dev->send_seq > dev->unack_seq) {
680			if (ack <= dev->unack_seq || ack > dev->send_seq) {
681				printk(KERN_DEBUG
682				     "layer 2 ack unacceptable - dev %d",
683				       dev->id);
684
685				pcbit_l2_error(dev);
686			} else if (ack > dev->send_seq && ack <= dev->unack_seq) {
687				printk(KERN_DEBUG
688				     "layer 2 ack unacceptable - dev %d",
689				       dev->id);
690				pcbit_l2_error(dev);
691			}
692		}
693		/* ack is acceptable */
694
695
696		i = dev->unack_seq;
697
698		do {
699			dev->unack_seq = i = (i + 1) % 8;
700			dev->free += dev->fsize[i];
701		} while (i != ack);
702
703		count = 0;
704		while (count < 7 && dev->write_queue) {
705			u8 lsend_seq = dev->send_seq;
706
707			pcbit_transmit(dev);
708
709			if (dev->send_seq == lsend_seq)
710				break;
711			count++;
712		}
713	} else
714		printk(KERN_DEBUG "recv_ack: unacked = 0\n");
715}
716