[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / hdlcdrv.h

/*
 * hdlcdrv.h  -- HDLC packet radio network driver.
 * The Linux soundcard driver for 1200 baud and 9600 baud packet radio
 * (C) 1996-1998 by Thomas Sailer, HB9JNX/AE4WA
 */
#ifndef _HDLCDRV_H
#define _HDLCDRV_H


#include <linux/netdevice.h>
#include <linux/if.h>
#include <linux/spinlock.h>
#include <uapi/linux/hdlcdrv.h>

#define HDLCDRV_MAGIC      0x5ac6e778
#define HDLCDRV_HDLCBUFFER  32 /* should be a power of 2 for speed reasons */
#define HDLCDRV_BITBUFFER  256 /* should be a power of 2 for speed reasons */
#undef HDLCDRV_LOOPBACK  /* define for HDLC debugging purposes */
#define HDLCDRV_DEBUG

/* maximum packet length, excluding CRC */
#define HDLCDRV_MAXFLEN             400	


struct hdlcdrv_hdlcbuffer {
	spinlock_t lock;
	unsigned rd, wr;
	unsigned short buf[HDLCDRV_HDLCBUFFER];
};

#ifdef HDLCDRV_DEBUG
struct hdlcdrv_bitbuffer {
	unsigned int rd;
	unsigned int wr;
	unsigned int shreg;
	unsigned char buffer[HDLCDRV_BITBUFFER];
};

static inline void hdlcdrv_add_bitbuffer(struct hdlcdrv_bitbuffer *buf, 
					 unsigned int bit)
{
	unsigned char new;

	new = buf->shreg & 1;
	buf->shreg >>= 1;
	buf->shreg |= (!!bit) << 7;
	if (new) {
		buf->buffer[buf->wr] = buf->shreg;
		buf->wr = (buf->wr+1) % sizeof(buf->buffer);
		buf->shreg = 0x80;
	}
}

static inline void hdlcdrv_add_bitbuffer_word(struct hdlcdrv_bitbuffer *buf, 
					      unsigned int bits)
{
	buf->buffer[buf->wr] = bits & 0xff;
	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
	buf->buffer[buf->wr] = (bits >> 8) & 0xff;
	buf->wr = (buf->wr+1) % sizeof(buf->buffer);

}
#endif /* HDLCDRV_DEBUG */

/* -------------------------------------------------------------------- */
/*
 * Information that need to be kept for each driver. 
 */

struct hdlcdrv_ops {
	/*
	 * first some informations needed by the hdlcdrv routines
	 */
	const char *drvname;
	const char *drvinfo;
	/*
	 * the routines called by the hdlcdrv routines
	 */
	int (*open)(struct net_device *);
	int (*close)(struct net_device *);
	int (*ioctl)(struct net_device *, struct ifreq *, 
		     struct hdlcdrv_ioctl *, int);
};

struct hdlcdrv_state {
	int magic;
	int opened;

	const struct hdlcdrv_ops *ops;

	struct {
		int bitrate;
	} par;

	struct hdlcdrv_pttoutput {
		int dma2;
		int seriobase;
		int pariobase;
		int midiiobase;
		unsigned int flags;
	} ptt_out;

	struct hdlcdrv_channel_params ch_params;

	struct hdlcdrv_hdlcrx {
		struct hdlcdrv_hdlcbuffer hbuf;
		unsigned long in_hdlc_rx;
		/* 0 = sync hunt, != 0 receiving */
		int rx_state;	
		unsigned int bitstream;
		unsigned int bitbuf;
		int numbits;
		unsigned char dcd;
		
		int len;
		unsigned char *bp;
		unsigned char buffer[HDLCDRV_MAXFLEN+2];
	} hdlcrx;

	struct hdlcdrv_hdlctx {
		struct hdlcdrv_hdlcbuffer hbuf;
		unsigned long in_hdlc_tx;
		/*
		 * 0 = send flags
		 * 1 = send txtail (flags)
		 * 2 = send packet
		 */
		int tx_state;	
		int numflags;
		unsigned int bitstream;
		unsigned char ptt;
		int calibrate;
		int slotcnt;

		unsigned int bitbuf;
		int numbits;
		
		int len;
		unsigned char *bp;
		unsigned char buffer[HDLCDRV_MAXFLEN+2];
	} hdlctx;

#ifdef HDLCDRV_DEBUG
	struct hdlcdrv_bitbuffer bitbuf_channel;
	struct hdlcdrv_bitbuffer bitbuf_hdlc;
#endif /* HDLCDRV_DEBUG */

	int ptt_keyed;

	/* queued skb for transmission */
	struct sk_buff *skb;
};


/* -------------------------------------------------------------------- */

static inline int hdlcdrv_hbuf_full(struct hdlcdrv_hdlcbuffer *hb) 
{
	unsigned long flags;
	int ret;
	
	spin_lock_irqsave(&hb->lock, flags);
	ret = !((HDLCDRV_HDLCBUFFER - 1 + hb->rd - hb->wr) % HDLCDRV_HDLCBUFFER);
	spin_unlock_irqrestore(&hb->lock, flags);
	return ret;
}

/* -------------------------------------------------------------------- */

static inline int hdlcdrv_hbuf_empty(struct hdlcdrv_hdlcbuffer *hb)
{
	unsigned long flags;
	int ret;
	
	spin_lock_irqsave(&hb->lock, flags);
	ret = (hb->rd == hb->wr);
	spin_unlock_irqrestore(&hb->lock, flags);
	return ret;
}

/* -------------------------------------------------------------------- */

static inline unsigned short hdlcdrv_hbuf_get(struct hdlcdrv_hdlcbuffer *hb)
{
	unsigned long flags;
	unsigned short val;
	unsigned newr;

	spin_lock_irqsave(&hb->lock, flags);
	if (hb->rd == hb->wr)
		val = 0;
	else {
		newr = (hb->rd+1) % HDLCDRV_HDLCBUFFER;
		val = hb->buf[hb->rd];
		hb->rd = newr;
	}
	spin_unlock_irqrestore(&hb->lock, flags);
	return val;
}

/* -------------------------------------------------------------------- */

static inline void hdlcdrv_hbuf_put(struct hdlcdrv_hdlcbuffer *hb, 
				    unsigned short val)
{
	unsigned newp;
	unsigned long flags;
	
	spin_lock_irqsave(&hb->lock, flags);
	newp = (hb->wr+1) % HDLCDRV_HDLCBUFFER;
	if (newp != hb->rd) { 
		hb->buf[hb->wr] = val & 0xffff;
		hb->wr = newp;
	}
	spin_unlock_irqrestore(&hb->lock, flags);
}

/* -------------------------------------------------------------------- */

static inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
{
	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
}

static inline unsigned int hdlcdrv_getbits(struct hdlcdrv_state *s)
{
	unsigned int ret;

	if (hdlcdrv_hbuf_empty(&s->hdlctx.hbuf)) {
		if (s->hdlctx.calibrate > 0)
			s->hdlctx.calibrate--;
		else
			s->hdlctx.ptt = 0;
		ret = 0;
	} else 
		ret = hdlcdrv_hbuf_get(&s->hdlctx.hbuf);
#ifdef HDLCDRV_LOOPBACK
	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, ret);
#endif /* HDLCDRV_LOOPBACK */
	return ret;
}

static inline void hdlcdrv_channelbit(struct hdlcdrv_state *s, unsigned int bit)
{
#ifdef HDLCDRV_DEBUG
	hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
#endif /* HDLCDRV_DEBUG */
}

static inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
{
	s->hdlcrx.dcd = !!dcd;
}

static inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
{
	return s->hdlctx.ptt || (s->hdlctx.calibrate > 0);
}

/* -------------------------------------------------------------------- */

void hdlcdrv_receiver(struct net_device *, struct hdlcdrv_state *);
void hdlcdrv_transmitter(struct net_device *, struct hdlcdrv_state *);
void hdlcdrv_arbitrate(struct net_device *, struct hdlcdrv_state *);
struct net_device *hdlcdrv_register(const struct hdlcdrv_ops *ops,
				    unsigned int privsize, const char *ifname,
				    unsigned int baseaddr, unsigned int irq, 
				    unsigned int dma);
void hdlcdrv_unregister(struct net_device *dev);

/* -------------------------------------------------------------------- */


#endif /* _HDLCDRV_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* hdlcdrv.h -- HDLC packet radio network driver.
	3	* The Linux soundcard driver for 1200 baud and 9600 baud packet radio
	4	* (C) 1996-1998 by Thomas Sailer, HB9JNX/AE4WA
	5	*/
1da177e4 LT	6	#ifndef _HDLCDRV_H
	7	#define _HDLCDRV_H
	8
1da177e4 LT	9
	10	#include <linux/netdevice.h>
	11	#include <linux/if.h>
	12	#include <linux/spinlock.h>
607ca46e	13	#include <uapi/linux/hdlcdrv.h>
1da177e4 LT	14
	15	#define HDLCDRV_MAGIC 0x5ac6e778
	16	#define HDLCDRV_HDLCBUFFER 32 /* should be a power of 2 for speed reasons */
	17	#define HDLCDRV_BITBUFFER 256 /* should be a power of 2 for speed reasons */
	18	#undef HDLCDRV_LOOPBACK /* define for HDLC debugging purposes */
	19	#define HDLCDRV_DEBUG
	20
	21	/* maximum packet length, excluding CRC */
	22	#define HDLCDRV_MAXFLEN 400
	23
	24
	25	struct hdlcdrv_hdlcbuffer {
	26	spinlock_t lock;
	27	unsigned rd, wr;
	28	unsigned short buf[HDLCDRV_HDLCBUFFER];
	29	};
	30
	31	#ifdef HDLCDRV_DEBUG
	32	struct hdlcdrv_bitbuffer {
	33	unsigned int rd;
	34	unsigned int wr;
	35	unsigned int shreg;
	36	unsigned char buffer[HDLCDRV_BITBUFFER];
	37	};
	38
	39	static inline void hdlcdrv_add_bitbuffer(struct hdlcdrv_bitbuffer *buf,
	40	unsigned int bit)
	41	{
	42	unsigned char new;
	43
	44	new = buf->shreg & 1;
	45	buf->shreg >>= 1;
	46	buf->shreg \|= (!!bit) << 7;
	47	if (new) {
	48	buf->buffer[buf->wr] = buf->shreg;
	49	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
	50	buf->shreg = 0x80;
	51	}
	52	}
	53
	54	static inline void hdlcdrv_add_bitbuffer_word(struct hdlcdrv_bitbuffer *buf,
	55	unsigned int bits)
	56	{
	57	buf->buffer[buf->wr] = bits & 0xff;
	58	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
	59	buf->buffer[buf->wr] = (bits >> 8) & 0xff;
	60	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
	61
	62	}
	63	#endif /* HDLCDRV_DEBUG */
	64
	65	/* -------------------------------------------------------------------- */
	66	/*
	67	* Information that need to be kept for each driver.
	68	*/
	69
	70	struct hdlcdrv_ops {
	71	/*
	72	* first some informations needed by the hdlcdrv routines
	73	*/
	74	const char *drvname;
	75	const char *drvinfo;
	76	/*
	77	* the routines called by the hdlcdrv routines
78	*/
79	int (open)(struct net_device );
80	int (close)(struct net_device );
81	int (ioctl)(struct net_device , struct ifreq *,
82	struct hdlcdrv_ioctl *, int);
83	};
84
85	struct hdlcdrv_state {
86	int magic;
87	int opened;
88
89	const struct hdlcdrv_ops *ops;
90
91	struct {
92	int bitrate;
93	} par;
94
95	struct hdlcdrv_pttoutput {
96	int dma2;
97	int seriobase;
98	int pariobase;
99	int midiiobase;
100	unsigned int flags;
101	} ptt_out;
102
103	struct hdlcdrv_channel_params ch_params;
104
105	struct hdlcdrv_hdlcrx {
106	struct hdlcdrv_hdlcbuffer hbuf;
64b33619	107	unsigned long in_hdlc_rx;
1da177e4 LT	108	/* 0 = sync hunt, != 0 receiving */
	109	int rx_state;
	110	unsigned int bitstream;
	111	unsigned int bitbuf;
	112	int numbits;
	113	unsigned char dcd;
	114
	115	int len;
	116	unsigned char *bp;
	117	unsigned char buffer[HDLCDRV_MAXFLEN+2];
	118	} hdlcrx;
	119
	120	struct hdlcdrv_hdlctx {
	121	struct hdlcdrv_hdlcbuffer hbuf;
886a63e8	122	unsigned long in_hdlc_tx;
1da177e4 LT	123	/*
	124	* 0 = send flags
	125	* 1 = send txtail (flags)
	126	* 2 = send packet
	127	*/
	128	int tx_state;
	129	int numflags;
	130	unsigned int bitstream;
	131	unsigned char ptt;
	132	int calibrate;
	133	int slotcnt;
	134
	135	unsigned int bitbuf;
	136	int numbits;
	137
	138	int len;
	139	unsigned char *bp;
	140	unsigned char buffer[HDLCDRV_MAXFLEN+2];
	141	} hdlctx;
	142
	143	#ifdef HDLCDRV_DEBUG
	144	struct hdlcdrv_bitbuffer bitbuf_channel;
	145	struct hdlcdrv_bitbuffer bitbuf_hdlc;
	146	#endif /* HDLCDRV_DEBUG */
	147
1da177e4 LT	148	int ptt_keyed;
	149
	150	/* queued skb for transmission */
	151	struct sk_buff *skb;
	152	};
	153
	154
	155	/* -------------------------------------------------------------------- */
	156
	157	static inline int hdlcdrv_hbuf_full(struct hdlcdrv_hdlcbuffer *hb)
	158	{
	159	unsigned long flags;
	160	int ret;
	161
	162	spin_lock_irqsave(&hb->lock, flags);
	163	ret = !((HDLCDRV_HDLCBUFFER - 1 + hb->rd - hb->wr) % HDLCDRV_HDLCBUFFER);
	164	spin_unlock_irqrestore(&hb->lock, flags);
	165	return ret;
	166	}
	167
	168	/* -------------------------------------------------------------------- */
	169
	170	static inline int hdlcdrv_hbuf_empty(struct hdlcdrv_hdlcbuffer *hb)
	171	{
	172	unsigned long flags;
	173	int ret;
	174
	175	spin_lock_irqsave(&hb->lock, flags);
	176	ret = (hb->rd == hb->wr);
	177	spin_unlock_irqrestore(&hb->lock, flags);
	178	return ret;
	179	}
	180
	181	/* -------------------------------------------------------------------- */
	182
	183	static inline unsigned short hdlcdrv_hbuf_get(struct hdlcdrv_hdlcbuffer *hb)
	184	{
	185	unsigned long flags;
	186	unsigned short val;
	187	unsigned newr;
	188
	189	spin_lock_irqsave(&hb->lock, flags);
	190	if (hb->rd == hb->wr)
	191	val = 0;
	192	else {
	193	newr = (hb->rd+1) % HDLCDRV_HDLCBUFFER;
	194	val = hb->buf[hb->rd];
	195	hb->rd = newr;
	196	}
	197	spin_unlock_irqrestore(&hb->lock, flags);
	198	return val;
	199	}
	200
	201	/* -------------------------------------------------------------------- */
	202
	203	static inline void hdlcdrv_hbuf_put(struct hdlcdrv_hdlcbuffer *hb,
	204	unsigned short val)
	205	{
	206	unsigned newp;
	207	unsigned long flags;
	208
	209	spin_lock_irqsave(&hb->lock, flags);
	210	newp = (hb->wr+1) % HDLCDRV_HDLCBUFFER;
	211	if (newp != hb->rd) {
212	hb->buf[hb->wr] = val & 0xffff;
213	hb->wr = newp;
214	}
215	spin_unlock_irqrestore(&hb->lock, flags);
216	}
217
218	/* -------------------------------------------------------------------- */
219
220	static inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
221	{
222	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
223	}
224
225	static inline unsigned int hdlcdrv_getbits(struct hdlcdrv_state *s)
226	{
227	unsigned int ret;
228
229	if (hdlcdrv_hbuf_empty(&s->hdlctx.hbuf)) {
230	if (s->hdlctx.calibrate > 0)
231	s->hdlctx.calibrate--;
232	else
233	s->hdlctx.ptt = 0;
234	ret = 0;
235	} else
236	ret = hdlcdrv_hbuf_get(&s->hdlctx.hbuf);
237	#ifdef HDLCDRV_LOOPBACK
238	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, ret);
239	#endif /* HDLCDRV_LOOPBACK */
240	return ret;
241	}
242
243	static inline void hdlcdrv_channelbit(struct hdlcdrv_state *s, unsigned int bit)
244	{
245	#ifdef HDLCDRV_DEBUG
246	hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
247	#endif /* HDLCDRV_DEBUG */
248	}
249
250	static inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
251	{
252	s->hdlcrx.dcd = !!dcd;
253	}
254
255	static inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
256	{
257	return s->hdlctx.ptt \|\| (s->hdlctx.calibrate > 0);
258	}
259
260	/* -------------------------------------------------------------------- */
261
262	void hdlcdrv_receiver(struct net_device , struct hdlcdrv_state );
263	void hdlcdrv_transmitter(struct net_device , struct hdlcdrv_state );
264	void hdlcdrv_arbitrate(struct net_device , struct hdlcdrv_state );
265	struct net_device hdlcdrv_register(const struct hdlcdrv_ops ops,
266	unsigned int privsize, const char *ifname,
267	unsigned int baseaddr, unsigned int irq,
268	unsigned int dma);
269	void hdlcdrv_unregister(struct net_device *dev);
270
271	/* -------------------------------------------------------------------- */
272
273
274
1da177e4	275	#endif /* _HDLCDRV_H */