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