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