Subversion Repositories or1k

/*
 * hdlcdrv.h  -- HDLC packet radio network driver.
 * The Linux soundcard driver for 1200 baud and 9600 baud packet radio
 * (C) 1996 by Thomas Sailer, HB9JNX/AE4WA
 */
 
#ifndef _HDLCDRV_H
#define _HDLCDRV_H
 
#include <linux/version.h>
#include <linux/sockios.h>
#include <linux/version.h>
#if LINUX_VERSION_CODE < 0x20119
#include <linux/if_ether.h>
#endif
#include <linux/netdevice.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;
#if LINUX_VERSION_CODE < 0x20100
  	struct enet_statistics stats;
#endif
};
 
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__
 
#define HDLCDRV_MAGIC      0x5ac6e778
#define HDLCDRV_IFNAMELEN    6
#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 {
	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];
};
 
extern 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;
	}
}
 
extern 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 device *);
	int (*close)(struct device *);
	int (*ioctl)(struct device *, struct ifreq *, 
		     struct hdlcdrv_ioctl *, int);
};
 
struct hdlcdrv_state {
	int magic;
 
	char ifname[HDLCDRV_IFNAMELEN];
 
	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;
		int 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;
		int 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 */
 
#if LINUX_VERSION_CODE < 0x20119
	struct enet_statistics stats;
#else
	struct net_device_stats stats;
#endif
	int ptt_keyed;
 
	struct sk_buff_head send_queue;  /* Packets awaiting transmission */
};
 
 
/* -------------------------------------------------------------------- */
 
extern inline int hdlcdrv_hbuf_full(struct hdlcdrv_hdlcbuffer *hb) 
{
	return !((HDLCDRV_HDLCBUFFER - 1 + hb->rd - hb->wr) 
		 % HDLCDRV_HDLCBUFFER);
}
 
/* -------------------------------------------------------------------- */
 
extern inline int hdlcdrv_hbuf_empty(struct hdlcdrv_hdlcbuffer *hb)
{
	return hb->rd == hb->wr;
}
 
/* -------------------------------------------------------------------- */
 
extern inline unsigned short hdlcdrv_hbuf_get(struct hdlcdrv_hdlcbuffer *hb)
{
	unsigned newr;
	unsigned short val;
	unsigned long flags;
 
	if (hb->rd == hb->wr)
		return 0;
	save_flags(flags);
	cli();
	newr = (hb->rd+1) % HDLCDRV_HDLCBUFFER;
	val = hb->buf[hb->rd];
	hb->rd = newr;
	restore_flags(flags);
	return val;
}
 
/* -------------------------------------------------------------------- */
 
extern inline void hdlcdrv_hbuf_put(struct hdlcdrv_hdlcbuffer *hb, 
				    unsigned short val)
{
	unsigned newp;
	unsigned long flags;
 
	save_flags(flags);
	cli();
	newp = (hb->wr+1) % HDLCDRV_HDLCBUFFER;
	if (newp != hb->rd) { 
		hb->buf[hb->wr] = val & 0xffff;
		hb->wr = newp;
	}
	restore_flags(flags);
}
 
/* -------------------------------------------------------------------- */
 
extern inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
{
	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
}
 
extern 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;
}
 
extern inline void hdlcdrv_channelbit(struct hdlcdrv_state *s, unsigned int bit)
{
#ifdef HDLCDRV_DEBUG
	hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
#endif /* HDLCDRV_DEBUG */
}
 
extern inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
{
	s->hdlcrx.dcd = !!dcd;
}
 
extern inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
{
	return s->hdlctx.ptt || (s->hdlctx.calibrate > 0);
}
 
/* -------------------------------------------------------------------- */
 
void hdlcdrv_receiver(struct device *, struct hdlcdrv_state *);
void hdlcdrv_transmitter(struct device *, struct hdlcdrv_state *);
void hdlcdrv_arbitrate(struct device *, struct hdlcdrv_state *);
int hdlcdrv_register_hdlcdrv(struct device *dev, const struct hdlcdrv_ops *ops,
			     unsigned int privsize, char *ifname,
			     unsigned int baseaddr, unsigned int irq, 
			     unsigned int dma);
int hdlcdrv_unregister_hdlcdrv(struct device *dev);
 
/* -------------------------------------------------------------------- */
 
 
 
#endif /* __KERNEL__ */
 
/* -------------------------------------------------------------------- */
 
#endif /* _HDLCDRV_H */
 
/* -------------------------------------------------------------------- */