Merge branch 'x86-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.git] / include / linux / hdlcdrv.h
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
15 struct 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
25 struct 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
34 struct hdlcdrv_old_channel_state {
35         int ptt;
36         int dcd;
37         int ptt_keyed;
38 };
39
40 struct 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
50 struct 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
121 struct hdlcdrv_hdlcbuffer {
122         spinlock_t lock;
123         unsigned rd, wr;
124         unsigned short buf[HDLCDRV_HDLCBUFFER];
125 };
126
127 #ifdef HDLCDRV_DEBUG
128 struct hdlcdrv_bitbuffer {
129         unsigned int rd;
130         unsigned int wr;
131         unsigned int shreg;
132         unsigned char buffer[HDLCDRV_BITBUFFER];
133 };
134
135 static 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
150 static 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
166 struct 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
181 struct hdlcdrv_state {
182         int magic;
183         int opened;
184
185         const struct hdlcdrv_ops *ops;
186
187         struct {
188                 int bitrate;
189         } par;
190
191         struct hdlcdrv_pttoutput {
192                 int dma2;
193                 int seriobase;
194                 int pariobase;
195                 int midiiobase;
196                 unsigned int flags;
197         } ptt_out;
198
199         struct hdlcdrv_channel_params ch_params;
200
201         struct hdlcdrv_hdlcrx {
202                 struct hdlcdrv_hdlcbuffer hbuf;
203                 unsigned long in_hdlc_rx;
204                 /* 0 = sync hunt, != 0 receiving */
205                 int rx_state;   
206                 unsigned int bitstream;
207                 unsigned int bitbuf;
208                 int numbits;
209                 unsigned char dcd;
210                 
211                 int len;
212                 unsigned char *bp;
213                 unsigned char buffer[HDLCDRV_MAXFLEN+2];
214         } hdlcrx;
215
216         struct hdlcdrv_hdlctx {
217                 struct hdlcdrv_hdlcbuffer hbuf;
218                 long in_hdlc_tx;
219                 /*
220                  * 0 = send flags
221                  * 1 = send txtail (flags)
222                  * 2 = send packet
223                  */
224                 int tx_state;   
225                 int numflags;
226                 unsigned int bitstream;
227                 unsigned char ptt;
228                 int calibrate;
229                 int slotcnt;
230
231                 unsigned int bitbuf;
232                 int numbits;
233                 
234                 int len;
235                 unsigned char *bp;
236                 unsigned char buffer[HDLCDRV_MAXFLEN+2];
237         } hdlctx;
238
239 #ifdef HDLCDRV_DEBUG
240         struct hdlcdrv_bitbuffer bitbuf_channel;
241         struct hdlcdrv_bitbuffer bitbuf_hdlc;
242 #endif /* HDLCDRV_DEBUG */
243
244         struct net_device_stats stats;
245         int ptt_keyed;
246
247         /* queued skb for transmission */
248         struct sk_buff *skb;
249 };
250
251
252 /* -------------------------------------------------------------------- */
253
254 static inline int hdlcdrv_hbuf_full(struct hdlcdrv_hdlcbuffer *hb) 
255 {
256         unsigned long flags;
257         int ret;
258         
259         spin_lock_irqsave(&hb->lock, flags);
260         ret = !((HDLCDRV_HDLCBUFFER - 1 + hb->rd - hb->wr) % HDLCDRV_HDLCBUFFER);
261         spin_unlock_irqrestore(&hb->lock, flags);
262         return ret;
263 }
264
265 /* -------------------------------------------------------------------- */
266
267 static inline int hdlcdrv_hbuf_empty(struct hdlcdrv_hdlcbuffer *hb)
268 {
269         unsigned long flags;
270         int ret;
271         
272         spin_lock_irqsave(&hb->lock, flags);
273         ret = (hb->rd == hb->wr);
274         spin_unlock_irqrestore(&hb->lock, flags);
275         return ret;
276 }
277
278 /* -------------------------------------------------------------------- */
279
280 static inline unsigned short hdlcdrv_hbuf_get(struct hdlcdrv_hdlcbuffer *hb)
281 {
282         unsigned long flags;
283         unsigned short val;
284         unsigned newr;
285
286         spin_lock_irqsave(&hb->lock, flags);
287         if (hb->rd == hb->wr)
288                 val = 0;
289         else {
290                 newr = (hb->rd+1) % HDLCDRV_HDLCBUFFER;
291                 val = hb->buf[hb->rd];
292                 hb->rd = newr;
293         }
294         spin_unlock_irqrestore(&hb->lock, flags);
295         return val;
296 }
297
298 /* -------------------------------------------------------------------- */
299
300 static inline void hdlcdrv_hbuf_put(struct hdlcdrv_hdlcbuffer *hb, 
301                                     unsigned short val)
302 {
303         unsigned newp;
304         unsigned long flags;
305         
306         spin_lock_irqsave(&hb->lock, flags);
307         newp = (hb->wr+1) % HDLCDRV_HDLCBUFFER;
308         if (newp != hb->rd) { 
309                 hb->buf[hb->wr] = val & 0xffff;
310                 hb->wr = newp;
311         }
312         spin_unlock_irqrestore(&hb->lock, flags);
313 }
314
315 /* -------------------------------------------------------------------- */
316
317 static inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
318 {
319         hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
320 }
321
322 static inline unsigned int hdlcdrv_getbits(struct hdlcdrv_state *s)
323 {
324         unsigned int ret;
325
326         if (hdlcdrv_hbuf_empty(&s->hdlctx.hbuf)) {
327                 if (s->hdlctx.calibrate > 0)
328                         s->hdlctx.calibrate--;
329                 else
330                         s->hdlctx.ptt = 0;
331                 ret = 0;
332         } else 
333                 ret = hdlcdrv_hbuf_get(&s->hdlctx.hbuf);
334 #ifdef HDLCDRV_LOOPBACK
335         hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, ret);
336 #endif /* HDLCDRV_LOOPBACK */
337         return ret;
338 }
339
340 static inline void hdlcdrv_channelbit(struct hdlcdrv_state *s, unsigned int bit)
341 {
342 #ifdef HDLCDRV_DEBUG
343         hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
344 #endif /* HDLCDRV_DEBUG */
345 }
346
347 static inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
348 {
349         s->hdlcrx.dcd = !!dcd;
350 }
351
352 static inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
353 {
354         return s->hdlctx.ptt || (s->hdlctx.calibrate > 0);
355 }
356
357 /* -------------------------------------------------------------------- */
358
359 void hdlcdrv_receiver(struct net_device *, struct hdlcdrv_state *);
360 void hdlcdrv_transmitter(struct net_device *, struct hdlcdrv_state *);
361 void hdlcdrv_arbitrate(struct net_device *, struct hdlcdrv_state *);
362 struct net_device *hdlcdrv_register(const struct hdlcdrv_ops *ops,
363                                     unsigned int privsize, const char *ifname,
364                                     unsigned int baseaddr, unsigned int irq, 
365                                     unsigned int dma);
366 void hdlcdrv_unregister(struct net_device *dev);
367
368 /* -------------------------------------------------------------------- */
369
370
371
372 #endif /* __KERNEL__ */
373
374 /* -------------------------------------------------------------------- */
375
376 #endif /* _HDLCDRV_H */
377
378 /* -------------------------------------------------------------------- */