drivers/net/hamradio/hdlcdrv.c

   1 /*****************************************************************************/
   2
   3 /*
   4  *      hdlcdrv.c  -- HDLC packet radio network driver.
   5  *
   6  *      Copyright (C) 1996-2000  Thomas Sailer (sailer@ife.ee.ethz.ch)
   7  *
   8  *      This program is free software; you can redistribute it and/or modify
   9  *      it under the terms of the GNU General Public License as published by
  10  *      the Free Software Foundation; either version 2 of the License, or
  11  *      (at your option) any later version.
  12  *
  13  *      This program is distributed in the hope that it will be useful,
  14  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *      GNU General Public License for more details.
  17  *
  18  *      You should have received a copy of the GNU General Public License
  19  *      along with this program; if not, write to the Free Software
  20  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  *  Please note that the GPL allows you to use the driver, NOT the radio.
  23  *  In order to use the radio, you need a license from the communications
  24  *  authority of your country.
  25  *
  26  *  The driver was derived from Donald Beckers skeleton.c
  27  *      Written 1993-94 by Donald Becker.
  28  *
  29  *  History:
  30  *   0.1  21.09.1996  Started
  31  *        18.10.1996  Changed to new user space access routines
  32  *                    (copy_{to,from}_user)
  33  *   0.2  21.11.1996  various small changes
  34  *   0.3  03.03.1997  fixed (hopefully) IP not working with ax.25 as a module
  35  *   0.4  16.04.1997  init code/data tagged
  36  *   0.5  30.07.1997  made HDLC buffers bigger (solves a problem with the
  37  *                    soundmodem driver)
  38  *   0.6  05.04.1998  add spinlocks
  39  *   0.7  03.08.1999  removed some old compatibility cruft
  40  *   0.8  12.02.2000  adapted to softnet driver interface
  41  */
  42
  43 /*****************************************************************************/
  44
  45 #include <linux/config.h>
  46 #include <linux/module.h>
  47 #include <linux/types.h>
  48 #include <linux/net.h>
  49 #include <linux/in.h>
  50 #include <linux/if.h>
  51 #include <linux/slab.h>
  52 #include <linux/errno.h>
  53 #include <linux/init.h>
  54 #include <asm/bitops.h>
  55 #include <asm/uaccess.h>
  56
  57 #include <linux/netdevice.h>
  58 #include <linux/if_arp.h>
  59 #include <linux/etherdevice.h>
  60 #include <linux/skbuff.h>
  61 #include <linux/hdlcdrv.h>
  62 /* prototypes for ax25_encapsulate and ax25_rebuild_header */
  63 #include <net/ax25.h>
  64
  65 /* make genksyms happy */
  66 #include <linux/ip.h>
  67 #include <linux/udp.h>
  68 #include <linux/tcp.h>
  69
  70 /* --------------------------------------------------------------------- */
  71
  72 /*
  73  * The name of the card. Is used for messages and in the requests for
  74  * io regions, irqs and dma channels
  75  */
  76
  77 static char ax25_bcast[AX25_ADDR_LEN] =
  78 {'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1};
  79 static char ax25_nocall[AX25_ADDR_LEN] =
  80 {'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1};
  81
  82 /* --------------------------------------------------------------------- */
  83
  84 #define KISS_VERBOSE
  85
  86 /* --------------------------------------------------------------------- */
  87
  88 #define PARAM_TXDELAY   1
  89 #define PARAM_PERSIST   2
  90 #define PARAM_SLOTTIME  3
  91 #define PARAM_TXTAIL    4
  92 #define PARAM_FULLDUP   5
  93 #define PARAM_HARDWARE  6
  94 #define PARAM_RETURN    255
  95
  96 /* --------------------------------------------------------------------- */
  97 /*
  98  * the CRC routines are stolen from WAMPES
  99  * by Dieter Deyke
 100  */
 101
 102 static const unsigned short crc_ccitt_table[] = {
 103         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 104         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 105         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 106         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 107         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 108         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 109         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 110         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 111         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 112         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 113         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 114         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 115         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 116         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 117         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 118         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 119         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 120         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 121         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 122         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 123         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 124         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 125         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 126         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 127         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 128         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 129         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 130         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 131         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 132         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 133         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 134         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 135 };
 136
 137 /*---------------------------------------------------------------------------*/
 138
 139 static inline void append_crc_ccitt(unsigned char *buffer, int len)
 140 {
 141         unsigned int crc = 0xffff;
 142
 143         for (;len>0;len--)
 144                 crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buffer++) & 0xff];
 145         crc ^= 0xffff;
 146         *buffer++ = crc;
 147         *buffer++ = crc >> 8;
 148 }
 149
 150 /*---------------------------------------------------------------------------*/
 151
 152 static inline int check_crc_ccitt(const unsigned char *buf, int cnt)
 153 {
 154         unsigned int crc = 0xffff;
 155
 156         for (; cnt > 0; cnt--)
 157                 crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
 158         return (crc & 0xffff) == 0xf0b8;
 159 }
 160
 161 /*---------------------------------------------------------------------------*/
 162
 163 #if 0
 164 static int calc_crc_ccitt(const unsigned char *buf, int cnt)
 165 {
 166         unsigned int crc = 0xffff;
 167
 168         for (; cnt > 0; cnt--)
 169                 crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
 170         crc ^= 0xffff;
 171         return (crc & 0xffff);
 172 }
 173 #endif
 174
 175 /* ---------------------------------------------------------------------- */
 176
 177 #define tenms_to_2flags(s,tenms) ((tenms * s->par.bitrate) / 100 / 16)
 178
 179 /* ---------------------------------------------------------------------- */
 180 /*
 181  * The HDLC routines
 182  */
 183
 184 static int hdlc_rx_add_bytes(struct hdlcdrv_state *s, unsigned int bits,
 185                              int num)
 186 {
 187         int added = 0;
 188
 189         while (s->hdlcrx.rx_state && num >= 8) {
 190                 if (s->hdlcrx.len >= sizeof(s->hdlcrx.buffer)) {
 191                         s->hdlcrx.rx_state = 0;
 192                         return 0;
 193                 }
 194                 *s->hdlcrx.bp++ = bits >> (32-num);
 195                 s->hdlcrx.len++;
 196                 num -= 8;
 197                 added += 8;
 198         }
 199         return added;
 200 }
 201
 202 static void hdlc_rx_flag(struct net_device *dev, struct hdlcdrv_state *s)
 203 {
 204         struct sk_buff *skb;
 205         int pkt_len;
 206         unsigned char *cp;
 207
 208         if (s->hdlcrx.len < 4)
 209                 return;
 210         if (!check_crc_ccitt(s->hdlcrx.buffer, s->hdlcrx.len))
 211                 return;
 212         pkt_len = s->hdlcrx.len - 2 + 1; /* KISS kludge */
 213         if (!(skb = dev_alloc_skb(pkt_len))) {
 214                 printk("%s: memory squeeze, dropping packet\n", dev->name);
 215                 s->stats.rx_dropped++;
 216                 return;
 217         }
 218         skb->dev = dev;
 219         cp = skb_put(skb, pkt_len);
 220         *cp++ = 0; /* KISS kludge */
 221         memcpy(cp, s->hdlcrx.buffer, pkt_len - 1);
 222         skb->protocol = htons(ETH_P_AX25);
 223         skb->mac.raw = skb->data;
 224         netif_rx(skb);
 225         dev->last_rx = jiffies;
 226         s->stats.rx_packets++;
 227 }
 228
 229 void hdlcdrv_receiver(struct net_device *dev, struct hdlcdrv_state *s)
 230 {
 231         int i;
 232         unsigned int mask1, mask2, mask3, mask4, mask5, mask6, word;
 233
 234         if (!s || s->magic != HDLCDRV_MAGIC)
 235                 return;
 236         if (test_and_set_bit(0, &s->hdlcrx.in_hdlc_rx))
 237                 return;
 238
 239         while (!hdlcdrv_hbuf_empty(&s->hdlcrx.hbuf)) {
 240                 word = hdlcdrv_hbuf_get(&s->hdlcrx.hbuf);
 241
 242 #ifdef HDLCDRV_DEBUG
 243                 hdlcdrv_add_bitbuffer_word(&s->bitbuf_hdlc, word);
 244 #endif /* HDLCDRV_DEBUG */
 245                 s->hdlcrx.bitstream >>= 16;
 246                 s->hdlcrx.bitstream |= word << 16;
 247                 s->hdlcrx.bitbuf >>= 16;
 248                 s->hdlcrx.bitbuf |= word << 16;
 249                 s->hdlcrx.numbits += 16;
 250                 for(i = 15, mask1 = 0x1fc00, mask2 = 0x1fe00, mask3 = 0x0fc00,
 251                     mask4 = 0x1f800, mask5 = 0xf800, mask6 = 0xffff;
 252                     i >= 0;
 253                     i--, mask1 <<= 1, mask2 <<= 1, mask3 <<= 1, mask4 <<= 1,
 254                     mask5 <<= 1, mask6 = (mask6 << 1) | 1) {
 255                         if ((s->hdlcrx.bitstream & mask1) == mask1)
 256                                 s->hdlcrx.rx_state = 0; /* abort received */
 257                         else if ((s->hdlcrx.bitstream & mask2) == mask3) {
 258                                 /* flag received */
 259                                 if (s->hdlcrx.rx_state) {
 260                                         hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf
 261                                                           << (8+i),
 262                                                           s->hdlcrx.numbits
 263                                                           -8-i);
 264                                         hdlc_rx_flag(dev, s);
 265                                 }
 266                                 s->hdlcrx.len = 0;
 267                                 s->hdlcrx.bp = s->hdlcrx.buffer;
 268                                 s->hdlcrx.rx_state = 1;
 269                                 s->hdlcrx.numbits = i;
 270                         } else if ((s->hdlcrx.bitstream & mask4) == mask5) {
 271                                 /* stuffed bit */
 272                                 s->hdlcrx.numbits--;
 273                                 s->hdlcrx.bitbuf = (s->hdlcrx.bitbuf & (~mask6)) |
 274                                         ((s->hdlcrx.bitbuf & mask6) << 1);
 275                         }
 276                 }
 277                 s->hdlcrx.numbits -= hdlc_rx_add_bytes(s, s->hdlcrx.bitbuf,
 278                                                        s->hdlcrx.numbits);
 279         }
 280         clear_bit(0, &s->hdlcrx.in_hdlc_rx);
 281 }
 282
 283 /* ---------------------------------------------------------------------- */
 284
 285 static inline void do_kiss_params(struct hdlcdrv_state *s,
 286                                   unsigned char *data, unsigned long len)
 287 {
 288
 289 #ifdef KISS_VERBOSE
 290 #define PKP(a,b) printk(KERN_INFO "hdlcdrv.c: channel params: " a "\n", b)
 291 #else /* KISS_VERBOSE */
 292 #define PKP(a,b)
 293 #endif /* KISS_VERBOSE */
 294
 295         if (len < 2)
 296                 return;
 297         switch(data[0]) {
 298         case PARAM_TXDELAY:
 299                 s->ch_params.tx_delay = data[1];
 300                 PKP("TX delay = %ums", 10 * s->ch_params.tx_delay);
 301                 break;
 302         case PARAM_PERSIST:
 303                 s->ch_params.ppersist = data[1];
 304                 PKP("p persistence = %u", s->ch_params.ppersist);
 305                 break;
 306         case PARAM_SLOTTIME:
 307                 s->ch_params.slottime = data[1];
 308                 PKP("slot time = %ums", s->ch_params.slottime);
 309                 break;
 310         case PARAM_TXTAIL:
 311                 s->ch_params.tx_tail = data[1];
 312                 PKP("TX tail = %ums", s->ch_params.tx_tail);
 313                 break;
 314         case PARAM_FULLDUP:
 315                 s->ch_params.fulldup = !!data[1];
 316                 PKP("%s duplex", s->ch_params.fulldup ? "full" : "half");
 317                 break;
 318         default:
 319                 break;
 320         }
 321 #undef PKP
 322 }
 323
 324 /* ---------------------------------------------------------------------- */
 325
 326 void hdlcdrv_transmitter(struct net_device *dev, struct hdlcdrv_state *s)
 327 {
 328         unsigned int mask1, mask2, mask3;
 329         int i;
 330         struct sk_buff *skb;
 331         int pkt_len;
 332
 333         if (!s || s->magic != HDLCDRV_MAGIC)
 334                 return;
 335         if (test_and_set_bit(0, &s->hdlctx.in_hdlc_tx))
 336                 return;
 337         for (;;) {
 338                 if (s->hdlctx.numbits >= 16) {
 339                         if (hdlcdrv_hbuf_full(&s->hdlctx.hbuf)) {
 340                                 clear_bit(0, &s->hdlctx.in_hdlc_tx);
 341                                 return;
 342                         }
 343                         hdlcdrv_hbuf_put(&s->hdlctx.hbuf, s->hdlctx.bitbuf);
 344                         s->hdlctx.bitbuf >>= 16;
 345                         s->hdlctx.numbits -= 16;
 346                 }
 347                 switch (s->hdlctx.tx_state) {
 348                 default:
 349                         clear_bit(0, &s->hdlctx.in_hdlc_tx);
 350                         return;
 351                 case 0:
 352                 case 1:
 353                         if (s->hdlctx.numflags) {
 354                                 s->hdlctx.numflags--;
 355                                 s->hdlctx.bitbuf |=
 356                                         0x7e7e << s->hdlctx.numbits;
 357                                 s->hdlctx.numbits += 16;
 358                                 break;
 359                         }
 360                         if (s->hdlctx.tx_state == 1) {
 361                                 clear_bit(0, &s->hdlctx.in_hdlc_tx);
 362                                 return;
 363                         }
 364                         if (!(skb = s->skb)) {
 365                                 int flgs = tenms_to_2flags(s, s->ch_params.tx_tail);
 366                                 if (flgs < 2)
 367                                         flgs = 2;
 368                                 s->hdlctx.tx_state = 1;
 369                                 s->hdlctx.numflags = flgs;
 370                                 break;
 371                         }
 372                         s->skb = NULL;
 373                         netif_wake_queue(dev);
 374                         pkt_len = skb->len-1; /* strip KISS byte */
 375                         if (pkt_len >= HDLCDRV_MAXFLEN || pkt_len < 2) {
 376                                 s->hdlctx.tx_state = 0;
 377                                 s->hdlctx.numflags = 1;
 378                                 dev_kfree_skb_irq(skb);
 379                                 break;
 380                         }
 381                         memcpy(s->hdlctx.buffer, skb->data+1, pkt_len);
 382                         dev_kfree_skb_irq(skb);
 383                         s->hdlctx.bp = s->hdlctx.buffer;
 384                         append_crc_ccitt(s->hdlctx.buffer, pkt_len);
 385                         s->hdlctx.len = pkt_len+2; /* the appended CRC */
 386                         s->hdlctx.tx_state = 2;
 387                         s->hdlctx.bitstream = 0;
 388                         s->stats.tx_packets++;
 389                         break;
 390                 case 2:
 391                         if (!s->hdlctx.len) {
 392                                 s->hdlctx.tx_state = 0;
 393                                 s->hdlctx.numflags = 1;
 394                                 break;
 395                         }
 396                         s->hdlctx.len--;
 397                         s->hdlctx.bitbuf |= *s->hdlctx.bp <<
 398                                 s->hdlctx.numbits;
 399                         s->hdlctx.bitstream >>= 8;
 400                         s->hdlctx.bitstream |= (*s->hdlctx.bp++) << 16;
 401                         mask1 = 0x1f000;
 402                         mask2 = 0x10000;
 403                         mask3 = 0xffffffff >> (31-s->hdlctx.numbits);
 404                         s->hdlctx.numbits += 8;
 405                         for(i = 0; i < 8; i++, mask1 <<= 1, mask2 <<= 1,
 406                             mask3 = (mask3 << 1) | 1) {
 407                                 if ((s->hdlctx.bitstream & mask1) != mask1)
 408                                         continue;
 409                                 s->hdlctx.bitstream &= ~mask2;
 410                                 s->hdlctx.bitbuf =
 411                                         (s->hdlctx.bitbuf & mask3) |
 412                                                 ((s->hdlctx.bitbuf &
 413                                                  (~mask3)) << 1);
 414                                 s->hdlctx.numbits++;
 415                                 mask3 = (mask3 << 1) | 1;
 416                         }
 417                         break;
 418                 }
 419         }
 420 }
 421
 422 /* ---------------------------------------------------------------------- */
 423
 424 static void start_tx(struct net_device *dev, struct hdlcdrv_state *s)
 425 {
 426         s->hdlctx.tx_state = 0;
 427         s->hdlctx.numflags = tenms_to_2flags(s, s->ch_params.tx_delay);
 428         s->hdlctx.bitbuf = s->hdlctx.bitstream = s->hdlctx.numbits = 0;
 429         hdlcdrv_transmitter(dev, s);
 430         s->hdlctx.ptt = 1;
 431         s->ptt_keyed++;
 432 }
 433
 434 /* ---------------------------------------------------------------------- */
 435
 436 static unsigned short random_seed;
 437
 438 static inline unsigned short random_num(void)
 439 {
 440         random_seed = 28629 * random_seed + 157;
 441         return random_seed;
 442 }
 443
 444 /* ---------------------------------------------------------------------- */
 445
 446 void hdlcdrv_arbitrate(struct net_device *dev, struct hdlcdrv_state *s)
 447 {
 448         if (!s || s->magic != HDLCDRV_MAGIC || s->hdlctx.ptt || !s->skb)
 449                 return;
 450         if (s->ch_params.fulldup) {
 451                 start_tx(dev, s);
 452                 return;
 453         }
 454         if (s->hdlcrx.dcd) {
 455                 s->hdlctx.slotcnt = s->ch_params.slottime;
 456                 return;
 457         }
 458         if ((--s->hdlctx.slotcnt) > 0)
 459                 return;
 460         s->hdlctx.slotcnt = s->ch_params.slottime;
 461         if ((random_num() % 256) > s->ch_params.ppersist)
 462                 return;
 463         start_tx(dev, s);
 464 }
 465
 466 /* --------------------------------------------------------------------- */
 467 /*
 468  * ===================== network driver interface =========================
 469  */
 470
 471 static inline int hdlcdrv_paranoia_check(struct net_device *dev,
 472                                         const char *routine)
 473 {
 474         if (!dev || !dev->priv ||
 475             ((struct hdlcdrv_state *)dev->priv)->magic != HDLCDRV_MAGIC) {
 476                 printk(KERN_ERR "hdlcdrv: bad magic number for hdlcdrv_state "
 477                        "struct in routine %s\n", routine);
 478                 return 1;
 479         }
 480         return 0;
 481 }
 482
 483 /* --------------------------------------------------------------------- */
 484
 485 static int hdlcdrv_send_packet(struct sk_buff *skb, struct net_device *dev)
 486 {
 487         struct hdlcdrv_state *sm;
 488
 489         if (hdlcdrv_paranoia_check(dev, "hdlcdrv_send_packet"))
 490                 return 0;
 491         sm = (struct hdlcdrv_state *)dev->priv;
 492         if (skb->data[0] != 0) {
 493                 do_kiss_params(sm, skb->data, skb->len);
 494                 dev_kfree_skb(skb);
 495                 return 0;
 496         }
 497         if (sm->skb)
 498                 return -1;
 499         netif_stop_queue(dev);
 500         sm->skb = skb;
 501         return 0;
 502 }
 503
 504 /* --------------------------------------------------------------------- */
 505
 506 static int hdlcdrv_set_mac_address(struct net_device *dev, void *addr)
 507 {
 508         struct sockaddr *sa = (struct sockaddr *)addr;
 509
 510         /* addr is an AX.25 shifted ASCII mac address */
 511         memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
 512         return 0;
 513 }
 514
 515 /* --------------------------------------------------------------------- */
 516
 517 static struct net_device_stats *hdlcdrv_get_stats(struct net_device *dev)
 518 {
 519         struct hdlcdrv_state *sm;
 520
 521         if (hdlcdrv_paranoia_check(dev, "hdlcdrv_get_stats"))
 522                 return NULL;
 523         sm = (struct hdlcdrv_state *)dev->priv;
 524         /*
 525          * Get the current statistics.  This may be called with the
 526          * card open or closed.
 527          */
 528         return &sm->stats;
 529 }
 530
 531 /* --------------------------------------------------------------------- */
 532 /*
 533  * Open/initialize the board. This is called (in the current kernel)
 534  * sometime after booting when the 'ifconfig' program is run.
 535  *
 536  * This routine should set everything up anew at each open, even
 537  * registers that "should" only need to be set once at boot, so that
 538  * there is non-reboot way to recover if something goes wrong.
 539  */
 540
 541 static int hdlcdrv_open(struct net_device *dev)
 542 {
 543         struct hdlcdrv_state *s;
 544         int i;
 545
 546         if (hdlcdrv_paranoia_check(dev, "hdlcdrv_open"))
 547                 return -EINVAL;
 548         s = (struct hdlcdrv_state *)dev->priv;
 549
 550         if (!s->ops || !s->ops->open)
 551                 return -ENODEV;
 552
 553         /*
 554          * initialise some variables
 555          */
 556         s->opened = 1;
 557         s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
 558         s->hdlcrx.in_hdlc_rx = 0;
 559         s->hdlcrx.rx_state = 0;
 560
 561         s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
 562         s->hdlctx.in_hdlc_tx = 0;
 563         s->hdlctx.tx_state = 1;
 564         s->hdlctx.numflags = 0;
 565         s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
 566         s->hdlctx.ptt = 0;
 567         s->hdlctx.slotcnt = s->ch_params.slottime;
 568         s->hdlctx.calibrate = 0;
 569
 570         i = s->ops->open(dev);
 571         if (i)
 572                 return i;
 573         netif_start_queue(dev);
 574         return 0;
 575 }
 576
 577 /* --------------------------------------------------------------------- */
 578 /*
 579  * The inverse routine to hdlcdrv_open().
 580  */
 581
 582 static int hdlcdrv_close(struct net_device *dev)
 583 {
 584         struct hdlcdrv_state *s;
 585         int i = 0;
 586
 587         if (hdlcdrv_paranoia_check(dev, "hdlcdrv_close"))
 588                 return -EINVAL;
 589         s = (struct hdlcdrv_state *)dev->priv;
 590
 591         if (s->ops && s->ops->close)
 592                 i = s->ops->close(dev);
 593         if (s->skb)
 594                 dev_kfree_skb(s->skb);
 595         s->skb = NULL;
 596         s->opened = 0;
 597         return i;
 598 }
 599
 600 /* --------------------------------------------------------------------- */
 601
 602 static int hdlcdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 603 {
 604         struct hdlcdrv_state *s;
 605         struct hdlcdrv_ioctl bi;
 606
 607         if (hdlcdrv_paranoia_check(dev, "hdlcdrv_ioctl"))
 608                 return -EINVAL;
 609         s = (struct hdlcdrv_state *)dev->priv;
 610
 611         if (cmd != SIOCDEVPRIVATE) {
 612                 if (s->ops && s->ops->ioctl)
 613                         return s->ops->ioctl(dev, ifr, &bi, cmd);
 614                 return -ENOIOCTLCMD;
 615         }
 616         if (copy_from_user(&bi, ifr->ifr_data, sizeof(bi)))
 617                 return -EFAULT;
 618
 619         switch (bi.cmd) {
 620         default:
 621                 if (s->ops && s->ops->ioctl)
 622                         return s->ops->ioctl(dev, ifr, &bi, cmd);
 623                 return -ENOIOCTLCMD;
 624
 625         case HDLCDRVCTL_GETCHANNELPAR:
 626                 bi.data.cp.tx_delay = s->ch_params.tx_delay;
 627                 bi.data.cp.tx_tail = s->ch_params.tx_tail;
 628                 bi.data.cp.slottime = s->ch_params.slottime;
 629                 bi.data.cp.ppersist = s->ch_params.ppersist;
 630                 bi.data.cp.fulldup = s->ch_params.fulldup;
 631                 break;
 632
 633         case HDLCDRVCTL_SETCHANNELPAR:
 634                 if (!capable(CAP_NET_ADMIN))
 635                         return -EACCES;
 636                 s->ch_params.tx_delay = bi.data.cp.tx_delay;
 637                 s->ch_params.tx_tail = bi.data.cp.tx_tail;
 638                 s->ch_params.slottime = bi.data.cp.slottime;
 639                 s->ch_params.ppersist = bi.data.cp.ppersist;
 640                 s->ch_params.fulldup = bi.data.cp.fulldup;
 641                 s->hdlctx.slotcnt = 1;
 642                 return 0;
 643
 644         case HDLCDRVCTL_GETMODEMPAR:
 645                 bi.data.mp.iobase = dev->base_addr;
 646                 bi.data.mp.irq = dev->irq;
 647                 bi.data.mp.dma = dev->dma;
 648                 bi.data.mp.dma2 = s->ptt_out.dma2;
 649                 bi.data.mp.seriobase = s->ptt_out.seriobase;
 650                 bi.data.mp.pariobase = s->ptt_out.pariobase;
 651                 bi.data.mp.midiiobase = s->ptt_out.midiiobase;
 652                 break;
 653
 654         case HDLCDRVCTL_SETMODEMPAR:
 655                 if ((!capable(CAP_SYS_RAWIO)) || netif_running(dev))
 656                         return -EACCES;
 657                 dev->base_addr = bi.data.mp.iobase;
 658                 dev->irq = bi.data.mp.irq;
 659                 dev->dma = bi.data.mp.dma;
 660                 s->ptt_out.dma2 = bi.data.mp.dma2;
 661                 s->ptt_out.seriobase = bi.data.mp.seriobase;
 662                 s->ptt_out.pariobase = bi.data.mp.pariobase;
 663                 s->ptt_out.midiiobase = bi.data.mp.midiiobase;
 664                 return 0;
 665
 666         case HDLCDRVCTL_GETSTAT:
 667                 bi.data.cs.ptt = hdlcdrv_ptt(s);
 668                 bi.data.cs.dcd = s->hdlcrx.dcd;
 669                 bi.data.cs.ptt_keyed = s->ptt_keyed;
 670                 bi.data.cs.tx_packets = s->stats.tx_packets;
 671                 bi.data.cs.tx_errors = s->stats.tx_errors;
 672                 bi.data.cs.rx_packets = s->stats.rx_packets;
 673                 bi.data.cs.rx_errors = s->stats.rx_errors;
 674                 break;
 675
 676         case HDLCDRVCTL_OLDGETSTAT:
 677                 bi.data.ocs.ptt = hdlcdrv_ptt(s);
 678                 bi.data.ocs.dcd = s->hdlcrx.dcd;
 679                 bi.data.ocs.ptt_keyed = s->ptt_keyed;
 680                 break;
 681
 682         case HDLCDRVCTL_CALIBRATE:
 683                 if(!capable(CAP_SYS_RAWIO))
 684                         return -EPERM;
 685                 s->hdlctx.calibrate = bi.data.calibrate * s->par.bitrate / 16;
 686                 return 0;
 687
 688         case HDLCDRVCTL_GETSAMPLES:
 689 #ifndef HDLCDRV_DEBUG
 690                 return -EPERM;
 691 #else /* HDLCDRV_DEBUG */
 692                 if (s->bitbuf_channel.rd == s->bitbuf_channel.wr)
 693                         return -EAGAIN;
 694                 bi.data.bits =
 695                         s->bitbuf_channel.buffer[s->bitbuf_channel.rd];
 696                 s->bitbuf_channel.rd = (s->bitbuf_channel.rd+1) %
 697                         sizeof(s->bitbuf_channel.buffer);
 698                 break;
 699 #endif /* HDLCDRV_DEBUG */
 700
 701         case HDLCDRVCTL_GETBITS:
 702 #ifndef HDLCDRV_DEBUG
 703                 return -EPERM;
 704 #else /* HDLCDRV_DEBUG */
 705                 if (s->bitbuf_hdlc.rd == s->bitbuf_hdlc.wr)
 706                         return -EAGAIN;
 707                 bi.data.bits =
 708                         s->bitbuf_hdlc.buffer[s->bitbuf_hdlc.rd];
 709                 s->bitbuf_hdlc.rd = (s->bitbuf_hdlc.rd+1) %
 710                         sizeof(s->bitbuf_hdlc.buffer);
 711                 break;
 712 #endif /* HDLCDRV_DEBUG */
 713
 714         case HDLCDRVCTL_DRIVERNAME:
 715                 if (s->ops && s->ops->drvname) {
 716                         strncpy(bi.data.drivername, s->ops->drvname,
 717                                 sizeof(bi.data.drivername));
 718                         break;
 719                 }
 720                 bi.data.drivername[0] = '\0';
 721                 break;
 722
 723         }
 724         if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi)))
 725                 return -EFAULT;
 726         return 0;
 727
 728 }
 729
 730 /* --------------------------------------------------------------------- */
 731
 732 /*
 733  * Initialize fields in hdlcdrv
 734  */
 735 static void hdlcdrv_setup(struct net_device *dev)
 736 {
 737         static const struct hdlcdrv_channel_params dflt_ch_params = {
 738                 20, 2, 10, 40, 0
 739         };
 740         struct hdlcdrv_state *s = dev->priv;
 741
 742         /*
 743          * initialize the hdlcdrv_state struct
 744          */
 745         s->ch_params = dflt_ch_params;
 746         s->ptt_keyed = 0;
 747
 748         spin_lock_init(&s->hdlcrx.hbuf.lock);
 749         s->hdlcrx.hbuf.rd = s->hdlcrx.hbuf.wr = 0;
 750         s->hdlcrx.in_hdlc_rx = 0;
 751         s->hdlcrx.rx_state = 0;
 752
 753         spin_lock_init(&s->hdlctx.hbuf.lock);
 754         s->hdlctx.hbuf.rd = s->hdlctx.hbuf.wr = 0;
 755         s->hdlctx.in_hdlc_tx = 0;
 756         s->hdlctx.tx_state = 1;
 757         s->hdlctx.numflags = 0;
 758         s->hdlctx.bitstream = s->hdlctx.bitbuf = s->hdlctx.numbits = 0;
 759         s->hdlctx.ptt = 0;
 760         s->hdlctx.slotcnt = s->ch_params.slottime;
 761         s->hdlctx.calibrate = 0;
 762
 763 #ifdef HDLCDRV_DEBUG
 764         s->bitbuf_channel.rd = s->bitbuf_channel.wr = 0;
 765         s->bitbuf_channel.shreg = 0x80;
 766
 767         s->bitbuf_hdlc.rd = s->bitbuf_hdlc.wr = 0;
 768         s->bitbuf_hdlc.shreg = 0x80;
 769 #endif /* HDLCDRV_DEBUG */
 770
 771         /*
 772          * initialize the device struct
 773          */
 774         dev->open = hdlcdrv_open;
 775         dev->stop = hdlcdrv_close;
 776         dev->do_ioctl = hdlcdrv_ioctl;
 777         dev->hard_start_xmit = hdlcdrv_send_packet;
 778         dev->get_stats = hdlcdrv_get_stats;
 779
 780         /* Fill in the fields of the device structure */
 781
 782         s->skb = NULL;
 783
 784 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 785         dev->hard_header = ax25_encapsulate;
 786         dev->rebuild_header = ax25_rebuild_header;
 787 #else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
 788         dev->hard_header = NULL;
 789         dev->rebuild_header = NULL;
 790 #endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
 791         dev->set_mac_address = hdlcdrv_set_mac_address;
 792
 793         dev->type = ARPHRD_AX25;           /* AF_AX25 device */
 794         dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN;
 795         dev->mtu = AX25_DEF_PACLEN;        /* eth_mtu is the default */
 796         dev->addr_len = AX25_ADDR_LEN;     /* sizeof an ax.25 address */
 797         memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
 798         memcpy(dev->dev_addr, ax25_nocall, AX25_ADDR_LEN);
 799         dev->tx_queue_len = 16;
 800 }
 801
 802 /* --------------------------------------------------------------------- */
 803 struct net_device *hdlcdrv_register(const struct hdlcdrv_ops *ops,
 804                                     unsigned int privsize, const char *ifname,
 805                                     unsigned int baseaddr, unsigned int irq,
 806                                     unsigned int dma)
 807 {
 808         struct net_device *dev;
 809         struct hdlcdrv_state *s;
 810         int err;
 811
 812         BUG_ON(ops == NULL);
 813
 814         if (privsize < sizeof(struct hdlcdrv_state))
 815                 privsize = sizeof(struct hdlcdrv_state);
 816
 817         dev = alloc_netdev(privsize, ifname, hdlcdrv_setup);
 818         if (!dev)
 819                 return ERR_PTR(-ENOMEM);
 820
 821         /*
 822          * initialize part of the hdlcdrv_state struct
 823          */
 824         s = dev->priv;
 825         s->magic = HDLCDRV_MAGIC;
 826         s->ops = ops;
 827         dev->base_addr = baseaddr;
 828         dev->irq = irq;
 829         dev->dma = dma;
 830
 831         err = register_netdev(dev);
 832         if (err < 0) {
 833                 printk(KERN_WARNING "hdlcdrv: cannot register net "
 834                        "device %s\n", dev->name);
 835                 free_netdev(dev);
 836                 dev = ERR_PTR(err);
 837         }
 838         return dev;
 839 }
 840
 841 /* --------------------------------------------------------------------- */
 842
 843 void hdlcdrv_unregister(struct net_device *dev)
 844 {
 845         struct hdlcdrv_state *s = dev->priv;
 846
 847         BUG_ON(s->magic != HDLCDRV_MAGIC);
 848
 849         if (s->opened && s->ops->close)
 850                 s->ops->close(dev);
 851         unregister_netdev(dev);
 852
 853         free_netdev(dev);
 854 }
 855
 856 /* --------------------------------------------------------------------- */
 857
 858 EXPORT_SYMBOL(hdlcdrv_receiver);
 859 EXPORT_SYMBOL(hdlcdrv_transmitter);
 860 EXPORT_SYMBOL(hdlcdrv_arbitrate);
 861 EXPORT_SYMBOL(hdlcdrv_register);
 862 EXPORT_SYMBOL(hdlcdrv_unregister);
 863
 864 /* --------------------------------------------------------------------- */
 865
 866 static int __init hdlcdrv_init_driver(void)
 867 {
 868         printk(KERN_INFO "hdlcdrv: (C) 1996-2000 Thomas Sailer HB9JNX/AE4WA\n");
 869         printk(KERN_INFO "hdlcdrv: version 0.8 compiled " __TIME__ " " __DATE__ "\n");
 870         return 0;
 871 }
 872
 873 /* --------------------------------------------------------------------- */
 874
 875 static void __exit hdlcdrv_cleanup_driver(void)
 876 {
 877         printk(KERN_INFO "hdlcdrv: cleanup\n");
 878 }
 879
 880 /* --------------------------------------------------------------------- */
 881
 882 MODULE_AUTHOR("Thomas M. Sailer, sailer@ife.ee.ethz.ch, hb9jnx@hb9w.che.eu");
 883 MODULE_DESCRIPTION("Packet Radio network interface HDLC encoder/decoder");
 884 MODULE_LICENSE("GPL");
 885 module_init(hdlcdrv_init_driver);
 886 module_exit(hdlcdrv_cleanup_driver);
 887
 888 /* --------------------------------------------------------------------- */