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