cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

hdlcdrv.h (6468B)


      1/* SPDX-License-Identifier: GPL-2.0 */
      2/*
      3 * hdlcdrv.h  -- HDLC packet radio network driver.
      4 * The Linux soundcard driver for 1200 baud and 9600 baud packet radio
      5 * (C) 1996-1998 by Thomas Sailer, HB9JNX/AE4WA
      6 */
      7#ifndef _HDLCDRV_H
      8#define _HDLCDRV_H
      9
     10
     11#include <linux/netdevice.h>
     12#include <linux/if.h>
     13#include <linux/spinlock.h>
     14#include <uapi/linux/hdlcdrv.h>
     15
     16#define HDLCDRV_MAGIC      0x5ac6e778
     17#define HDLCDRV_HDLCBUFFER  32 /* should be a power of 2 for speed reasons */
     18#define HDLCDRV_BITBUFFER  256 /* should be a power of 2 for speed reasons */
     19#undef HDLCDRV_LOOPBACK  /* define for HDLC debugging purposes */
     20#define HDLCDRV_DEBUG
     21
     22/* maximum packet length, excluding CRC */
     23#define HDLCDRV_MAXFLEN             400	
     24
     25
     26struct hdlcdrv_hdlcbuffer {
     27	spinlock_t lock;
     28	unsigned rd, wr;
     29	unsigned short buf[HDLCDRV_HDLCBUFFER];
     30};
     31
     32#ifdef HDLCDRV_DEBUG
     33struct hdlcdrv_bitbuffer {
     34	unsigned int rd;
     35	unsigned int wr;
     36	unsigned int shreg;
     37	unsigned char buffer[HDLCDRV_BITBUFFER];
     38};
     39
     40static inline void hdlcdrv_add_bitbuffer(struct hdlcdrv_bitbuffer *buf, 
     41					 unsigned int bit)
     42{
     43	unsigned char new;
     44
     45	new = buf->shreg & 1;
     46	buf->shreg >>= 1;
     47	buf->shreg |= (!!bit) << 7;
     48	if (new) {
     49		buf->buffer[buf->wr] = buf->shreg;
     50		buf->wr = (buf->wr+1) % sizeof(buf->buffer);
     51		buf->shreg = 0x80;
     52	}
     53}
     54
     55static inline void hdlcdrv_add_bitbuffer_word(struct hdlcdrv_bitbuffer *buf, 
     56					      unsigned int bits)
     57{
     58	buf->buffer[buf->wr] = bits & 0xff;
     59	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
     60	buf->buffer[buf->wr] = (bits >> 8) & 0xff;
     61	buf->wr = (buf->wr+1) % sizeof(buf->buffer);
     62
     63}
     64#endif /* HDLCDRV_DEBUG */
     65
     66/* -------------------------------------------------------------------- */
     67/*
     68 * Information that need to be kept for each driver. 
     69 */
     70
     71struct hdlcdrv_ops {
     72	/*
     73	 * first some informations needed by the hdlcdrv routines
     74	 */
     75	const char *drvname;
     76	const char *drvinfo;
     77	/*
     78	 * the routines called by the hdlcdrv routines
     79	 */
     80	int (*open)(struct net_device *);
     81	int (*close)(struct net_device *);
     82	int (*ioctl)(struct net_device *, void __user *,
     83		     struct hdlcdrv_ioctl *, int);
     84};
     85
     86struct hdlcdrv_state {
     87	int magic;
     88	int opened;
     89
     90	const struct hdlcdrv_ops *ops;
     91
     92	struct {
     93		int bitrate;
     94	} par;
     95
     96	struct hdlcdrv_pttoutput {
     97		int dma2;
     98		int seriobase;
     99		int pariobase;
    100		int midiiobase;
    101		unsigned int flags;
    102	} ptt_out;
    103
    104	struct hdlcdrv_channel_params ch_params;
    105
    106	struct hdlcdrv_hdlcrx {
    107		struct hdlcdrv_hdlcbuffer hbuf;
    108		unsigned long in_hdlc_rx;
    109		/* 0 = sync hunt, != 0 receiving */
    110		int rx_state;	
    111		unsigned int bitstream;
    112		unsigned int bitbuf;
    113		int numbits;
    114		unsigned char dcd;
    115		
    116		int len;
    117		unsigned char *bp;
    118		unsigned char buffer[HDLCDRV_MAXFLEN+2];
    119	} hdlcrx;
    120
    121	struct hdlcdrv_hdlctx {
    122		struct hdlcdrv_hdlcbuffer hbuf;
    123		unsigned long in_hdlc_tx;
    124		/*
    125		 * 0 = send flags
    126		 * 1 = send txtail (flags)
    127		 * 2 = send packet
    128		 */
    129		int tx_state;	
    130		int numflags;
    131		unsigned int bitstream;
    132		unsigned char ptt;
    133		int calibrate;
    134		int slotcnt;
    135
    136		unsigned int bitbuf;
    137		int numbits;
    138		
    139		int len;
    140		unsigned char *bp;
    141		unsigned char buffer[HDLCDRV_MAXFLEN+2];
    142	} hdlctx;
    143
    144#ifdef HDLCDRV_DEBUG
    145	struct hdlcdrv_bitbuffer bitbuf_channel;
    146	struct hdlcdrv_bitbuffer bitbuf_hdlc;
    147#endif /* HDLCDRV_DEBUG */
    148
    149	int ptt_keyed;
    150
    151	/* queued skb for transmission */
    152	struct sk_buff *skb;
    153};
    154
    155
    156/* -------------------------------------------------------------------- */
    157
    158static inline int hdlcdrv_hbuf_full(struct hdlcdrv_hdlcbuffer *hb) 
    159{
    160	unsigned long flags;
    161	int ret;
    162	
    163	spin_lock_irqsave(&hb->lock, flags);
    164	ret = !((HDLCDRV_HDLCBUFFER - 1 + hb->rd - hb->wr) % HDLCDRV_HDLCBUFFER);
    165	spin_unlock_irqrestore(&hb->lock, flags);
    166	return ret;
    167}
    168
    169/* -------------------------------------------------------------------- */
    170
    171static inline int hdlcdrv_hbuf_empty(struct hdlcdrv_hdlcbuffer *hb)
    172{
    173	unsigned long flags;
    174	int ret;
    175	
    176	spin_lock_irqsave(&hb->lock, flags);
    177	ret = (hb->rd == hb->wr);
    178	spin_unlock_irqrestore(&hb->lock, flags);
    179	return ret;
    180}
    181
    182/* -------------------------------------------------------------------- */
    183
    184static inline unsigned short hdlcdrv_hbuf_get(struct hdlcdrv_hdlcbuffer *hb)
    185{
    186	unsigned long flags;
    187	unsigned short val;
    188	unsigned newr;
    189
    190	spin_lock_irqsave(&hb->lock, flags);
    191	if (hb->rd == hb->wr)
    192		val = 0;
    193	else {
    194		newr = (hb->rd+1) % HDLCDRV_HDLCBUFFER;
    195		val = hb->buf[hb->rd];
    196		hb->rd = newr;
    197	}
    198	spin_unlock_irqrestore(&hb->lock, flags);
    199	return val;
    200}
    201
    202/* -------------------------------------------------------------------- */
    203
    204static inline void hdlcdrv_hbuf_put(struct hdlcdrv_hdlcbuffer *hb, 
    205				    unsigned short val)
    206{
    207	unsigned newp;
    208	unsigned long flags;
    209	
    210	spin_lock_irqsave(&hb->lock, flags);
    211	newp = (hb->wr+1) % HDLCDRV_HDLCBUFFER;
    212	if (newp != hb->rd) { 
    213		hb->buf[hb->wr] = val & 0xffff;
    214		hb->wr = newp;
    215	}
    216	spin_unlock_irqrestore(&hb->lock, flags);
    217}
    218
    219/* -------------------------------------------------------------------- */
    220
    221static inline void hdlcdrv_putbits(struct hdlcdrv_state *s, unsigned int bits)
    222{
    223	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, bits);
    224}
    225
    226static inline unsigned int hdlcdrv_getbits(struct hdlcdrv_state *s)
    227{
    228	unsigned int ret;
    229
    230	if (hdlcdrv_hbuf_empty(&s->hdlctx.hbuf)) {
    231		if (s->hdlctx.calibrate > 0)
    232			s->hdlctx.calibrate--;
    233		else
    234			s->hdlctx.ptt = 0;
    235		ret = 0;
    236	} else 
    237		ret = hdlcdrv_hbuf_get(&s->hdlctx.hbuf);
    238#ifdef HDLCDRV_LOOPBACK
    239	hdlcdrv_hbuf_put(&s->hdlcrx.hbuf, ret);
    240#endif /* HDLCDRV_LOOPBACK */
    241	return ret;
    242}
    243
    244static inline void hdlcdrv_channelbit(struct hdlcdrv_state *s, unsigned int bit)
    245{
    246#ifdef HDLCDRV_DEBUG
    247	hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
    248#endif /* HDLCDRV_DEBUG */
    249}
    250
    251static inline void hdlcdrv_setdcd(struct hdlcdrv_state *s, int dcd)
    252{
    253	s->hdlcrx.dcd = !!dcd;
    254}
    255
    256static inline int hdlcdrv_ptt(struct hdlcdrv_state *s)
    257{
    258	return s->hdlctx.ptt || (s->hdlctx.calibrate > 0);
    259}
    260
    261/* -------------------------------------------------------------------- */
    262
    263void hdlcdrv_receiver(struct net_device *, struct hdlcdrv_state *);
    264void hdlcdrv_transmitter(struct net_device *, struct hdlcdrv_state *);
    265void hdlcdrv_arbitrate(struct net_device *, struct hdlcdrv_state *);
    266struct net_device *hdlcdrv_register(const struct hdlcdrv_ops *ops,
    267				    unsigned int privsize, const char *ifname,
    268				    unsigned int baseaddr, unsigned int irq, 
    269				    unsigned int dma);
    270void hdlcdrv_unregister(struct net_device *dev);
    271
    272/* -------------------------------------------------------------------- */
    273
    274
    275
    276#endif /* _HDLCDRV_H */