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