1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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
79static const char yam_drvname[] = "yam";
80static 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
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
102#define DEFAULT_HOLDD 10
103#define DEFAULT_TXD 300
104#define DEFAULT_TXTAIL 10
105#define DEFAULT_SLOT 100
106#define DEFAULT_PERS 64
107
108struct 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
119
120 struct net_device_stats stats;
121
122 int nb_rxint;
123 int nb_mdint;
124
125
126
127 int txd;
128 int holdd;
129 int txtail;
130 int slot;
131 int pers;
132
133
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;
142
143
144
145 int dcd;
146 unsigned char rx_buf[YAM_MAX_FRAME];
147 int rx_len;
148 int rx_crcl, rx_crch;
149};
150
151struct yam_mcs {
152 unsigned char bits[YAM_FPGA_SIZE];
153 int bitrate;
154 struct yam_mcs *next;
155};
156
157static struct net_device *yam_devs[NR_PORTS];
158
159static struct yam_mcs *yam_data;
160
161static 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
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
187
188#define IIR_MASK 0x0F
189
190
191#define IER_RX 1
192#define IER_TX 2
193#define IER_LSR 4
194#define IER_MSR 8
195
196
197#define MCR_DTR 0x01
198#define MCR_RTS 0x02
199#define MCR_OUT1 0x04
200#define MCR_OUT2 0x08
201#define MCR_LOOP 0x10
202
203
204#define MSR_DCTS 0x01
205#define MSR_DDSR 0x02
206#define MSR_DRIN 0x04
207#define MSR_DDCD 0x08
208#define MSR_CTS 0x10
209#define MSR_DSR 0x20
210#define MSR_RING 0x40
211#define MSR_DCD 0x80
212
213
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
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
236
237#define TX_RDY MSR_DCTS
238#define RX_DCD MSR_DCD
239#define RX_FLAG MSR_RING
240#define FPGA_DONE MSR_DSR
241#define PTT_ON (MCR_RTS|MCR_OUT2)
242#define PTT_OFF (MCR_DTR|MCR_OUT2)
243
244#define ENABLE_RXINT IER_RX
245#define ENABLE_TXINT IER_MSR
246#define ENABLE_RTXINT (IER_RX|IER_MSR)
247
248
249
250
251
252
253static 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};
272static 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
294
295
296static 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
305
306
307static 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
318 outb(MCR_OUT1 | MCR_OUT2, MCR(iobase));
319 delay(100);
320
321 outb(MCR_DTR | MCR_RTS | MCR_OUT1 | MCR_OUT2, MCR(iobase));
322 delay(100);
323}
324
325
326
327
328
329static 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
348static unsigned char *add_mcs(unsigned char *bits, int bitrate)
349{
350 struct yam_mcs *p;
351
352
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
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
375static 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
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
397
398
399
400static 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;
414 }
415 }
416
417 fpga_write(iobase, 0xFF);
418 rc = inb(MSR(iobase));
419
420
421 delay(50);
422
423 return (rc & MSR_DSR) ? 0 : -1;
424}
425
426
427
428
429
430
431static 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
445
446 inb(RBR(dev->base_addr));
447 inb(MSR(dev->base_addr));
448
449
450
451 outb(ENABLE_RTXINT, IER(dev->base_addr));
452}
453
454
455
456
457enum uart {
458 c_uart_unknown, c_uart_8250,
459 c_uart_16450, c_uart_16550, c_uart_16550A
460};
461
462static const char *uart_str[] =
463{"unknown", "8250", "16450", "16550", "16550A"};
464
465static 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));
474 b2 = inb(MSR(iobase));
475 outb(0x1a, MCR(iobase));
476 b3 = inb(MSR(iobase)) & 0xf0;
477 outb(b1, MCR(iobase));
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));
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
498
499static 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;
503 struct sk_buff *skb;
504
505 if ((yp->rx_crch & yp->rx_crcl) != 0xFF) {
506
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;
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
528static 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
540
541
542static void ptt_on(struct net_device *dev)
543{
544 outb(PTT_ON, MCR(dev->base_addr));
545}
546
547static void ptt_off(struct net_device *dev)
548{
549 outb(PTT_OFF, MCR(dev->base_addr));
550}
551
552static 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
561static 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
571static 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
579
580 if (yp->dupmode) {
581
582 yam_start_tx(dev, yp);
583 return;
584 }
585 if (yp->dcd) {
586
587 yp->slotcnt = yp->slot / 10;
588 return;
589 }
590
591 if ((--yp->slotcnt) > 0)
592 return;
593
594 yp->slotcnt = yp->slot / 10;
595
596
597 if ((random32() % 256) > yp->pers)
598 return;
599
600 yam_start_tx(dev, yp);
601}
602
603static 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
616static 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
634 dev_kfree_skb_any(skb);
635 break;
636 }
637 yp->tx_len = skb->len - 1;
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
694
695
696static 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 }
743out:
744 return IRQ_RETVAL(handled);
745}
746
747#ifdef CONFIG_PROC_FS
748
749static void *yam_seq_start(struct seq_file *seq, loff_t *pos)
750{
751 return (*pos < NR_PORTS) ? yam_devs[*pos] : NULL;
752}
753
754static 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
760static void yam_seq_stop(struct seq_file *seq, void *v)
761{
762}
763
764static 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
791static 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
798static int yam_info_open(struct inode *inode, struct file *file)
799{
800 return seq_open(file, &yam_seqops);
801}
802
803static 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
816static 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
829
830
831 return &yp->stats;
832}
833
834
835
836static 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
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
891out_release_base:
892 release_region(dev->base_addr, YAM_EXTENT);
893 return ret;
894}
895
896
897
898static 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
908
909 outb(0, IER(dev->base_addr));
910 outb(1, MCR(dev->base_addr));
911
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
925static 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;
948
949 case SIOCYAMSMCS:
950 if (netif_running(dev))
951 return -EINVAL;
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;
975 if ((yi.cfg.mask & YAM_IRQ) && netif_running(dev))
976 return -EINVAL;
977 if ((yi.cfg.mask & YAM_BITRATE) && netif_running(dev))
978 return -EINVAL;
979 if ((yi.cfg.mask & YAM_BAUDRATE) && netif_running(dev))
980 return -EINVAL;
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
1061static int yam_set_mac_address(struct net_device *dev, void *addr)
1062{
1063 struct sockaddr *sa = (struct sockaddr *) addr;
1064
1065
1066 memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
1067 return 0;
1068}
1069
1070
1071
1072static 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
1112static 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
1157static 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
1182MODULE_AUTHOR("Frederic Rible F1OAT frible@teaser.fr");
1183MODULE_DESCRIPTION("Yam amateur radio modem driver");
1184MODULE_LICENSE("GPL");
1185
1186module_init(yam_init_driver);
1187module_exit(yam_cleanup_driver);
1188
1189
1190