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