Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hdlcdrv.h
Go to the documentation of this file.
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 #ifndef _HDLCDRV_H
7 #define _HDLCDRV_H
8 
9 
10 #include <linux/netdevice.h>
11 #include <linux/if.h>
12 #include <linux/spinlock.h>
13 #include <uapi/linux/hdlcdrv.h>
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 
27  unsigned rd, wr;
28  unsigned short buf[HDLCDRV_HDLCBUFFER];
29 };
30 
31 #ifdef HDLCDRV_DEBUG
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 
96  int dma2;
97  int seriobase;
98  int pariobase;
100  unsigned int flags;
101  } ptt_out;
102 
104 
105  struct hdlcdrv_hdlcrx {
107  unsigned long in_hdlc_rx;
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 {
122  unsigned long in_hdlc_tx;
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;
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
146 #endif /* HDLCDRV_DEBUG */
147 
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 
275 #endif /* _HDLCDRV_H */