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