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 */
6
7#ifndef _HDLCDRV_H
8#define _HDLCDRV_H
9
10/* -------------------------------------------------------------------- */
11/*
12 * structs for the IOCTL commands
13 */
14
15struct hdlcdrv_params {
16	int iobase;
17	int irq;
18	int dma;
19	int dma2;
20	int seriobase;
21	int pariobase;
22	int midiiobase;
23};
24
25struct hdlcdrv_channel_params {
26	int tx_delay;  /* the transmitter keyup delay in 10ms units */
27	int tx_tail;   /* the transmitter keyoff delay in 10ms units */
28	int slottime;  /* the slottime in 10ms; usually 10 = 100ms */
29	int ppersist;  /* the p-persistence 0..255 */
30	int fulldup;   /* some driver do not support full duplex, setting */
31	               /* this just makes them send even if DCD is on */
32};
33
34struct hdlcdrv_old_channel_state {
35  	int ptt;
36  	int dcd;
37  	int ptt_keyed;
38};
39
40struct hdlcdrv_channel_state {
41 	int ptt;
42 	int dcd;
43 	int ptt_keyed;
44 	unsigned long tx_packets;
45 	unsigned long tx_errors;
46 	unsigned long rx_packets;
47 	unsigned long rx_errors;
48};
49
50struct hdlcdrv_ioctl {
51	int cmd;
52	union {
53		struct hdlcdrv_params mp;
54		struct hdlcdrv_channel_params cp;
55		struct hdlcdrv_channel_state cs;
56		struct hdlcdrv_old_channel_state ocs;
57		unsigned int calibrate;
58		unsigned char bits;
59		char modename[128];
60		char drivername[32];
61	} data;
62};
63
64/* -------------------------------------------------------------------- */
65
66/*
67 * ioctl values
68 */
69#define HDLCDRVCTL_GETMODEMPAR       0
70#define HDLCDRVCTL_SETMODEMPAR       1
71#define HDLCDRVCTL_MODEMPARMASK      2  /* not handled by hdlcdrv */
72#define HDLCDRVCTL_GETCHANNELPAR    10
73#define HDLCDRVCTL_SETCHANNELPAR    11
74#define HDLCDRVCTL_OLDGETSTAT       20
75#define HDLCDRVCTL_CALIBRATE        21
76#define HDLCDRVCTL_GETSTAT          22
77
78/*
79 * these are mainly for debugging purposes
80 */
81#define HDLCDRVCTL_GETSAMPLES       30
82#define HDLCDRVCTL_GETBITS          31
83
84/*
85 * not handled by hdlcdrv, but by its depending drivers
86 */
87#define HDLCDRVCTL_GETMODE          40
88#define HDLCDRVCTL_SETMODE          41
89#define HDLCDRVCTL_MODELIST         42
90#define HDLCDRVCTL_DRIVERNAME       43
91
92/*
93 * mask of needed modem parameters, returned by HDLCDRVCTL_MODEMPARMASK
94 */
95#define HDLCDRV_PARMASK_IOBASE      (1<<0)
96#define HDLCDRV_PARMASK_IRQ         (1<<1)
97#define HDLCDRV_PARMASK_DMA         (1<<2)
98#define HDLCDRV_PARMASK_DMA2        (1<<3)
99#define HDLCDRV_PARMASK_SERIOBASE   (1<<4)
100#define HDLCDRV_PARMASK_PARIOBASE   (1<<5)
101#define HDLCDRV_PARMASK_MIDIIOBASE  (1<<6)
102
103/* -------------------------------------------------------------------- */
104
105#ifdef __KERNEL__
106
107#include <linux/netdevice.h>
108#include <linux/if.h>
109#include <linux/spinlock.h>
110
111#define HDLCDRV_MAGIC      0x5ac6e778
112#define HDLCDRV_HDLCBUFFER  32 /* should be a power of 2 for speed reasons */
113#define HDLCDRV_BITBUFFER  256 /* should be a power of 2 for speed reasons */
114#undef HDLCDRV_LOOPBACK  /* define for HDLC debugging purposes */
115#define HDLCDRV_DEBUG
116
117/* maximum packet length, excluding CRC */
118#define HDLCDRV_MAXFLEN             400
119
120
121struct hdlcdrv_hdlcbuffer {
122	spinlock_t lock;
123	unsigned rd, wr;
124	unsigned short buf[HDLCDRV_HDLCBUFFER];
125};
126
127#ifdef HDLCDRV_DEBUG
128struct hdlcdrv_bitbuffer {
129	unsigned int rd;
130	unsigned int wr;
131	unsigned int shreg;
132	unsigned char buffer[HDLCDRV_BITBUFFER];
133};
134
135static inline void hdlcdrv_add_bitbuffer(struct hdlcdrv_bitbuffer *buf,
136					 unsigned int bit)
137{
138	unsigned char new;
139
140	new = buf->shreg & 1;
141	buf->shreg >>= 1;
142	buf->shreg |= (!!bit) << 7;
143	if (new) {
144		buf->buffer[buf->wr] = buf->shreg;
145		buf->wr = (buf->wr+1) % sizeof(buf->buffer);
146		buf->shreg = 0x80;
147	}
148}
149
150static inline void hdlcdrv_add_bitbuffer_word(struct hdlcdrv_bitbuffer *buf,
151					      unsigned int bits)
152{
153	buf->buffer[buf->wr] = bits & 0xff;
154	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
155	buf->buffer[buf->wr] = (bits >> 8) & 0xff;
156	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
157
158}
159#endif /* HDLCDRV_DEBUG */
160
161/* -------------------------------------------------------------------- */
162/*
163 * Information that need to be kept for each driver.
164 */
165
166struct hdlcdrv_ops {
167	/*
168	 * first some informations needed by the hdlcdrv routines
169	 */
170	const char *drvname;
171	const char *drvinfo;
172	/*
173	 * the routines called by the hdlcdrv routines
174	 */
175	int (*open)(struct net_device *);
176	int (*close)(struct net_device *);
177	int (*ioctl)(struct net_device *, struct ifreq *,
178		     struct hdlcdrv_ioctl *, int);
179};
180
181struct hdlcdrv_state {
182	int magic;
183
184	const struct hdlcdrv_ops *ops;
185
186	struct {
187		int bitrate;
188	} par;
189
190	struct hdlcdrv_pttoutput {
191		int dma2;
192		int seriobase;
193		int pariobase;
194		int midiiobase;
195		unsigned int flags;
196	} ptt_out;
197
198	struct hdlcdrv_channel_params ch_params;
199
200	struct hdlcdrv_hdlcrx {
201		struct hdlcdrv_hdlcbuffer hbuf;
202		long in_hdlc_rx;
203		/* 0 = sync hunt, != 0 receiving */
204		int rx_state;
205		unsigned int bitstream;
206		unsigned int bitbuf;
207		int numbits;
208		unsigned char dcd;
209
210		int len;
211		unsigned char *bp;
212		unsigned char buffer[HDLCDRV_MAXFLEN+2];
213	} hdlcrx;
214
215	struct hdlcdrv_hdlctx {
216		struct hdlcdrv_hdlcbuffer hbuf;
217		int in_hdlc_tx;
218		/*
219		 * 0 = send flags
220		 * 1 = send txtail (flags)
221		 * 2 = send packet
222		 */
223		int tx_state;
224		int numflags;
225		unsigned int bitstream;
226		unsigned char ptt;
227		int calibrate;
228		int slotcnt;
229
230		unsigned int bitbuf;
231		int numbits;
232
233		int len;
234		unsigned char *bp;
235		unsigned char buffer[HDLCDRV_MAXFLEN+2];
236	} hdlctx;
237
238#ifdef HDLCDRV_DEBUG
239	struct hdlcdrv_bitbuffer bitbuf_channel;
240	struct hdlcdrv_bitbuffer bitbuf_hdlc;
241#endif /* HDLCDRV_DEBUG */
242
243	struct net_device_stats stats;
244	int ptt_keyed;
245
246	/* queued skb for transmission */
247	struct sk_buff *skb;
248};
249
250
251/* -------------------------------------------------------------------- */
252
253static inline int hdlcdrv_hbuf_full(struct hdlcdrv_hdlcbuffer *hb)
254{
255	unsigned long flags;
256	int ret;
257
258	spin_lock_irqsave(&hb->lock, flags);
259	ret = !((HDLCDRV_HDLCBUFFER - 1 + hb->rd - hb->wr) % HDLCDRV_HDLCBUFFER);
260	spin_unlock_irqrestore(&hb->lock, flags);
261	return ret;
262}
263
264/* -------------------------------------------------------------------- */
265
266static inline int hdlcdrv_hbuf_empty(struct hdlcdrv_hdlcbuffer *hb)
267{
268	unsigned long flags;
269	int ret;
270
271	spin_lock_irqsave(&hb->lock, flags);
272	ret = (hb->rd == hb->wr);
273	spin_unlock_irqrestore(&hb->lock, flags);
274	return ret;
275}
276
277/* -------------------------------------------------------------------- */
278
279static inline unsigned short hdlcdrv_hbuf_get(struct hdlcdrv_hdlcbuffer *hb)
280{
281	unsigned long flags;
282	unsigned short val;
283	unsigned newr;
284
285	spin_lock_irqsave(&hb->lock, flags);
286	if (hb->rd == hb->wr)
287		val = 0;
288	else {
289		newr = (hb->rd+1) % HDLCDRV_HDLCBUFFER;
290		val = hb->buf[hb->rd];
291		hb->rd = newr;
292	}
293	spin_unlock_irqrestore(&hb->lock, flags);
294	return val;
295}
296
297/* -------------------------------------------------------------------- */
298
299static inline void hdlcdrv_hbuf_put(struct hdlcdrv_hdlcbuffer *hb,
300				    unsigned short val)
301{
302	unsigned newp;
303	unsigned long flags;
304
305	spin_lock_irqsave(&hb->lock, flags);
306	newp = (hb->wr+1) % HDLCDRV_HDLCBUFFER;
307	if (newp != hb->rd) {
308		hb->buf[hb->wr] = val & 0xffff;
309		hb->wr = newp;
310	}
311	spin_unlock_irqrestore(&hb->lock, flags);
312}
313
314/* -------------------------------------------------------------------- */
315
316static inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
317{
318	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
319}
320
321static inline unsigned int hdlcdrv_getbits(struct hdlcdrv_state *s)
322{
323	unsigned int ret;
324
325	if (hdlcdrv_hbuf_empty(&s->hdlctx.hbuf)) {
326		if (s->hdlctx.calibrate > 0)
327			s->hdlctx.calibrate--;
328		else
329			s->hdlctx.ptt = 0;
330		ret = 0;
331	} else
332		ret = hdlcdrv_hbuf_get(&s->hdlctx.hbuf);
333#ifdef HDLCDRV_LOOPBACK
334	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, ret);
335#endif /* HDLCDRV_LOOPBACK */
336	return ret;
337}
338
339static inline void hdlcdrv_channelbit(struct hdlcdrv_state *s, unsigned int bit)
340{
341#ifdef HDLCDRV_DEBUG
342	hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
343#endif /* HDLCDRV_DEBUG */
344}
345
346static inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
347{
348	s->hdlcrx.dcd = !!dcd;
349}
350
351static inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
352{
353	return s->hdlctx.ptt || (s->hdlctx.calibrate > 0);
354}
355
356/* -------------------------------------------------------------------- */
357
358void hdlcdrv_receiver(struct net_device *, struct hdlcdrv_state *);
359void hdlcdrv_transmitter(struct net_device *, struct hdlcdrv_state *);
360void hdlcdrv_arbitrate(struct net_device *, struct hdlcdrv_state *);
361int hdlcdrv_register_hdlcdrv(struct net_device *dev, const struct hdlcdrv_ops *ops,
362			     unsigned int privsize, char *ifname,
363			     unsigned int baseaddr, unsigned int irq,
364			     unsigned int dma);
365int hdlcdrv_unregister_hdlcdrv(struct net_device *dev);
366
367/* -------------------------------------------------------------------- */
368
369
370
371#endif /* __KERNEL__ */
372
373/* -------------------------------------------------------------------- */
374
375#endif /* _HDLCDRV_H */
376
377/* -------------------------------------------------------------------- */
378