git.oblomov.eu Git - linux-2.6/blob - 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                 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 /* -------------------------------------------------------------------- */