release/src-rt-6.x.4708/linux/linux-2.6.36/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                 unsigned 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                 unsigned 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         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 /* -------------------------------------------------------------------- */