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