[net-next-2.6.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

/* -------------------------------------------------------------------- */
/*
 * structs for the IOCTL commands
 */

struct hdlcdrv_params {
	int iobase;
	int irq;
	int dma;
	int dma2;
	int seriobase;
	int pariobase;
	int midiiobase;
};	

struct hdlcdrv_channel_params {
	int tx_delay;  /* the transmitter keyup delay in 10ms units */
	int tx_tail;   /* the transmitter keyoff delay in 10ms units */
	int slottime;  /* the slottime in 10ms; usually 10 = 100ms */
	int ppersist;  /* the p-persistence 0..255 */
	int fulldup;   /* some driver do not support full duplex, setting */
	               /* this just makes them send even if DCD is on */
};	

struct hdlcdrv_old_channel_state {
  	int ptt;
  	int dcd;
  	int ptt_keyed;
};

struct hdlcdrv_channel_state {
 	int ptt;
 	int dcd;
 	int ptt_keyed;
 	unsigned long tx_packets;
 	unsigned long tx_errors;
 	unsigned long rx_packets;
 	unsigned long rx_errors;
};

struct hdlcdrv_ioctl {
	int cmd;
	union {
		struct hdlcdrv_params mp;
		struct hdlcdrv_channel_params cp;
		struct hdlcdrv_channel_state cs;
		struct hdlcdrv_old_channel_state ocs;
		unsigned int calibrate;
		unsigned char bits;
		char modename[128];
		char drivername[32];
	} data;
};

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

/*
 * ioctl values
 */
#define HDLCDRVCTL_GETMODEMPAR       0
#define HDLCDRVCTL_SETMODEMPAR       1
#define HDLCDRVCTL_MODEMPARMASK      2  /* not handled by hdlcdrv */
#define HDLCDRVCTL_GETCHANNELPAR    10
#define HDLCDRVCTL_SETCHANNELPAR    11
#define HDLCDRVCTL_OLDGETSTAT       20
#define HDLCDRVCTL_CALIBRATE        21
#define HDLCDRVCTL_GETSTAT          22

/*
 * these are mainly for debugging purposes
 */
#define HDLCDRVCTL_GETSAMPLES       30
#define HDLCDRVCTL_GETBITS          31

/*
 * not handled by hdlcdrv, but by its depending drivers
 */
#define HDLCDRVCTL_GETMODE          40
#define HDLCDRVCTL_SETMODE          41
#define HDLCDRVCTL_MODELIST         42
#define HDLCDRVCTL_DRIVERNAME       43

/*
 * mask of needed modem parameters, returned by HDLCDRVCTL_MODEMPARMASK
 */
#define HDLCDRV_PARMASK_IOBASE      (1<<0)
#define HDLCDRV_PARMASK_IRQ         (1<<1)
#define HDLCDRV_PARMASK_DMA         (1<<2)
#define HDLCDRV_PARMASK_DMA2        (1<<3)
#define HDLCDRV_PARMASK_SERIOBASE   (1<<4)
#define HDLCDRV_PARMASK_PARIOBASE   (1<<5)
#define HDLCDRV_PARMASK_MIDIIOBASE  (1<<6)

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

#ifdef __KERNEL__

#include <linux/netdevice.h>
#include <linux/if.h>
#include <linux/spinlock.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 /* __KERNEL__ */

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

#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	*/
	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;
64b33619	203	unsigned long in_hdlc_rx;
1da177e4 LT	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;
886a63e8	218	unsigned long in_hdlc_tx;
1da177e4 LT	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
1da177e4 LT	244	int ptt_keyed;
	245
	246	/* queued skb for transmission */
	247	struct sk_buff *skb;
	248	};
	249
	250
	251	/* -------------------------------------------------------------------- */
	252
	253	static 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
	266	static 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
	279	static 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
	299	static 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
316	static inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
317	{
318	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
319	}
320
321	static 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
339	static 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
346	static inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
347	{
348	s->hdlcrx.dcd = !!dcd;
349	}
350
351	static inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
352	{
353	return s->hdlctx.ptt \|\| (s->hdlctx.calibrate > 0);
354	}
355
356	/* -------------------------------------------------------------------- */
357
358	void hdlcdrv_receiver(struct net_device , struct hdlcdrv_state );
359	void hdlcdrv_transmitter(struct net_device , struct hdlcdrv_state );
360	void hdlcdrv_arbitrate(struct net_device , struct hdlcdrv_state );
361	struct net_device hdlcdrv_register(const struct hdlcdrv_ops ops,
362	unsigned int privsize, const char *ifname,
363	unsigned int baseaddr, unsigned int irq,
364	unsigned int dma);
365	void hdlcdrv_unregister(struct net_device *dev);
366
367	/* -------------------------------------------------------------------- */
368
369
370
371	#endif /* __KERNEL__ */
372
373	/* -------------------------------------------------------------------- */
374
375	#endif /* _HDLCDRV_H */
376
377	/* -------------------------------------------------------------------- */