git.oblomov.eu Git - linux-2.6/blob - drivers/net/hamradio/yam.c

   1 /*****************************************************************************/
   2
   3 /*
   4  *    yam.c  -- YAM radio modem driver.
   5  *
   6  *      Copyright (C) 1998 Frederic Rible F1OAT (frible@teaser.fr)
   7  *      Adapted from baycom.c driver written by Thomas Sailer (sailer@ife.ee.ethz.ch)
   8  *
   9  *      This program is free software; you can redistribute it and/or modify
  10  *      it under the terms of the GNU General Public License as published by
  11  *      the Free Software Foundation; either version 2 of the License, or
  12  *      (at your option) any later version.
  13  *
  14  *      This program is distributed in the hope that it will be useful,
  15  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *      GNU General Public License for more details.
  18  *
  19  *      You should have received a copy of the GNU General Public License
  20  *      along with this program; if not, write to the Free Software
  21  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  *  Please note that the GPL allows you to use the driver, NOT the radio.
  24  *  In order to use the radio, you need a license from the communications
  25  *  authority of your country.
  26  *
  27  *
  28  *  History:
  29  *   0.0 F1OAT 06.06.98  Begin of work with baycom.c source code V 0.3
  30  *   0.1 F1OAT 07.06.98  Add timer polling routine for channel arbitration
  31  *   0.2 F6FBB 08.06.98  Added delay after FPGA programming
  32  *   0.3 F6FBB 29.07.98  Delayed PTT implementation for dupmode=2
  33  *   0.4 F6FBB 30.07.98  Added TxTail, Slottime and Persistance
  34  *   0.5 F6FBB 01.08.98  Shared IRQs, /proc/net and network statistics
  35  *   0.6 F6FBB 25.08.98  Added 1200Bds format
  36  *   0.7 F6FBB 12.09.98  Added to the kernel configuration
  37  *   0.8 F6FBB 14.10.98  Fixed slottime/persistence timing bug
  38  *       OK1ZIA 2.09.01  Fixed "kfree_skb on hard IRQ"
  39  *                       using dev_kfree_skb_any(). (important in 2.4 kernel)
  40  *
  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/bitops.h>
  54 #include <asm/io.h>
  55 #include <asm/system.h>
  56 #include <linux/interrupt.h>
  57 #include <linux/ioport.h>
  58
  59 #include <linux/netdevice.h>
  60 #include <linux/if_arp.h>
  61 #include <linux/etherdevice.h>
  62 #include <linux/skbuff.h>
  63 #include <net/ax25.h>
  64
  65 #include <linux/kernel.h>
  66 #include <linux/proc_fs.h>
  67 #include <linux/seq_file.h>
  68
  69 #include <asm/uaccess.h>
  70 #include <linux/init.h>
  71
  72 #include <linux/yam.h>
  73 #include "yam9600.h"
  74 #include "yam1200.h"
  75
  76 /* --------------------------------------------------------------------- */
  77
  78 static const char yam_drvname[] = "yam";
  79 static char yam_drvinfo[] __initdata = KERN_INFO "YAM driver version 0.8 by F1OAT/F6FBB\n";
  80
  81 /* --------------------------------------------------------------------- */
  82
  83 #define YAM_9600        1
  84 #define YAM_1200        2
  85
  86 #define NR_PORTS        4
  87 #define YAM_MAGIC       0xF10A7654
  88
  89 /* Transmitter states */
  90
  91 #define TX_OFF          0
  92 #define TX_HEAD         1
  93 #define TX_DATA         2
  94 #define TX_CRC1         3
  95 #define TX_CRC2         4
  96 #define TX_TAIL         5
  97
  98 #define YAM_MAX_FRAME   1024
  99
 100 #define DEFAULT_BITRATE 9600                    /* bps */
 101 #define DEFAULT_HOLDD   10                      /* sec */
 102 #define DEFAULT_TXD     300                     /* ms */
 103 #define DEFAULT_TXTAIL  10                      /* ms */
 104 #define DEFAULT_SLOT    100                     /* ms */
 105 #define DEFAULT_PERS    64                      /* 0->255 */
 106
 107 struct yam_port {
 108         int magic;
 109         int bitrate;
 110         int baudrate;
 111         int iobase;
 112         int irq;
 113         int dupmode;
 114
 115         struct net_device *dev;
 116
 117         /* Stats section */
 118
 119         struct net_device_stats stats;
 120
 121         int nb_rxint;
 122         int nb_mdint;
 123
 124         /* Parameters section */
 125
 126         int txd;                                /* tx delay */
 127         int holdd;                              /* duplex ptt delay */
 128         int txtail;                             /* txtail delay */
 129         int slot;                               /* slottime */
 130         int pers;                               /* persistence */
 131
 132         /* Tx section */
 133
 134         int tx_state;
 135         int tx_count;
 136         int slotcnt;
 137         unsigned char tx_buf[YAM_MAX_FRAME];
 138         int tx_len;
 139         int tx_crcl, tx_crch;
 140         struct sk_buff_head send_queue;         /* Packets awaiting transmission */
 141
 142         /* Rx section */
 143
 144         int dcd;
 145         unsigned char rx_buf[YAM_MAX_FRAME];
 146         int rx_len;
 147         int rx_crcl, rx_crch;
 148 };
 149
 150 struct yam_mcs {
 151         unsigned char bits[YAM_FPGA_SIZE];
 152         int bitrate;
 153         struct yam_mcs *next;
 154 };
 155
 156 static struct net_device *yam_devs[NR_PORTS];
 157
 158 static struct yam_mcs *yam_data;
 159
 160 static char ax25_bcast[7] =
 161 {'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1};
 162 static char ax25_test[7] =
 163 {'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1};
 164
 165 static DEFINE_TIMER(yam_timer, NULL, 0, 0);
 166
 167 /* --------------------------------------------------------------------- */
 168
 169 #define RBR(iobase)     (iobase+0)
 170 #define THR(iobase)     (iobase+0)
 171 #define IER(iobase)     (iobase+1)
 172 #define IIR(iobase)     (iobase+2)
 173 #define FCR(iobase)     (iobase+2)
 174 #define LCR(iobase)     (iobase+3)
 175 #define MCR(iobase)     (iobase+4)
 176 #define LSR(iobase)     (iobase+5)
 177 #define MSR(iobase)     (iobase+6)
 178 #define SCR(iobase)     (iobase+7)
 179 #define DLL(iobase)     (iobase+0)
 180 #define DLM(iobase)     (iobase+1)
 181
 182 #define YAM_EXTENT      8
 183
 184 /* Interrupt Identification Register Bit Masks */
 185 #define IIR_NOPEND      1
 186 #define IIR_MSR         0
 187 #define IIR_TX          2
 188 #define IIR_RX          4
 189 #define IIR_LSR         6
 190 #define IIR_TIMEOUT     12                      /* Fifo mode only */
 191
 192 #define IIR_MASK        0x0F
 193
 194 /* Interrupt Enable Register Bit Masks */
 195 #define IER_RX          1                       /* enable rx interrupt */
 196 #define IER_TX          2                       /* enable tx interrupt */
 197 #define IER_LSR         4                       /* enable line status interrupts */
 198 #define IER_MSR         8                       /* enable modem status interrupts */
 199
 200 /* Modem Control Register Bit Masks */
 201 #define MCR_DTR         0x01                    /* DTR output */
 202 #define MCR_RTS         0x02                    /* RTS output */
 203 #define MCR_OUT1        0x04                    /* OUT1 output (not accessible in RS232) */
 204 #define MCR_OUT2        0x08                    /* Master Interrupt enable (must be set on PCs) */
 205 #define MCR_LOOP        0x10                    /* Loopback enable */
 206
 207 /* Modem Status Register Bit Masks */
 208 #define MSR_DCTS        0x01                    /* Delta CTS input */
 209 #define MSR_DDSR        0x02                    /* Delta DSR */
 210 #define MSR_DRIN        0x04                    /* Delta RI */
 211 #define MSR_DDCD        0x08                    /* Delta DCD */
 212 #define MSR_CTS         0x10                    /* CTS input */
 213 #define MSR_DSR         0x20                    /* DSR input */
 214 #define MSR_RING        0x40                    /* RI  input */
 215 #define MSR_DCD         0x80                    /* DCD input */
 216
 217 /* line status register bit mask */
 218 #define LSR_RXC         0x01
 219 #define LSR_OE          0x02
 220 #define LSR_PE          0x04
 221 #define LSR_FE          0x08
 222 #define LSR_BREAK       0x10
 223 #define LSR_THRE        0x20
 224 #define LSR_TSRE        0x40
 225
 226 /* Line Control Register Bit Masks */
 227 #define LCR_DLAB        0x80
 228 #define LCR_BREAK       0x40
 229 #define LCR_PZERO       0x28
 230 #define LCR_PEVEN       0x18
 231 #define LCR_PODD        0x08
 232 #define LCR_STOP1       0x00
 233 #define LCR_STOP2       0x04
 234 #define LCR_BIT5        0x00
 235 #define LCR_BIT6        0x02
 236 #define LCR_BIT7        0x01
 237 #define LCR_BIT8        0x03
 238
 239 /* YAM Modem <-> UART Port mapping */
 240
 241 #define TX_RDY          MSR_DCTS                /* transmitter ready to send */
 242 #define RX_DCD          MSR_DCD                 /* carrier detect */
 243 #define RX_FLAG         MSR_RING                /* hdlc flag received */
 244 #define FPGA_DONE       MSR_DSR                 /* FPGA is configured */
 245 #define PTT_ON          (MCR_RTS|MCR_OUT2)      /* activate PTT */
 246 #define PTT_OFF         (MCR_DTR|MCR_OUT2)      /* release PTT */
 247
 248 #define ENABLE_RXINT    IER_RX                  /* enable uart rx interrupt during rx */
 249 #define ENABLE_TXINT    IER_MSR                 /* enable uart ms interrupt during tx */
 250 #define ENABLE_RTXINT   (IER_RX|IER_MSR)        /* full duplex operations */
 251
 252
 253 /*************************************************************************
 254 * CRC Tables
 255 ************************************************************************/
 256
 257 static const unsigned char chktabl[256] =
 258 {0x00, 0x89, 0x12, 0x9b, 0x24, 0xad, 0x36, 0xbf, 0x48, 0xc1, 0x5a, 0xd3, 0x6c, 0xe5, 0x7e,
 259  0xf7, 0x81, 0x08, 0x93, 0x1a, 0xa5, 0x2c, 0xb7, 0x3e, 0xc9, 0x40, 0xdb, 0x52, 0xed, 0x64,
 260  0xff, 0x76, 0x02, 0x8b, 0x10, 0x99, 0x26, 0xaf, 0x34, 0xbd, 0x4a, 0xc3, 0x58, 0xd1, 0x6e,
 261  0xe7, 0x7c, 0xf5, 0x83, 0x0a, 0x91, 0x18, 0xa7, 0x2e, 0xb5, 0x3c, 0xcb, 0x42, 0xd9, 0x50,
 262  0xef, 0x66, 0xfd, 0x74, 0x04, 0x8d, 0x16, 0x9f, 0x20, 0xa9, 0x32, 0xbb, 0x4c, 0xc5, 0x5e,
 263  0xd7, 0x68, 0xe1, 0x7a, 0xf3, 0x85, 0x0c, 0x97, 0x1e, 0xa1, 0x28, 0xb3, 0x3a, 0xcd, 0x44,
 264  0xdf, 0x56, 0xe9, 0x60, 0xfb, 0x72, 0x06, 0x8f, 0x14, 0x9d, 0x22, 0xab, 0x30, 0xb9, 0x4e,
 265  0xc7, 0x5c, 0xd5, 0x6a, 0xe3, 0x78, 0xf1, 0x87, 0x0e, 0x95, 0x1c, 0xa3, 0x2a, 0xb1, 0x38,
 266  0xcf, 0x46, 0xdd, 0x54, 0xeb, 0x62, 0xf9, 0x70, 0x08, 0x81, 0x1a, 0x93, 0x2c, 0xa5, 0x3e,
 267  0xb7, 0x40, 0xc9, 0x52, 0xdb, 0x64, 0xed, 0x76, 0xff, 0x89, 0x00, 0x9b, 0x12, 0xad, 0x24,
 268  0xbf, 0x36, 0xc1, 0x48, 0xd3, 0x5a, 0xe5, 0x6c, 0xf7, 0x7e, 0x0a, 0x83, 0x18, 0x91, 0x2e,
 269  0xa7, 0x3c, 0xb5, 0x42, 0xcb, 0x50, 0xd9, 0x66, 0xef, 0x74, 0xfd, 0x8b, 0x02, 0x99, 0x10,
 270  0xaf, 0x26, 0xbd, 0x34, 0xc3, 0x4a, 0xd1, 0x58, 0xe7, 0x6e, 0xf5, 0x7c, 0x0c, 0x85, 0x1e,
 271  0x97, 0x28, 0xa1, 0x3a, 0xb3, 0x44, 0xcd, 0x56, 0xdf, 0x60, 0xe9, 0x72, 0xfb, 0x8d, 0x04,
 272  0x9f, 0x16, 0xa9, 0x20, 0xbb, 0x32, 0xc5, 0x4c, 0xd7, 0x5e, 0xe1, 0x68, 0xf3, 0x7a, 0x0e,
 273  0x87, 0x1c, 0x95, 0x2a, 0xa3, 0x38, 0xb1, 0x46, 0xcf, 0x54, 0xdd, 0x62, 0xeb, 0x70, 0xf9,
 274  0x8f, 0x06, 0x9d, 0x14, 0xab, 0x22, 0xb9, 0x30, 0xc7, 0x4e, 0xd5, 0x5c, 0xe3, 0x6a, 0xf1,
 275  0x78};
 276 static const unsigned char chktabh[256] =
 277 {0x00, 0x11, 0x23, 0x32, 0x46, 0x57, 0x65, 0x74, 0x8c, 0x9d, 0xaf, 0xbe, 0xca, 0xdb, 0xe9,
 278  0xf8, 0x10, 0x01, 0x33, 0x22, 0x56, 0x47, 0x75, 0x64, 0x9c, 0x8d, 0xbf, 0xae, 0xda, 0xcb,
 279  0xf9, 0xe8, 0x21, 0x30, 0x02, 0x13, 0x67, 0x76, 0x44, 0x55, 0xad, 0xbc, 0x8e, 0x9f, 0xeb,
 280  0xfa, 0xc8, 0xd9, 0x31, 0x20, 0x12, 0x03, 0x77, 0x66, 0x54, 0x45, 0xbd, 0xac, 0x9e, 0x8f,
 281  0xfb, 0xea, 0xd8, 0xc9, 0x42, 0x53, 0x61, 0x70, 0x04, 0x15, 0x27, 0x36, 0xce, 0xdf, 0xed,
 282  0xfc, 0x88, 0x99, 0xab, 0xba, 0x52, 0x43, 0x71, 0x60, 0x14, 0x05, 0x37, 0x26, 0xde, 0xcf,
 283  0xfd, 0xec, 0x98, 0x89, 0xbb, 0xaa, 0x63, 0x72, 0x40, 0x51, 0x25, 0x34, 0x06, 0x17, 0xef,
 284  0xfe, 0xcc, 0xdd, 0xa9, 0xb8, 0x8a, 0x9b, 0x73, 0x62, 0x50, 0x41, 0x35, 0x24, 0x16, 0x07,
 285  0xff, 0xee, 0xdc, 0xcd, 0xb9, 0xa8, 0x9a, 0x8b, 0x84, 0x95, 0xa7, 0xb6, 0xc2, 0xd3, 0xe1,
 286  0xf0, 0x08, 0x19, 0x2b, 0x3a, 0x4e, 0x5f, 0x6d, 0x7c, 0x94, 0x85, 0xb7, 0xa6, 0xd2, 0xc3,
 287  0xf1, 0xe0, 0x18, 0x09, 0x3b, 0x2a, 0x5e, 0x4f, 0x7d, 0x6c, 0xa5, 0xb4, 0x86, 0x97, 0xe3,
 288  0xf2, 0xc0, 0xd1, 0x29, 0x38, 0x0a, 0x1b, 0x6f, 0x7e, 0x4c, 0x5d, 0xb5, 0xa4, 0x96, 0x87,
 289  0xf3, 0xe2, 0xd0, 0xc1, 0x39, 0x28, 0x1a, 0x0b, 0x7f, 0x6e, 0x5c, 0x4d, 0xc6, 0xd7, 0xe5,
 290  0xf4, 0x80, 0x91, 0xa3, 0xb2, 0x4a, 0x5b, 0x69, 0x78, 0x0c, 0x1d, 0x2f, 0x3e, 0xd6, 0xc7,
 291  0xf5, 0xe4, 0x90, 0x81, 0xb3, 0xa2, 0x5a, 0x4b, 0x79, 0x68, 0x1c, 0x0d, 0x3f, 0x2e, 0xe7,
 292  0xf6, 0xc4, 0xd5, 0xa1, 0xb0, 0x82, 0x93, 0x6b, 0x7a, 0x48, 0x59, 0x2d, 0x3c, 0x0e, 0x1f,
 293  0xf7, 0xe6, 0xd4, 0xc5, 0xb1, 0xa0, 0x92, 0x83, 0x7b, 0x6a, 0x58, 0x49, 0x3d, 0x2c, 0x1e,
 294  0x0f};
 295
 296 /*************************************************************************
 297 * FPGA functions
 298 ************************************************************************/
 299
 300 static void delay(int ms)
 301 {
 302         unsigned long timeout = jiffies + ((ms * HZ) / 1000);
 303         while (time_before(jiffies, timeout))
 304                 cpu_relax();
 305 }
 306
 307 /*
 308  * reset FPGA
 309  */
 310
 311 static void fpga_reset(int iobase)
 312 {
 313         outb(0, IER(iobase));
 314         outb(LCR_DLAB | LCR_BIT5, LCR(iobase));
 315         outb(1, DLL(iobase));
 316         outb(0, DLM(iobase));
 317
 318         outb(LCR_BIT5, LCR(iobase));
 319         inb(LSR(iobase));
 320         inb(MSR(iobase));
 321         /* turn off FPGA supply voltage */
 322         outb(MCR_OUT1 | MCR_OUT2, MCR(iobase));
 323         delay(100);
 324         /* turn on FPGA supply voltage again */
 325         outb(MCR_DTR | MCR_RTS | MCR_OUT1 | MCR_OUT2, MCR(iobase));
 326         delay(100);
 327 }
 328
 329 /*
 330  * send one byte to FPGA
 331  */
 332
 333 static int fpga_write(int iobase, unsigned char wrd)
 334 {
 335         unsigned char bit;
 336         int k;
 337         unsigned long timeout = jiffies + HZ / 10;
 338
 339         for (k = 0; k < 8; k++) {
 340                 bit = (wrd & 0x80) ? (MCR_RTS | MCR_DTR) : MCR_DTR;
 341                 outb(bit | MCR_OUT1 | MCR_OUT2, MCR(iobase));
 342                 wrd <<= 1;
 343                 outb(0xfc, THR(iobase));
 344                 while ((inb(LSR(iobase)) & LSR_TSRE) == 0)
 345                         if (time_after(jiffies, timeout))
 346                                 return -1;
 347         }
 348
 349         return 0;
 350 }
 351
 352 static unsigned char *add_mcs(unsigned char *bits, int bitrate)
 353 {
 354         struct yam_mcs *p;
 355
 356         /* If it already exists, replace the bit data */
 357         p = yam_data;
 358         while (p) {
 359                 if (p->bitrate == bitrate) {
 360                         memcpy(p->bits, bits, YAM_FPGA_SIZE);
 361                         return p->bits;
 362                 }
 363                 p = p->next;
 364         }
 365
 366         /* Allocate a new mcs */
 367         if ((p = kmalloc(sizeof(struct yam_mcs), GFP_KERNEL)) == NULL) {
 368                 printk(KERN_WARNING "YAM: no memory to allocate mcs\n");
 369                 return NULL;
 370         }
 371         memcpy(p->bits, bits, YAM_FPGA_SIZE);
 372         p->bitrate = bitrate;
 373         p->next = yam_data;
 374         yam_data = p;
 375
 376         return p->bits;
 377 }
 378
 379 static unsigned char *get_mcs(int bitrate)
 380 {
 381         struct yam_mcs *p;
 382
 383         p = yam_data;
 384         while (p) {
 385                 if (p->bitrate == bitrate)
 386                         return p->bits;
 387                 p = p->next;
 388         }
 389
 390         /* Load predefined mcs data */
 391         switch (bitrate) {
 392         case 1200:
 393                 return add_mcs(bits_1200, bitrate);
 394         default:
 395                 return add_mcs(bits_9600, bitrate);
 396         }
 397 }
 398
 399 /*
 400  * download bitstream to FPGA
 401  * data is contained in bits[] array in yam1200.h resp. yam9600.h
 402  */
 403
 404 static int fpga_download(int iobase, int bitrate)
 405 {
 406         int i, rc;
 407         unsigned char *pbits;
 408
 409         pbits = get_mcs(bitrate);
 410         if (pbits == NULL)
 411                 return -1;
 412
 413         fpga_reset(iobase);
 414         for (i = 0; i < YAM_FPGA_SIZE; i++) {
 415                 if (fpga_write(iobase, pbits[i])) {
 416                         printk(KERN_ERR "yam: error in write cycle\n");
 417                         return -1;                      /* write... */
 418                 }
 419         }
 420
 421         fpga_write(iobase, 0xFF);
 422         rc = inb(MSR(iobase));          /* check DONE signal */
 423
 424         /* Needed for some hardwares */
 425         delay(50);
 426
 427         return (rc & MSR_DSR) ? 0 : -1;
 428 }
 429
 430
 431 /************************************************************************
 432 * Serial port init
 433 ************************************************************************/
 434
 435 static void yam_set_uart(struct net_device *dev)
 436 {
 437         struct yam_port *yp = netdev_priv(dev);
 438         int divisor = 115200 / yp->baudrate;
 439
 440         outb(0, IER(dev->base_addr));
 441         outb(LCR_DLAB | LCR_BIT8, LCR(dev->base_addr));
 442         outb(divisor, DLL(dev->base_addr));
 443         outb(0, DLM(dev->base_addr));
 444         outb(LCR_BIT8, LCR(dev->base_addr));
 445         outb(PTT_OFF, MCR(dev->base_addr));
 446         outb(0x00, FCR(dev->base_addr));
 447
 448         /* Flush pending irq */
 449
 450         inb(RBR(dev->base_addr));
 451         inb(MSR(dev->base_addr));
 452
 453         /* Enable rx irq */
 454
 455         outb(ENABLE_RTXINT, IER(dev->base_addr));
 456 }
 457
 458
 459 /* --------------------------------------------------------------------- */
 460
 461 enum uart {
 462         c_uart_unknown, c_uart_8250,
 463         c_uart_16450, c_uart_16550, c_uart_16550A
 464 };
 465
 466 static const char *uart_str[] =
 467 {"unknown", "8250", "16450", "16550", "16550A"};
 468
 469 static enum uart yam_check_uart(unsigned int iobase)
 470 {
 471         unsigned char b1, b2, b3;
 472         enum uart u;
 473         enum uart uart_tab[] =
 474         {c_uart_16450, c_uart_unknown, c_uart_16550, c_uart_16550A};
 475
 476         b1 = inb(MCR(iobase));
 477         outb(b1 | 0x10, MCR(iobase));   /* loopback mode */
 478         b2 = inb(MSR(iobase));
 479         outb(0x1a, MCR(iobase));
 480         b3 = inb(MSR(iobase)) & 0xf0;
 481         outb(b1, MCR(iobase));          /* restore old values */
 482         outb(b2, MSR(iobase));
 483         if (b3 != 0x90)
 484                 return c_uart_unknown;
 485         inb(RBR(iobase));
 486         inb(RBR(iobase));
 487         outb(0x01, FCR(iobase));        /* enable FIFOs */
 488         u = uart_tab[(inb(IIR(iobase)) >> 6) & 3];
 489         if (u == c_uart_16450) {
 490                 outb(0x5a, SCR(iobase));
 491                 b1 = inb(SCR(iobase));
 492                 outb(0xa5, SCR(iobase));
 493                 b2 = inb(SCR(iobase));
 494                 if ((b1 != 0x5a) || (b2 != 0xa5))
 495                         u = c_uart_8250;
 496         }
 497         return u;
 498 }
 499
 500 /******************************************************************************
 501 * Rx Section
 502 ******************************************************************************/
 503 static inline void yam_rx_flag(struct net_device *dev, struct yam_port *yp)
 504 {
 505         if (yp->dcd && yp->rx_len >= 3 && yp->rx_len < YAM_MAX_FRAME) {
 506                 int pkt_len = yp->rx_len - 2 + 1;       /* -CRC + kiss */
 507                 struct sk_buff *skb;
 508
 509                 if ((yp->rx_crch & yp->rx_crcl) != 0xFF) {
 510                         /* Bad crc */
 511                 } else {
 512                         if (!(skb = dev_alloc_skb(pkt_len))) {
 513                                 printk(KERN_WARNING "%s: memory squeeze, dropping packet\n", dev->name);
 514                                 ++yp->stats.rx_dropped;
 515                         } else {
 516                                 unsigned char *cp;
 517                                 cp = skb_put(skb, pkt_len);
 518                                 *cp++ = 0;              /* KISS kludge */
 519                                 memcpy(cp, yp->rx_buf, pkt_len - 1);
 520                                 skb->protocol = ax25_type_trans(skb, dev);
 521                                 netif_rx(skb);
 522                                 dev->last_rx = jiffies;
 523                                 ++yp->stats.rx_packets;
 524                         }
 525                 }
 526         }
 527         yp->rx_len = 0;
 528         yp->rx_crcl = 0x21;
 529         yp->rx_crch = 0xf3;
 530 }
 531
 532 static inline void yam_rx_byte(struct net_device *dev, struct yam_port *yp, unsigned char rxb)
 533 {
 534         if (yp->rx_len < YAM_MAX_FRAME) {
 535                 unsigned char c = yp->rx_crcl;
 536                 yp->rx_crcl = (chktabl[c] ^ yp->rx_crch);
 537                 yp->rx_crch = (chktabh[c] ^ rxb);
 538                 yp->rx_buf[yp->rx_len++] = rxb;
 539         }
 540 }
 541
 542 /********************************************************************************
 543 * TX Section
 544 ********************************************************************************/
 545
 546 static void ptt_on(struct net_device *dev)
 547 {
 548         outb(PTT_ON, MCR(dev->base_addr));
 549 }
 550
 551 static void ptt_off(struct net_device *dev)
 552 {
 553         outb(PTT_OFF, MCR(dev->base_addr));
 554 }
 555
 556 static int yam_send_packet(struct sk_buff *skb, struct net_device *dev)
 557 {
 558         struct yam_port *yp = netdev_priv(dev);
 559
 560         skb_queue_tail(&yp->send_queue, skb);
 561         dev->trans_start = jiffies;
 562         return 0;
 563 }
 564
 565 static void yam_start_tx(struct net_device *dev, struct yam_port *yp)
 566 {
 567         if ((yp->tx_state == TX_TAIL) || (yp->txd == 0))
 568                 yp->tx_count = 1;
 569         else
 570                 yp->tx_count = (yp->bitrate * yp->txd) / 8000;
 571         yp->tx_state = TX_HEAD;
 572         ptt_on(dev);
 573 }
 574
 575 static unsigned short random_seed;
 576
 577 static inline unsigned short random_num(void)
 578 {
 579         random_seed = 28629 * random_seed + 157;
 580         return random_seed;
 581 }
 582
 583 static void yam_arbitrate(struct net_device *dev)
 584 {
 585         struct yam_port *yp = netdev_priv(dev);
 586
 587         if (yp->magic != YAM_MAGIC || yp->tx_state != TX_OFF ||
 588             skb_queue_empty(&yp->send_queue))
 589                 return;
 590         /* tx_state is TX_OFF and there is data to send */
 591
 592         if (yp->dupmode) {
 593                 /* Full duplex mode, don't wait */
 594                 yam_start_tx(dev, yp);
 595                 return;
 596         }
 597         if (yp->dcd) {
 598                 /* DCD on, wait slotime ... */
 599                 yp->slotcnt = yp->slot / 10;
 600                 return;
 601         }
 602         /* Is slottime passed ? */
 603         if ((--yp->slotcnt) > 0)
 604                 return;
 605
 606         yp->slotcnt = yp->slot / 10;
 607
 608         /* is random > persist ? */
 609         if ((random_num() % 256) > yp->pers)
 610                 return;
 611
 612         yam_start_tx(dev, yp);
 613 }
 614
 615 static void yam_dotimer(unsigned long dummy)
 616 {
 617         int i;
 618
 619         for (i = 0; i < NR_PORTS; i++) {
 620                 struct net_device *dev = yam_devs[i];
 621                 if (dev && netif_running(dev))
 622                         yam_arbitrate(dev);
 623         }
 624         yam_timer.expires = jiffies + HZ / 100;
 625         add_timer(&yam_timer);
 626 }
 627
 628 static void yam_tx_byte(struct net_device *dev, struct yam_port *yp)
 629 {
 630         struct sk_buff *skb;
 631         unsigned char b, temp;
 632
 633         switch (yp->tx_state) {
 634         case TX_OFF:
 635                 break;
 636         case TX_HEAD:
 637                 if (--yp->tx_count <= 0) {
 638                         if (!(skb = skb_dequeue(&yp->send_queue))) {
 639                                 ptt_off(dev);
 640                                 yp->tx_state = TX_OFF;
 641                                 break;
 642                         }
 643                         yp->tx_state = TX_DATA;
 644                         if (skb->data[0] != 0) {
 645 /*                              do_kiss_params(s, skb->data, skb->len); */
 646                                 dev_kfree_skb_any(skb);
 647                                 break;
 648                         }
 649                         yp->tx_len = skb->len - 1;      /* strip KISS byte */
 650                         if (yp->tx_len >= YAM_MAX_FRAME || yp->tx_len < 2) {
 651                                 dev_kfree_skb_any(skb);
 652                                 break;
 653                         }
 654                         memcpy(yp->tx_buf, skb->data + 1, yp->tx_len);
 655                         dev_kfree_skb_any(skb);
 656                         yp->tx_count = 0;
 657                         yp->tx_crcl = 0x21;
 658                         yp->tx_crch = 0xf3;
 659                         yp->tx_state = TX_DATA;
 660                 }
 661                 break;
 662         case TX_DATA:
 663                 b = yp->tx_buf[yp->tx_count++];
 664                 outb(b, THR(dev->base_addr));
 665                 temp = yp->tx_crcl;
 666                 yp->tx_crcl = chktabl[temp] ^ yp->tx_crch;
 667                 yp->tx_crch = chktabh[temp] ^ b;
 668                 if (yp->tx_count >= yp->tx_len) {
 669                         yp->tx_state = TX_CRC1;
 670                 }
 671                 break;
 672         case TX_CRC1:
 673                 yp->tx_crch = chktabl[yp->tx_crcl] ^ yp->tx_crch;
 674                 yp->tx_crcl = chktabh[yp->tx_crcl] ^ chktabl[yp->tx_crch] ^ 0xff;
 675                 outb(yp->tx_crcl, THR(dev->base_addr));
 676                 yp->tx_state = TX_CRC2;
 677                 break;
 678         case TX_CRC2:
 679                 outb(chktabh[yp->tx_crch] ^ 0xFF, THR(dev->base_addr));
 680                 if (skb_queue_empty(&yp->send_queue)) {
 681                         yp->tx_count = (yp->bitrate * yp->txtail) / 8000;
 682                         if (yp->dupmode == 2)
 683                                 yp->tx_count += (yp->bitrate * yp->holdd) / 8;
 684                         if (yp->tx_count == 0)
 685                                 yp->tx_count = 1;
 686                         yp->tx_state = TX_TAIL;
 687                 } else {
 688                         yp->tx_count = 1;
 689                         yp->tx_state = TX_HEAD;
 690                 }
 691                 ++yp->stats.tx_packets;
 692                 break;
 693         case TX_TAIL:
 694                 if (--yp->tx_count <= 0) {
 695                         yp->tx_state = TX_OFF;
 696                         ptt_off(dev);
 697                 }
 698                 break;
 699         }
 700 }
 701
 702 /***********************************************************************************
 703 * ISR routine
 704 ************************************************************************************/
 705
 706 static irqreturn_t yam_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 707 {
 708         struct net_device *dev;
 709         struct yam_port *yp;
 710         unsigned char iir;
 711         int counter = 100;
 712         int i;
 713         int handled = 0;
 714
 715         for (i = 0; i < NR_PORTS; i++) {
 716                 dev = yam_devs[i];
 717                 yp = netdev_priv(dev);
 718
 719                 if (!netif_running(dev))
 720                         continue;
 721
 722                 while ((iir = IIR_MASK & inb(IIR(dev->base_addr))) != IIR_NOPEND) {
 723                         unsigned char msr = inb(MSR(dev->base_addr));
 724                         unsigned char lsr = inb(LSR(dev->base_addr));
 725                         unsigned char rxb;
 726
 727                         handled = 1;
 728
 729                         if (lsr & LSR_OE)
 730                                 ++yp->stats.rx_fifo_errors;
 731
 732                         yp->dcd = (msr & RX_DCD) ? 1 : 0;
 733
 734                         if (--counter <= 0) {
 735                                 printk(KERN_ERR "%s: too many irq iir=%d\n",
 736                                                 dev->name, iir);
 737                                 goto out;
 738                         }
 739                         if (msr & TX_RDY) {
 740                                 ++yp->nb_mdint;
 741                                 yam_tx_byte(dev, yp);
 742                         }
 743                         if (lsr & LSR_RXC) {
 744                                 ++yp->nb_rxint;
 745                                 rxb = inb(RBR(dev->base_addr));
 746                                 if (msr & RX_FLAG)
 747                                         yam_rx_flag(dev, yp);
 748                                 else
 749                                         yam_rx_byte(dev, yp, rxb);
 750                         }
 751                 }
 752         }
 753 out:
 754         return IRQ_RETVAL(handled);
 755 }
 756
 757 #ifdef CONFIG_PROC_FS
 758
 759 static void *yam_seq_start(struct seq_file *seq, loff_t *pos)
 760 {
 761         return (*pos < NR_PORTS) ? yam_devs[*pos] : NULL;
 762 }
 763
 764 static void *yam_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 765 {
 766         ++*pos;
 767         return (*pos < NR_PORTS) ? yam_devs[*pos] : NULL;
 768 }
 769
 770 static void yam_seq_stop(struct seq_file *seq, void *v)
 771 {
 772 }
 773
 774 static int yam_seq_show(struct seq_file *seq, void *v)
 775 {
 776         struct net_device *dev = v;
 777         const struct yam_port *yp = netdev_priv(dev);
 778
 779         seq_printf(seq, "Device %s\n", dev->name);
 780         seq_printf(seq, "  Up       %d\n", netif_running(dev));
 781         seq_printf(seq, "  Speed    %u\n", yp->bitrate);
 782         seq_printf(seq, "  IoBase   0x%x\n", yp->iobase);
 783         seq_printf(seq, "  BaudRate %u\n", yp->baudrate);
 784         seq_printf(seq, "  IRQ      %u\n", yp->irq);
 785         seq_printf(seq, "  TxState  %u\n", yp->tx_state);
 786         seq_printf(seq, "  Duplex   %u\n", yp->dupmode);
 787         seq_printf(seq, "  HoldDly  %u\n", yp->holdd);
 788         seq_printf(seq, "  TxDelay  %u\n", yp->txd);
 789         seq_printf(seq, "  TxTail   %u\n", yp->txtail);
 790         seq_printf(seq, "  SlotTime %u\n", yp->slot);
 791         seq_printf(seq, "  Persist  %u\n", yp->pers);
 792         seq_printf(seq, "  TxFrames %lu\n", yp->stats.tx_packets);
 793         seq_printf(seq, "  RxFrames %lu\n", yp->stats.rx_packets);
 794         seq_printf(seq, "  TxInt    %u\n", yp->nb_mdint);
 795         seq_printf(seq, "  RxInt    %u\n", yp->nb_rxint);
 796         seq_printf(seq, "  RxOver   %lu\n", yp->stats.rx_fifo_errors);
 797         seq_printf(seq, "\n");
 798         return 0;
 799 }
 800
 801 static struct seq_operations yam_seqops = {
 802         .start = yam_seq_start,
 803         .next = yam_seq_next,
 804         .stop = yam_seq_stop,
 805         .show = yam_seq_show,
 806 };
 807
 808 static int yam_info_open(struct inode *inode, struct file *file)
 809 {
 810         return seq_open(file, &yam_seqops);
 811 }
 812
 813 static struct file_operations yam_info_fops = {
 814         .owner = THIS_MODULE,
 815         .open = yam_info_open,
 816         .read = seq_read,
 817         .llseek = seq_lseek,
 818         .release = seq_release,
 819 };
 820
 821 #endif
 822
 823
 824 /* --------------------------------------------------------------------- */
 825
 826 static struct net_device_stats *yam_get_stats(struct net_device *dev)
 827 {
 828         struct yam_port *yp;
 829
 830         if (!dev)
 831                 return NULL;
 832
 833         yp = netdev_priv(dev);
 834         if (yp->magic != YAM_MAGIC)
 835                 return NULL;
 836
 837         /*
 838          * Get the current statistics.  This may be called with the
 839          * card open or closed.
 840          */
 841         return &yp->stats;
 842 }
 843
 844 /* --------------------------------------------------------------------- */
 845
 846 static int yam_open(struct net_device *dev)
 847 {
 848         struct yam_port *yp = netdev_priv(dev);
 849         enum uart u;
 850         int i;
 851         int ret=0;
 852
 853         printk(KERN_INFO "Trying %s at iobase 0x%lx irq %u\n", dev->name, dev->base_addr, dev->irq);
 854
 855         if (!dev || !yp->bitrate)
 856                 return -ENXIO;
 857         if (!dev->base_addr || dev->base_addr > 0x1000 - YAM_EXTENT ||
 858                 dev->irq < 2 || dev->irq > 15) {
 859                 return -ENXIO;
 860         }
 861         if (!request_region(dev->base_addr, YAM_EXTENT, dev->name))
 862         {
 863                 printk(KERN_ERR "%s: cannot 0x%lx busy\n", dev->name, dev->base_addr);
 864                 return -EACCES;
 865         }
 866         if ((u = yam_check_uart(dev->base_addr)) == c_uart_unknown) {
 867                 printk(KERN_ERR "%s: cannot find uart type\n", dev->name);
 868                 ret = -EIO;
 869                 goto out_release_base;
 870         }
 871         if (fpga_download(dev->base_addr, yp->bitrate)) {
 872                 printk(KERN_ERR "%s: cannot init FPGA\n", dev->name);
 873                 ret = -EIO;
 874                 goto out_release_base;
 875         }
 876         outb(0, IER(dev->base_addr));
 877         if (request_irq(dev->irq, yam_interrupt, SA_INTERRUPT | SA_SHIRQ, dev->name, dev)) {
 878                 printk(KERN_ERR "%s: irq %d busy\n", dev->name, dev->irq);
 879                 ret = -EBUSY;
 880                 goto out_release_base;
 881         }
 882
 883         yam_set_uart(dev);
 884
 885         netif_start_queue(dev);
 886
 887         yp->slotcnt = yp->slot / 10;
 888
 889         /* Reset overruns for all ports - FPGA programming makes overruns */
 890         for (i = 0; i < NR_PORTS; i++) {
 891                 struct net_device *dev = yam_devs[i];
 892                 struct yam_port *yp = netdev_priv(dev);
 893                 inb(LSR(dev->base_addr));
 894                 yp->stats.rx_fifo_errors = 0;
 895         }
 896
 897         printk(KERN_INFO "%s at iobase 0x%lx irq %u uart %s\n", dev->name, dev->base_addr, dev->irq,
 898                    uart_str[u]);
 899         return 0;
 900
 901 out_release_base:
 902         release_region(dev->base_addr, YAM_EXTENT);
 903         return ret;
 904 }
 905
 906 /* --------------------------------------------------------------------- */
 907
 908 static int yam_close(struct net_device *dev)
 909 {
 910         struct sk_buff *skb;
 911         struct yam_port *yp = netdev_priv(dev);
 912
 913         if (!dev)
 914                 return -EINVAL;
 915
 916         /*
 917          * disable interrupts
 918          */
 919         outb(0, IER(dev->base_addr));
 920         outb(1, MCR(dev->base_addr));
 921         /* Remove IRQ handler if last */
 922         free_irq(dev->irq,dev);
 923         release_region(dev->base_addr, YAM_EXTENT);
 924         netif_stop_queue(dev);
 925         while ((skb = skb_dequeue(&yp->send_queue)))
 926                 dev_kfree_skb(skb);
 927
 928         printk(KERN_INFO "%s: close yam at iobase 0x%lx irq %u\n",
 929                    yam_drvname, dev->base_addr, dev->irq);
 930         return 0;
 931 }
 932
 933 /* --------------------------------------------------------------------- */
 934
 935 static int yam_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 936 {
 937         struct yam_port *yp = netdev_priv(dev);
 938         struct yamdrv_ioctl_cfg yi;
 939         struct yamdrv_ioctl_mcs *ym;
 940         int ioctl_cmd;
 941
 942         if (copy_from_user(&ioctl_cmd, ifr->ifr_data, sizeof(int)))
 943                  return -EFAULT;
 944
 945         if (yp->magic != YAM_MAGIC)
 946                 return -EINVAL;
 947
 948         if (!capable(CAP_NET_ADMIN))
 949                 return -EPERM;
 950
 951         if (cmd != SIOCDEVPRIVATE)
 952                 return -EINVAL;
 953
 954         switch (ioctl_cmd) {
 955
 956         case SIOCYAMRESERVED:
 957                 return -EINVAL;                 /* unused */
 958
 959         case SIOCYAMSMCS:
 960                 if (netif_running(dev))
 961                         return -EINVAL;         /* Cannot change this parameter when up */
 962                 if ((ym = kmalloc(sizeof(struct yamdrv_ioctl_mcs), GFP_KERNEL)) == NULL)
 963                         return -ENOBUFS;
 964                 ym->bitrate = 9600;
 965                 if (copy_from_user(ym, ifr->ifr_data, sizeof(struct yamdrv_ioctl_mcs))) {
 966                         kfree(ym);
 967                         return -EFAULT;
 968                 }
 969                 if (ym->bitrate > YAM_MAXBITRATE) {
 970                         kfree(ym);
 971                         return -EINVAL;
 972                 }
 973                 add_mcs(ym->bits, ym->bitrate);
 974                 kfree(ym);
 975                 break;
 976
 977         case SIOCYAMSCFG:
 978                 if (!capable(CAP_SYS_RAWIO))
 979                         return -EPERM;
 980                 if (copy_from_user(&yi, ifr->ifr_data, sizeof(struct yamdrv_ioctl_cfg)))
 981                          return -EFAULT;
 982
 983                 if ((yi.cfg.mask & YAM_IOBASE) && netif_running(dev))
 984                         return -EINVAL;         /* Cannot change this parameter when up */
 985                 if ((yi.cfg.mask & YAM_IRQ) && netif_running(dev))
 986                         return -EINVAL;         /* Cannot change this parameter when up */
 987                 if ((yi.cfg.mask & YAM_BITRATE) && netif_running(dev))
 988                         return -EINVAL;         /* Cannot change this parameter when up */
 989                 if ((yi.cfg.mask & YAM_BAUDRATE) && netif_running(dev))
 990                         return -EINVAL;         /* Cannot change this parameter when up */
 991
 992                 if (yi.cfg.mask & YAM_IOBASE) {
 993                         yp->iobase = yi.cfg.iobase;
 994                         dev->base_addr = yi.cfg.iobase;
 995                 }
 996                 if (yi.cfg.mask & YAM_IRQ) {
 997                         if (yi.cfg.irq > 15)
 998                                 return -EINVAL;
 999                         yp->irq = yi.cfg.irq;
1000                         dev->irq = yi.cfg.irq;
1001                 }
1002                 if (yi.cfg.mask & YAM_BITRATE) {
1003                         if (yi.cfg.bitrate > YAM_MAXBITRATE)
1004                                 return -EINVAL;
1005                         yp->bitrate = yi.cfg.bitrate;
1006                 }
1007                 if (yi.cfg.mask & YAM_BAUDRATE) {
1008                         if (yi.cfg.baudrate > YAM_MAXBAUDRATE)
1009                                 return -EINVAL;
1010                         yp->baudrate = yi.cfg.baudrate;
1011                 }
1012                 if (yi.cfg.mask & YAM_MODE) {
1013                         if (yi.cfg.mode > YAM_MAXMODE)
1014                                 return -EINVAL;
1015                         yp->dupmode = yi.cfg.mode;
1016                 }
1017                 if (yi.cfg.mask & YAM_HOLDDLY) {
1018                         if (yi.cfg.holddly > YAM_MAXHOLDDLY)
1019                                 return -EINVAL;
1020                         yp->holdd = yi.cfg.holddly;
1021                 }
1022                 if (yi.cfg.mask & YAM_TXDELAY) {
1023                         if (yi.cfg.txdelay > YAM_MAXTXDELAY)
1024                                 return -EINVAL;
1025                         yp->txd = yi.cfg.txdelay;
1026                 }
1027                 if (yi.cfg.mask & YAM_TXTAIL) {
1028                         if (yi.cfg.txtail > YAM_MAXTXTAIL)
1029                                 return -EINVAL;
1030                         yp->txtail = yi.cfg.txtail;
1031                 }
1032                 if (yi.cfg.mask & YAM_PERSIST) {
1033                         if (yi.cfg.persist > YAM_MAXPERSIST)
1034                                 return -EINVAL;
1035                         yp->pers = yi.cfg.persist;
1036                 }
1037                 if (yi.cfg.mask & YAM_SLOTTIME) {
1038                         if (yi.cfg.slottime > YAM_MAXSLOTTIME)
1039                                 return -EINVAL;
1040                         yp->slot = yi.cfg.slottime;
1041                         yp->slotcnt = yp->slot / 10;
1042                 }
1043                 break;
1044
1045         case SIOCYAMGCFG:
1046                 yi.cfg.mask = 0xffffffff;
1047                 yi.cfg.iobase = yp->iobase;
1048                 yi.cfg.irq = yp->irq;
1049                 yi.cfg.bitrate = yp->bitrate;
1050                 yi.cfg.baudrate = yp->baudrate;
1051                 yi.cfg.mode = yp->dupmode;
1052                 yi.cfg.txdelay = yp->txd;
1053                 yi.cfg.holddly = yp->holdd;
1054                 yi.cfg.txtail = yp->txtail;
1055                 yi.cfg.persist = yp->pers;
1056                 yi.cfg.slottime = yp->slot;
1057                 if (copy_to_user(ifr->ifr_data, &yi, sizeof(struct yamdrv_ioctl_cfg)))
1058                          return -EFAULT;
1059                 break;
1060
1061         default:
1062                 return -EINVAL;
1063
1064         }
1065
1066         return 0;
1067 }
1068
1069 /* --------------------------------------------------------------------- */
1070
1071 static int yam_set_mac_address(struct net_device *dev, void *addr)
1072 {
1073         struct sockaddr *sa = (struct sockaddr *) addr;
1074
1075         /* addr is an AX.25 shifted ASCII mac address */
1076         memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
1077         return 0;
1078 }
1079
1080 /* --------------------------------------------------------------------- */
1081
1082 static void yam_setup(struct net_device *dev)
1083 {
1084         struct yam_port *yp = netdev_priv(dev);
1085
1086         yp->magic = YAM_MAGIC;
1087         yp->bitrate = DEFAULT_BITRATE;
1088         yp->baudrate = DEFAULT_BITRATE * 2;
1089         yp->iobase = 0;
1090         yp->irq = 0;
1091         yp->dupmode = 0;
1092         yp->holdd = DEFAULT_HOLDD;
1093         yp->txd = DEFAULT_TXD;
1094         yp->txtail = DEFAULT_TXTAIL;
1095         yp->slot = DEFAULT_SLOT;
1096         yp->pers = DEFAULT_PERS;
1097         yp->dev = dev;
1098
1099         dev->base_addr = yp->iobase;
1100         dev->irq = yp->irq;
1101         SET_MODULE_OWNER(dev);
1102
1103         dev->open = yam_open;
1104         dev->stop = yam_close;
1105         dev->do_ioctl = yam_ioctl;
1106         dev->hard_start_xmit = yam_send_packet;
1107         dev->get_stats = yam_get_stats;
1108
1109         skb_queue_head_init(&yp->send_queue);
1110
1111         dev->hard_header = ax25_hard_header;
1112         dev->rebuild_header = ax25_rebuild_header;
1113
1114         dev->set_mac_address = yam_set_mac_address;
1115
1116         dev->type = ARPHRD_AX25;
1117         dev->hard_header_len = AX25_MAX_HEADER_LEN;
1118         dev->mtu = AX25_MTU;
1119         dev->addr_len = AX25_ADDR_LEN;
1120         memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
1121         memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
1122 }
1123
1124 static int __init yam_init_driver(void)
1125 {
1126         struct net_device *dev;
1127         int i, err;
1128         char name[IFNAMSIZ];
1129
1130         printk(yam_drvinfo);
1131
1132         for (i = 0; i < NR_PORTS; i++) {
1133                 sprintf(name, "yam%d", i);
1134
1135                 dev = alloc_netdev(sizeof(struct yam_port), name,
1136                                    yam_setup);
1137                 if (!dev) {
1138                         printk(KERN_ERR "yam: cannot allocate net device %s\n",
1139                                dev->name);
1140                         err = -ENOMEM;
1141                         goto error;
1142                 }
1143
1144                 err = register_netdev(dev);
1145                 if (err) {
1146                         printk(KERN_WARNING "yam: cannot register net device %s\n", dev->name);
1147                         goto error;
1148                 }
1149                 yam_devs[i] = dev;
1150
1151         }
1152
1153         yam_timer.function = yam_dotimer;
1154         yam_timer.expires = jiffies + HZ / 100;
1155         add_timer(&yam_timer);
1156
1157         proc_net_fops_create("yam", S_IRUGO, &yam_info_fops);
1158         return 0;
1159  error:
1160         while (--i >= 0) {
1161                 unregister_netdev(yam_devs[i]);
1162                 free_netdev(yam_devs[i]);
1163         }
1164         return err;
1165 }
1166
1167 /* --------------------------------------------------------------------- */
1168
1169 static void __exit yam_cleanup_driver(void)
1170 {
1171         struct yam_mcs *p;
1172         int i;
1173
1174         del_timer(&yam_timer);
1175         for (i = 0; i < NR_PORTS; i++) {
1176                 struct net_device *dev = yam_devs[i];
1177                 if (dev) {
1178                         unregister_netdev(dev);
1179                         free_netdev(dev);
1180                 }
1181         }
1182
1183         while (yam_data) {
1184                 p = yam_data;
1185                 yam_data = yam_data->next;
1186                 kfree(p);
1187         }
1188
1189         proc_net_remove("yam");
1190 }
1191
1192 /* --------------------------------------------------------------------- */
1193
1194 MODULE_AUTHOR("Frederic Rible F1OAT frible@teaser.fr");
1195 MODULE_DESCRIPTION("Yam amateur radio modem driver");
1196 MODULE_LICENSE("GPL");
1197
1198 module_init(yam_init_driver);
1199 module_exit(yam_cleanup_driver);
1200
1201 /* --------------------------------------------------------------------- */
1202