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