projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[SK_BUFF]: Introduce skb_copy_from_linear_data{_offset}
[deliverable/linux.git] / drivers / net / hamradio / dmascc.c
1 /*
2 * Driver for high-speed SCC boards (those with DMA support)
3 * Copyright (C) 1997-2000 Klaus Kudielka
4 *
5 * S5SCC/DMA support by Janko Koleznik S52HI
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22
23 #include <linux/module.h>
24 #include <linux/delay.h>
25 #include <linux/errno.h>
26 #include <linux/if_arp.h>
27 #include <linux/in.h>
28 #include <linux/init.h>
29 #include <linux/interrupt.h>
30 #include <linux/ioport.h>
31 #include <linux/kernel.h>
32 #include <linux/mm.h>
33 #include <linux/netdevice.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/sockios.h>
36 #include <linux/workqueue.h>
37 #include <asm/atomic.h>
38 #include <asm/bitops.h>
39 #include <asm/dma.h>
40 #include <asm/io.h>
41 #include <asm/irq.h>
42 #include <asm/uaccess.h>
43 #include <net/ax25.h>
44 #include "z8530.h"
45
46
47 /* Number of buffers per channel */
48
49 #define NUM_TX_BUF 2 /* NUM_TX_BUF >= 1 (min. 2 recommended) */
50 #define NUM_RX_BUF 6 /* NUM_RX_BUF >= 1 (min. 2 recommended) */
51 #define BUF_SIZE 1576 /* BUF_SIZE >= mtu + hard_header_len */
52
53
54 /* Cards supported */
55
56 #define HW_PI { "Ottawa PI", 0x300, 0x20, 0x10, 8, \
57 0, 8, 1843200, 3686400 }
58 #define HW_PI2 { "Ottawa PI2", 0x300, 0x20, 0x10, 8, \
59 0, 8, 3686400, 7372800 }
60 #define HW_TWIN { "Gracilis PackeTwin", 0x200, 0x10, 0x10, 32, \
61 0, 4, 6144000, 6144000 }
62 #define HW_S5 { "S5SCC/DMA", 0x200, 0x10, 0x10, 32, \
63 0, 8, 4915200, 9830400 }
64
65 #define HARDWARE { HW_PI, HW_PI2, HW_TWIN, HW_S5 }
66
67 #define TMR_0_HZ 25600 /* Frequency of timer 0 */
68
69 #define TYPE_PI 0
70 #define TYPE_PI2 1
71 #define TYPE_TWIN 2
72 #define TYPE_S5 3
73 #define NUM_TYPES 4
74
75 #define MAX_NUM_DEVS 32
76
77
78 /* SCC chips supported */
79
80 #define Z8530 0
81 #define Z85C30 1
82 #define Z85230 2
83
84 #define CHIPNAMES { "Z8530", "Z85C30", "Z85230" }
85
86
87 /* I/O registers */
88
89 /* 8530 registers relative to card base */
90 #define SCCB_CMD 0x00
91 #define SCCB_DATA 0x01
92 #define SCCA_CMD 0x02
93 #define SCCA_DATA 0x03
94
95 /* 8253/8254 registers relative to card base */
96 #define TMR_CNT0 0x00
97 #define TMR_CNT1 0x01
98 #define TMR_CNT2 0x02
99 #define TMR_CTRL 0x03
100
101 /* Additional PI/PI2 registers relative to card base */
102 #define PI_DREQ_MASK 0x04
103
104 /* Additional PackeTwin registers relative to card base */
105 #define TWIN_INT_REG 0x08
106 #define TWIN_CLR_TMR1 0x09
107 #define TWIN_CLR_TMR2 0x0a
108 #define TWIN_SPARE_1 0x0b
109 #define TWIN_DMA_CFG 0x08
110 #define TWIN_SERIAL_CFG 0x09
111 #define TWIN_DMA_CLR_FF 0x0a
112 #define TWIN_SPARE_2 0x0b
113
114
115 /* PackeTwin I/O register values */
116
117 /* INT_REG */
118 #define TWIN_SCC_MSK 0x01
119 #define TWIN_TMR1_MSK 0x02
120 #define TWIN_TMR2_MSK 0x04
121 #define TWIN_INT_MSK 0x07
122
123 /* SERIAL_CFG */
124 #define TWIN_DTRA_ON 0x01
125 #define TWIN_DTRB_ON 0x02
126 #define TWIN_EXTCLKA 0x04
127 #define TWIN_EXTCLKB 0x08
128 #define TWIN_LOOPA_ON 0x10
129 #define TWIN_LOOPB_ON 0x20
130 #define TWIN_EI 0x80
131
132 /* DMA_CFG */
133 #define TWIN_DMA_HDX_T1 0x08
134 #define TWIN_DMA_HDX_R1 0x0a
135 #define TWIN_DMA_HDX_T3 0x14
136 #define TWIN_DMA_HDX_R3 0x16
137 #define TWIN_DMA_FDX_T3R1 0x1b
138 #define TWIN_DMA_FDX_T1R3 0x1d
139
140
141 /* Status values */
142
143 #define IDLE 0
144 #define TX_HEAD 1
145 #define TX_DATA 2
146 #define TX_PAUSE 3
147 #define TX_TAIL 4
148 #define RTS_OFF 5
149 #define WAIT 6
150 #define DCD_ON 7
151 #define RX_ON 8
152 #define DCD_OFF 9
153
154
155 /* Ioctls */
156
157 #define SIOCGSCCPARAM SIOCDEVPRIVATE
158 #define SIOCSSCCPARAM (SIOCDEVPRIVATE+1)
159
160
161 /* Data types */
162
163 struct scc_param {
164 int pclk_hz; /* frequency of BRG input (don't change) */
165 int brg_tc; /* BRG terminal count; BRG disabled if < 0 */
166 int nrzi; /* 0 (nrz), 1 (nrzi) */
167 int clocks; /* see dmascc_cfg documentation */
168 int txdelay; /* [1/TMR_0_HZ] */
169 int txtimeout; /* [1/HZ] */
170 int txtail; /* [1/TMR_0_HZ] */
171 int waittime; /* [1/TMR_0_HZ] */
172 int slottime; /* [1/TMR_0_HZ] */
173 int persist; /* 1 ... 256 */
174 int dma; /* -1 (disable), 0, 1, 3 */
175 int txpause; /* [1/TMR_0_HZ] */
176 int rtsoff; /* [1/TMR_0_HZ] */
177 int dcdon; /* [1/TMR_0_HZ] */
178 int dcdoff; /* [1/TMR_0_HZ] */
179 };
180
181 struct scc_hardware {
182 char *name;
183 int io_region;
184 int io_delta;
185 int io_size;
186 int num_devs;
187 int scc_offset;
188 int tmr_offset;
189 int tmr_hz;
190 int pclk_hz;
191 };
192
193 struct scc_priv {
194 int type;
195 int chip;
196 struct net_device *dev;
197 struct scc_info *info;
198 struct net_device_stats stats;
199 int channel;
200 int card_base, scc_cmd, scc_data;
201 int tmr_cnt, tmr_ctrl, tmr_mode;
202 struct scc_param param;
203 char rx_buf[NUM_RX_BUF][BUF_SIZE];
204 int rx_len[NUM_RX_BUF];
205 int rx_ptr;
206 struct work_struct rx_work;
207 int rx_head, rx_tail, rx_count;
208 int rx_over;
209 char tx_buf[NUM_TX_BUF][BUF_SIZE];
210 int tx_len[NUM_TX_BUF];
211 int tx_ptr;
212 int tx_head, tx_tail, tx_count;
213 int state;
214 unsigned long tx_start;
215 int rr0;
216 spinlock_t *register_lock; /* Per scc_info */
217 spinlock_t ring_lock;
218 };
219
220 struct scc_info {
221 int irq_used;
222 int twin_serial_cfg;
223 struct net_device *dev[2];
224 struct scc_priv priv[2];
225 struct scc_info *next;
226 spinlock_t register_lock; /* Per device register lock */
227 };
228
229
230 /* Function declarations */
231 static int setup_adapter(int card_base, int type, int n) __init;
232
233 static void write_scc(struct scc_priv *priv, int reg, int val);
234 static void write_scc_data(struct scc_priv *priv, int val, int fast);
235 static int read_scc(struct scc_priv *priv, int reg);
236 static int read_scc_data(struct scc_priv *priv);
237
238 static int scc_open(struct net_device *dev);
239 static int scc_close(struct net_device *dev);
240 static int scc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
241 static int scc_send_packet(struct sk_buff *skb, struct net_device *dev);
242 static struct net_device_stats *scc_get_stats(struct net_device *dev);
243 static int scc_set_mac_address(struct net_device *dev, void *sa);
244
245 static inline void tx_on(struct scc_priv *priv);
246 static inline void rx_on(struct scc_priv *priv);
247 static inline void rx_off(struct scc_priv *priv);
248 static void start_timer(struct scc_priv *priv, int t, int r15);
249 static inline unsigned char random(void);
250
251 static inline void z8530_isr(struct scc_info *info);
252 static irqreturn_t scc_isr(int irq, void *dev_id);
253 static void rx_isr(struct scc_priv *priv);
254 static void special_condition(struct scc_priv *priv, int rc);
255 static void rx_bh(struct work_struct *);
256 static void tx_isr(struct scc_priv *priv);
257 static void es_isr(struct scc_priv *priv);
258 static void tm_isr(struct scc_priv *priv);
259
260
261 /* Initialization variables */
262
263 static int io[MAX_NUM_DEVS] __initdata = { 0, };
264
265 /* Beware! hw[] is also used in cleanup_module(). */
266 static struct scc_hardware hw[NUM_TYPES] __initdata_or_module = HARDWARE;
267
268
269 /* Global variables */
270
271 static struct scc_info *first;
272 static unsigned long rand;
273
274
275 MODULE_AUTHOR("Klaus Kudielka");
276 MODULE_DESCRIPTION("Driver for high-speed SCC boards");
277 module_param_array(io, int, NULL, 0);
278 MODULE_LICENSE("GPL");
279
280 static void __exit dmascc_exit(void)
281 {
282 int i;
283 struct scc_info *info;
284
285 while (first) {
286 info = first;
287
288 /* Unregister devices */
289 for (i = 0; i < 2; i++)
290 unregister_netdev(info->dev[i]);
291
292 /* Reset board */
293 if (info->priv[0].type == TYPE_TWIN)
294 outb(0, info->dev[0]->base_addr + TWIN_SERIAL_CFG);
295 write_scc(&info->priv[0], R9, FHWRES);
296 release_region(info->dev[0]->base_addr,
297 hw[info->priv[0].type].io_size);
298
299 for (i = 0; i < 2; i++)
300 free_netdev(info->dev[i]);
301
302 /* Free memory */
303 first = info->next;
304 kfree(info);
305 }
306 }
307
308 static int __init dmascc_init(void)
309 {
310 int h, i, j, n;
311 int base[MAX_NUM_DEVS], tcmd[MAX_NUM_DEVS], t0[MAX_NUM_DEVS],
312 t1[MAX_NUM_DEVS];
313 unsigned t_val;
314 unsigned long time, start[MAX_NUM_DEVS], delay[MAX_NUM_DEVS],
315 counting[MAX_NUM_DEVS];
316
317 /* Initialize random number generator */
318 rand = jiffies;
319 /* Cards found = 0 */
320 n = 0;
321 /* Warning message */
322 if (!io[0])
323 printk(KERN_INFO "dmascc: autoprobing (dangerous)\n");
324
325 /* Run autodetection for each card type */
326 for (h = 0; h < NUM_TYPES; h++) {
327
328 if (io[0]) {
329 /* User-specified I/O address regions */
330 for (i = 0; i < hw[h].num_devs; i++)
331 base[i] = 0;
332 for (i = 0; i < MAX_NUM_DEVS && io[i]; i++) {
333 j = (io[i] -
334 hw[h].io_region) / hw[h].io_delta;
335 if (j >= 0 && j < hw[h].num_devs
336 && hw[h].io_region +
337 j * hw[h].io_delta == io[i]) {
338 base[j] = io[i];
339 }
340 }
341 } else {
342 /* Default I/O address regions */
343 for (i = 0; i < hw[h].num_devs; i++) {
344 base[i] =
345 hw[h].io_region + i * hw[h].io_delta;
346 }
347 }
348
349 /* Check valid I/O address regions */
350 for (i = 0; i < hw[h].num_devs; i++)
351 if (base[i]) {
352 if (!request_region
353 (base[i], hw[h].io_size, "dmascc"))
354 base[i] = 0;
355 else {
356 tcmd[i] =
357 base[i] + hw[h].tmr_offset +
358 TMR_CTRL;
359 t0[i] =
360 base[i] + hw[h].tmr_offset +
361 TMR_CNT0;
362 t1[i] =
363 base[i] + hw[h].tmr_offset +
364 TMR_CNT1;
365 }
366 }
367
368 /* Start timers */
369 for (i = 0; i < hw[h].num_devs; i++)
370 if (base[i]) {
371 /* Timer 0: LSB+MSB, Mode 3, TMR_0_HZ */
372 outb(0x36, tcmd[i]);
373 outb((hw[h].tmr_hz / TMR_0_HZ) & 0xFF,
374 t0[i]);
375 outb((hw[h].tmr_hz / TMR_0_HZ) >> 8,
376 t0[i]);
377 /* Timer 1: LSB+MSB, Mode 0, HZ/10 */
378 outb(0x70, tcmd[i]);
379 outb((TMR_0_HZ / HZ * 10) & 0xFF, t1[i]);
380 outb((TMR_0_HZ / HZ * 10) >> 8, t1[i]);
381 start[i] = jiffies;
382 delay[i] = 0;
383 counting[i] = 1;
384 /* Timer 2: LSB+MSB, Mode 0 */
385 outb(0xb0, tcmd[i]);
386 }
387 time = jiffies;
388 /* Wait until counter registers are loaded */
389 udelay(2000000 / TMR_0_HZ);
390
391 /* Timing loop */
392 while (jiffies - time < 13) {
393 for (i = 0; i < hw[h].num_devs; i++)
394 if (base[i] && counting[i]) {
395 /* Read back Timer 1: latch; read LSB; read MSB */
396 outb(0x40, tcmd[i]);
397 t_val =
398 inb(t1[i]) + (inb(t1[i]) << 8);
399 /* Also check whether counter did wrap */
400 if (t_val == 0
401 || t_val > TMR_0_HZ / HZ * 10)
402 counting[i] = 0;
403 delay[i] = jiffies - start[i];
404 }
405 }
406
407 /* Evaluate measurements */
408 for (i = 0; i < hw[h].num_devs; i++)
409 if (base[i]) {
410 if ((delay[i] >= 9 && delay[i] <= 11) &&
411 /* Ok, we have found an adapter */
412 (setup_adapter(base[i], h, n) == 0))
413 n++;
414 else
415 release_region(base[i],
416 hw[h].io_size);
417 }
418
419 } /* NUM_TYPES */
420
421 /* If any adapter was successfully initialized, return ok */
422 if (n)
423 return 0;
424
425 /* If no adapter found, return error */
426 printk(KERN_INFO "dmascc: no adapters found\n");
427 return -EIO;
428 }
429
430 module_init(dmascc_init);
431 module_exit(dmascc_exit);
432
433 static void __init dev_setup(struct net_device *dev)
434 {
435 dev->type = ARPHRD_AX25;
436 dev->hard_header_len = AX25_MAX_HEADER_LEN;
437 dev->mtu = 1500;
438 dev->addr_len = AX25_ADDR_LEN;
439 dev->tx_queue_len = 64;
440 memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
441 memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
442 }
443
444 static int __init setup_adapter(int card_base, int type, int n)
445 {
446 int i, irq, chip;
447 struct scc_info *info;
448 struct net_device *dev;
449 struct scc_priv *priv;
450 unsigned long time;
451 unsigned int irqs;
452 int tmr_base = card_base + hw[type].tmr_offset;
453 int scc_base = card_base + hw[type].scc_offset;
454 char *chipnames[] = CHIPNAMES;
455
456 /* Allocate memory */
457 info = kmalloc(sizeof(struct scc_info), GFP_KERNEL | GFP_DMA);
458 if (!info) {
459 printk(KERN_ERR "dmascc: "
460 "could not allocate memory for %s at %#3x\n",
461 hw[type].name, card_base);
462 goto out;
463 }
464
465 /* Initialize what is necessary for write_scc and write_scc_data */
466 memset(info, 0, sizeof(struct scc_info));
467
468 info->dev[0] = alloc_netdev(0, "", dev_setup);
469 if (!info->dev[0]) {
470 printk(KERN_ERR "dmascc: "
471 "could not allocate memory for %s at %#3x\n",
472 hw[type].name, card_base);
473 goto out1;
474 }
475
476 info->dev[1] = alloc_netdev(0, "", dev_setup);
477 if (!info->dev[1]) {
478 printk(KERN_ERR "dmascc: "
479 "could not allocate memory for %s at %#3x\n",
480 hw[type].name, card_base);
481 goto out2;
482 }
483 spin_lock_init(&info->register_lock);
484
485 priv = &info->priv[0];
486 priv->type = type;
487 priv->card_base = card_base;
488 priv->scc_cmd = scc_base + SCCA_CMD;
489 priv->scc_data = scc_base + SCCA_DATA;
490 priv->register_lock = &info->register_lock;
491
492 /* Reset SCC */
493 write_scc(priv, R9, FHWRES | MIE | NV);
494
495 /* Determine type of chip by enabling SDLC/HDLC enhancements */
496 write_scc(priv, R15, SHDLCE);
497 if (!read_scc(priv, R15)) {
498 /* WR7' not present. This is an ordinary Z8530 SCC. */
499 chip = Z8530;
500 } else {
501 /* Put one character in TX FIFO */
502 write_scc_data(priv, 0, 0);
503 if (read_scc(priv, R0) & Tx_BUF_EMP) {
504 /* TX FIFO not full. This is a Z85230 ESCC with a 4-byte FIFO. */
505 chip = Z85230;
506 } else {
507 /* TX FIFO full. This is a Z85C30 SCC with a 1-byte FIFO. */
508 chip = Z85C30;
509 }
510 }
511 write_scc(priv, R15, 0);
512
513 /* Start IRQ auto-detection */
514 irqs = probe_irq_on();
515
516 /* Enable interrupts */
517 if (type == TYPE_TWIN) {
518 outb(0, card_base + TWIN_DMA_CFG);
519 inb(card_base + TWIN_CLR_TMR1);
520 inb(card_base + TWIN_CLR_TMR2);
521 info->twin_serial_cfg = TWIN_EI;
522 outb(info->twin_serial_cfg, card_base + TWIN_SERIAL_CFG);
523 } else {
524 write_scc(priv, R15, CTSIE);
525 write_scc(priv, R0, RES_EXT_INT);
526 write_scc(priv, R1, EXT_INT_ENAB);
527 }
528
529 /* Start timer */
530 outb(1, tmr_base + TMR_CNT1);
531 outb(0, tmr_base + TMR_CNT1);
532
533 /* Wait and detect IRQ */
534 time = jiffies;
535 while (jiffies - time < 2 + HZ / TMR_0_HZ);
536 irq = probe_irq_off(irqs);
537
538 /* Clear pending interrupt, disable interrupts */
539 if (type == TYPE_TWIN) {
540 inb(card_base + TWIN_CLR_TMR1);
541 } else {
542 write_scc(priv, R1, 0);
543 write_scc(priv, R15, 0);
544 write_scc(priv, R0, RES_EXT_INT);
545 }
546
547 if (irq <= 0) {
548 printk(KERN_ERR
549 "dmascc: could not find irq of %s at %#3x (irq=%d)\n",
550 hw[type].name, card_base, irq);
551 goto out3;
552 }
553
554 /* Set up data structures */
555 for (i = 0; i < 2; i++) {
556 dev = info->dev[i];
557 priv = &info->priv[i];
558 priv->type = type;
559 priv->chip = chip;
560 priv->dev = dev;
561 priv->info = info;
562 priv->channel = i;
563 spin_lock_init(&priv->ring_lock);
564 priv->register_lock = &info->register_lock;
565 priv->card_base = card_base;
566 priv->scc_cmd = scc_base + (i ? SCCB_CMD : SCCA_CMD);
567 priv->scc_data = scc_base + (i ? SCCB_DATA : SCCA_DATA);
568 priv->tmr_cnt = tmr_base + (i ? TMR_CNT2 : TMR_CNT1);
569 priv->tmr_ctrl = tmr_base + TMR_CTRL;
570 priv->tmr_mode = i ? 0xb0 : 0x70;
571 priv->param.pclk_hz = hw[type].pclk_hz;
572 priv->param.brg_tc = -1;
573 priv->param.clocks = TCTRxCP | RCRTxCP;
574 priv->param.persist = 256;
575 priv->param.dma = -1;
576 INIT_WORK(&priv->rx_work, rx_bh);
577 dev->priv = priv;
578 sprintf(dev->name, "dmascc%i", 2 * n + i);
579 dev->base_addr = card_base;
580 dev->irq = irq;
581 dev->open = scc_open;
582 dev->stop = scc_close;
583 dev->do_ioctl = scc_ioctl;
584 dev->hard_start_xmit = scc_send_packet;
585 dev->get_stats = scc_get_stats;
586 dev->hard_header = ax25_hard_header;
587 dev->rebuild_header = ax25_rebuild_header;
588 dev->set_mac_address = scc_set_mac_address;
589 }
590 if (register_netdev(info->dev[0])) {
591 printk(KERN_ERR "dmascc: could not register %s\n",
592 info->dev[0]->name);
593 goto out3;
594 }
595 if (register_netdev(info->dev[1])) {
596 printk(KERN_ERR "dmascc: could not register %s\n",
597 info->dev[1]->name);
598 goto out4;
599 }
600
601
602 info->next = first;
603 first = info;
604 printk(KERN_INFO "dmascc: found %s (%s) at %#3x, irq %d\n",
605 hw[type].name, chipnames[chip], card_base, irq);
606 return 0;
607
608 out4:
609 unregister_netdev(info->dev[0]);
610 out3:
611 if (info->priv[0].type == TYPE_TWIN)
612 outb(0, info->dev[0]->base_addr + TWIN_SERIAL_CFG);
613 write_scc(&info->priv[0], R9, FHWRES);
614 free_netdev(info->dev[1]);
615 out2:
616 free_netdev(info->dev[0]);
617 out1:
618 kfree(info);
619 out:
620 return -1;
621 }
622
623
624 /* Driver functions */
625
626 static void write_scc(struct scc_priv *priv, int reg, int val)
627 {
628 unsigned long flags;
629 switch (priv->type) {
630 case TYPE_S5:
631 if (reg)
632 outb(reg, priv->scc_cmd);
633 outb(val, priv->scc_cmd);
634 return;
635 case TYPE_TWIN:
636 if (reg)
637 outb_p(reg, priv->scc_cmd);
638 outb_p(val, priv->scc_cmd);
639 return;
640 default:
641 spin_lock_irqsave(priv->register_lock, flags);
642 outb_p(0, priv->card_base + PI_DREQ_MASK);
643 if (reg)
644 outb_p(reg, priv->scc_cmd);
645 outb_p(val, priv->scc_cmd);
646 outb(1, priv->card_base + PI_DREQ_MASK);
647 spin_unlock_irqrestore(priv->register_lock, flags);
648 return;
649 }
650 }
651
652
653 static void write_scc_data(struct scc_priv *priv, int val, int fast)
654 {
655 unsigned long flags;
656 switch (priv->type) {
657 case TYPE_S5:
658 outb(val, priv->scc_data);
659 return;
660 case TYPE_TWIN:
661 outb_p(val, priv->scc_data);
662 return;
663 default:
664 if (fast)
665 outb_p(val, priv->scc_data);
666 else {
667 spin_lock_irqsave(priv->register_lock, flags);
668 outb_p(0, priv->card_base + PI_DREQ_MASK);
669 outb_p(val, priv->scc_data);
670 outb(1, priv->card_base + PI_DREQ_MASK);
671 spin_unlock_irqrestore(priv->register_lock, flags);
672 }
673 return;
674 }
675 }
676
677
678 static int read_scc(struct scc_priv *priv, int reg)
679 {
680 int rc;
681 unsigned long flags;
682 switch (priv->type) {
683 case TYPE_S5:
684 if (reg)
685 outb(reg, priv->scc_cmd);
686 return inb(priv->scc_cmd);
687 case TYPE_TWIN:
688 if (reg)
689 outb_p(reg, priv->scc_cmd);
690 return inb_p(priv->scc_cmd);
691 default:
692 spin_lock_irqsave(priv->register_lock, flags);
693 outb_p(0, priv->card_base + PI_DREQ_MASK);
694 if (reg)
695 outb_p(reg, priv->scc_cmd);
696 rc = inb_p(priv->scc_cmd);
697 outb(1, priv->card_base + PI_DREQ_MASK);
698 spin_unlock_irqrestore(priv->register_lock, flags);
699 return rc;
700 }
701 }
702
703
704 static int read_scc_data(struct scc_priv *priv)
705 {
706 int rc;
707 unsigned long flags;
708 switch (priv->type) {
709 case TYPE_S5:
710 return inb(priv->scc_data);
711 case TYPE_TWIN:
712 return inb_p(priv->scc_data);
713 default:
714 spin_lock_irqsave(priv->register_lock, flags);
715 outb_p(0, priv->card_base + PI_DREQ_MASK);
716 rc = inb_p(priv->scc_data);
717 outb(1, priv->card_base + PI_DREQ_MASK);
718 spin_unlock_irqrestore(priv->register_lock, flags);
719 return rc;
720 }
721 }
722
723
724 static int scc_open(struct net_device *dev)
725 {
726 struct scc_priv *priv = dev->priv;
727 struct scc_info *info = priv->info;
728 int card_base = priv->card_base;
729
730 /* Request IRQ if not already used by other channel */
731 if (!info->irq_used) {
732 if (request_irq(dev->irq, scc_isr, 0, "dmascc", info)) {
733 return -EAGAIN;
734 }
735 }
736 info->irq_used++;
737
738 /* Request DMA if required */
739 if (priv->param.dma >= 0) {
740 if (request_dma(priv->param.dma, "dmascc")) {
741 if (--info->irq_used == 0)
742 free_irq(dev->irq, info);
743 return -EAGAIN;
744 } else {
745 unsigned long flags = claim_dma_lock();
746 clear_dma_ff(priv->param.dma);
747 release_dma_lock(flags);
748 }
749 }
750
751 /* Initialize local variables */
752 priv->rx_ptr = 0;
753 priv->rx_over = 0;
754 priv->rx_head = priv->rx_tail = priv->rx_count = 0;
755 priv->state = IDLE;
756 priv->tx_head = priv->tx_tail = priv->tx_count = 0;
757 priv->tx_ptr = 0;
758
759 /* Reset channel */
760 write_scc(priv, R9, (priv->channel ? CHRB : CHRA) | MIE | NV);
761 /* X1 clock, SDLC mode */
762 write_scc(priv, R4, SDLC | X1CLK);
763 /* DMA */
764 write_scc(priv, R1, EXT_INT_ENAB | WT_FN_RDYFN);
765 /* 8 bit RX char, RX disable */
766 write_scc(priv, R3, Rx8);
767 /* 8 bit TX char, TX disable */
768 write_scc(priv, R5, Tx8);
769 /* SDLC address field */
770 write_scc(priv, R6, 0);
771 /* SDLC flag */
772 write_scc(priv, R7, FLAG);
773 switch (priv->chip) {
774 case Z85C30:
775 /* Select WR7' */
776 write_scc(priv, R15, SHDLCE);
777 /* Auto EOM reset */
778 write_scc(priv, R7, AUTOEOM);
779 write_scc(priv, R15, 0);
780 break;
781 case Z85230:
782 /* Select WR7' */
783 write_scc(priv, R15, SHDLCE);
784 /* The following bits are set (see 2.5.2.1):
785 - Automatic EOM reset
786 - Interrupt request if RX FIFO is half full
787 This bit should be ignored in DMA mode (according to the
788 documentation), but actually isn't. The receiver doesn't work if
789 it is set. Thus, we have to clear it in DMA mode.
790 - Interrupt/DMA request if TX FIFO is completely empty
791 a) If set, the ESCC behaves as if it had no TX FIFO (Z85C30
792 compatibility).
793 b) If cleared, DMA requests may follow each other very quickly,
794 filling up the TX FIFO.
795 Advantage: TX works even in case of high bus latency.
796 Disadvantage: Edge-triggered DMA request circuitry may miss
797 a request. No more data is delivered, resulting
798 in a TX FIFO underrun.
799 Both PI2 and S5SCC/DMA seem to work fine with TXFIFOE cleared.
800 The PackeTwin doesn't. I don't know about the PI, but let's
801 assume it behaves like the PI2.
802 */
803 if (priv->param.dma >= 0) {
804 if (priv->type == TYPE_TWIN)
805 write_scc(priv, R7, AUTOEOM | TXFIFOE);
806 else
807 write_scc(priv, R7, AUTOEOM);
808 } else {
809 write_scc(priv, R7, AUTOEOM | RXFIFOH);
810 }
811 write_scc(priv, R15, 0);
812 break;
813 }
814 /* Preset CRC, NRZ(I) encoding */
815 write_scc(priv, R10, CRCPS | (priv->param.nrzi ? NRZI : NRZ));
816
817 /* Configure baud rate generator */
818 if (priv->param.brg_tc >= 0) {
819 /* Program BR generator */
820 write_scc(priv, R12, priv->param.brg_tc & 0xFF);
821 write_scc(priv, R13, (priv->param.brg_tc >> 8) & 0xFF);
822 /* BRG source = SYS CLK; enable BRG; DTR REQ function (required by
823 PackeTwin, not connected on the PI2); set DPLL source to BRG */
824 write_scc(priv, R14, SSBR | DTRREQ | BRSRC | BRENABL);
825 /* Enable DPLL */
826 write_scc(priv, R14, SEARCH | DTRREQ | BRSRC | BRENABL);
827 } else {
828 /* Disable BR generator */
829 write_scc(priv, R14, DTRREQ | BRSRC);
830 }
831
832 /* Configure clocks */
833 if (priv->type == TYPE_TWIN) {
834 /* Disable external TX clock receiver */
835 outb((info->twin_serial_cfg &=
836 ~(priv->channel ? TWIN_EXTCLKB : TWIN_EXTCLKA)),
837 card_base + TWIN_SERIAL_CFG);
838 }
839 write_scc(priv, R11, priv->param.clocks);
840 if ((priv->type == TYPE_TWIN) && !(priv->param.clocks & TRxCOI)) {
841 /* Enable external TX clock receiver */
842 outb((info->twin_serial_cfg |=
843 (priv->channel ? TWIN_EXTCLKB : TWIN_EXTCLKA)),
844 card_base + TWIN_SERIAL_CFG);
845 }
846
847 /* Configure PackeTwin */
848 if (priv->type == TYPE_TWIN) {
849 /* Assert DTR, enable interrupts */
850 outb((info->twin_serial_cfg |= TWIN_EI |
851 (priv->channel ? TWIN_DTRB_ON : TWIN_DTRA_ON)),
852 card_base + TWIN_SERIAL_CFG);
853 }
854
855 /* Read current status */
856 priv->rr0 = read_scc(priv, R0);
857 /* Enable DCD interrupt */
858 write_scc(priv, R15, DCDIE);
859
860 netif_start_queue(dev);
861
862 return 0;
863 }
864
865
866 static int scc_close(struct net_device *dev)
867 {
868 struct scc_priv *priv = dev->priv;
869 struct scc_info *info = priv->info;
870 int card_base = priv->card_base;
871
872 netif_stop_queue(dev);
873
874 if (priv->type == TYPE_TWIN) {
875 /* Drop DTR */
876 outb((info->twin_serial_cfg &=
877 (priv->channel ? ~TWIN_DTRB_ON : ~TWIN_DTRA_ON)),
878 card_base + TWIN_SERIAL_CFG);
879 }
880
881 /* Reset channel, free DMA and IRQ */
882 write_scc(priv, R9, (priv->channel ? CHRB : CHRA) | MIE | NV);
883 if (priv->param.dma >= 0) {
884 if (priv->type == TYPE_TWIN)
885 outb(0, card_base + TWIN_DMA_CFG);
886 free_dma(priv->param.dma);
887 }
888 if (--info->irq_used == 0)
889 free_irq(dev->irq, info);
890
891 return 0;
892 }
893
894
895 static int scc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
896 {
897 struct scc_priv *priv = dev->priv;
898
899 switch (cmd) {
900 case SIOCGSCCPARAM:
901 if (copy_to_user
902 (ifr->ifr_data, &priv->param,
903 sizeof(struct scc_param)))
904 return -EFAULT;
905 return 0;
906 case SIOCSSCCPARAM:
907 if (!capable(CAP_NET_ADMIN))
908 return -EPERM;
909 if (netif_running(dev))
910 return -EAGAIN;
911 if (copy_from_user
912 (&priv->param, ifr->ifr_data,
913 sizeof(struct scc_param)))
914 return -EFAULT;
915 return 0;
916 default:
917 return -EINVAL;
918 }
919 }
920
921
922 static int scc_send_packet(struct sk_buff *skb, struct net_device *dev)
923 {
924 struct scc_priv *priv = dev->priv;
925 unsigned long flags;
926 int i;
927
928 /* Temporarily stop the scheduler feeding us packets */
929 netif_stop_queue(dev);
930
931 /* Transfer data to DMA buffer */
932 i = priv->tx_head;
933 skb_copy_from_linear_data_offset(skb, 1, priv->tx_buf[i], skb->len - 1);
934 priv->tx_len[i] = skb->len - 1;
935
936 /* Clear interrupts while we touch our circular buffers */
937
938 spin_lock_irqsave(&priv->ring_lock, flags);
939 /* Move the ring buffer's head */
940 priv->tx_head = (i + 1) % NUM_TX_BUF;
941 priv->tx_count++;
942
943 /* If we just filled up the last buffer, leave queue stopped.
944 The higher layers must wait until we have a DMA buffer
945 to accept the data. */
946 if (priv->tx_count < NUM_TX_BUF)
947 netif_wake_queue(dev);
948
949 /* Set new TX state */
950 if (priv->state == IDLE) {
951 /* Assert RTS, start timer */
952 priv->state = TX_HEAD;
953 priv->tx_start = jiffies;
954 write_scc(priv, R5, TxCRC_ENAB | RTS | TxENAB | Tx8);
955 write_scc(priv, R15, 0);
956 start_timer(priv, priv->param.txdelay, 0);
957 }
958
959 /* Turn interrupts back on and free buffer */
960 spin_unlock_irqrestore(&priv->ring_lock, flags);
961 dev_kfree_skb(skb);
962
963 return 0;
964 }
965
966
967 static struct net_device_stats *scc_get_stats(struct net_device *dev)
968 {
969 struct scc_priv *priv = dev->priv;
970
971 return &priv->stats;
972 }
973
974
975 static int scc_set_mac_address(struct net_device *dev, void *sa)
976 {
977 memcpy(dev->dev_addr, ((struct sockaddr *) sa)->sa_data,
978 dev->addr_len);
979 return 0;
980 }
981
982
983 static inline void tx_on(struct scc_priv *priv)
984 {
985 int i, n;
986 unsigned long flags;
987
988 if (priv->param.dma >= 0) {
989 n = (priv->chip == Z85230) ? 3 : 1;
990 /* Program DMA controller */
991 flags = claim_dma_lock();
992 set_dma_mode(priv->param.dma, DMA_MODE_WRITE);
993 set_dma_addr(priv->param.dma,
994 (int) priv->tx_buf[priv->tx_tail] + n);
995 set_dma_count(priv->param.dma,
996 priv->tx_len[priv->tx_tail] - n);
997 release_dma_lock(flags);
998 /* Enable TX underrun interrupt */
999 write_scc(priv, R15, TxUIE);
1000 /* Configure DREQ */
1001 if (priv->type == TYPE_TWIN)
1002 outb((priv->param.dma ==
1003 1) ? TWIN_DMA_HDX_T1 : TWIN_DMA_HDX_T3,
1004 priv->card_base + TWIN_DMA_CFG);
1005 else
1006 write_scc(priv, R1,
1007 EXT_INT_ENAB | WT_FN_RDYFN |
1008 WT_RDY_ENAB);
1009 /* Write first byte(s) */
1010 spin_lock_irqsave(priv->register_lock, flags);
1011 for (i = 0; i < n; i++)
1012 write_scc_data(priv,
1013 priv->tx_buf[priv->tx_tail][i], 1);
1014 enable_dma(priv->param.dma);
1015 spin_unlock_irqrestore(priv->register_lock, flags);
1016 } else {
1017 write_scc(priv, R15, TxUIE);
1018 write_scc(priv, R1,
1019 EXT_INT_ENAB | WT_FN_RDYFN | TxINT_ENAB);
1020 tx_isr(priv);
1021 }
1022 /* Reset EOM latch if we do not have the AUTOEOM feature */
1023 if (priv->chip == Z8530)
1024 write_scc(priv, R0, RES_EOM_L);
1025 }
1026
1027
1028 static inline void rx_on(struct scc_priv *priv)
1029 {
1030 unsigned long flags;
1031
1032 /* Clear RX FIFO */
1033 while (read_scc(priv, R0) & Rx_CH_AV)
1034 read_scc_data(priv);
1035 priv->rx_over = 0;
1036 if (priv->param.dma >= 0) {
1037 /* Program DMA controller */
1038 flags = claim_dma_lock();
1039 set_dma_mode(priv->param.dma, DMA_MODE_READ);
1040 set_dma_addr(priv->param.dma,
1041 (int) priv->rx_buf[priv->rx_head]);
1042 set_dma_count(priv->param.dma, BUF_SIZE);
1043 release_dma_lock(flags);
1044 enable_dma(priv->param.dma);
1045 /* Configure PackeTwin DMA */
1046 if (priv->type == TYPE_TWIN) {
1047 outb((priv->param.dma ==
1048 1) ? TWIN_DMA_HDX_R1 : TWIN_DMA_HDX_R3,
1049 priv->card_base + TWIN_DMA_CFG);
1050 }
1051 /* Sp. cond. intr. only, ext int enable, RX DMA enable */
1052 write_scc(priv, R1, EXT_INT_ENAB | INT_ERR_Rx |
1053 WT_RDY_RT | WT_FN_RDYFN | WT_RDY_ENAB);
1054 } else {
1055 /* Reset current frame */
1056 priv->rx_ptr = 0;
1057 /* Intr. on all Rx characters and Sp. cond., ext int enable */
1058 write_scc(priv, R1, EXT_INT_ENAB | INT_ALL_Rx | WT_RDY_RT |
1059 WT_FN_RDYFN);
1060 }
1061 write_scc(priv, R0, ERR_RES);
1062 write_scc(priv, R3, RxENABLE | Rx8 | RxCRC_ENAB);
1063 }
1064
1065
1066 static inline void rx_off(struct scc_priv *priv)
1067 {
1068 /* Disable receiver */
1069 write_scc(priv, R3, Rx8);
1070 /* Disable DREQ / RX interrupt */
1071 if (priv->param.dma >= 0 && priv->type == TYPE_TWIN)
1072 outb(0, priv->card_base + TWIN_DMA_CFG);
1073 else
1074 write_scc(priv, R1, EXT_INT_ENAB | WT_FN_RDYFN);
1075 /* Disable DMA */
1076 if (priv->param.dma >= 0)
1077 disable_dma(priv->param.dma);
1078 }
1079
1080
1081 static void start_timer(struct scc_priv *priv, int t, int r15)
1082 {
1083 unsigned long flags;
1084
1085 outb(priv->tmr_mode, priv->tmr_ctrl);
1086 if (t == 0) {
1087 tm_isr(priv);
1088 } else if (t > 0) {
1089 save_flags(flags);
1090 cli();
1091 outb(t & 0xFF, priv->tmr_cnt);
1092 outb((t >> 8) & 0xFF, priv->tmr_cnt);
1093 if (priv->type != TYPE_TWIN) {
1094 write_scc(priv, R15, r15 | CTSIE);
1095 priv->rr0 |= CTS;
1096 }
1097 restore_flags(flags);
1098 }
1099 }
1100
1101
1102 static inline unsigned char random(void)
1103 {
1104 /* See "Numerical Recipes in C", second edition, p. 284 */
1105 rand = rand * 1664525L + 1013904223L;
1106 return (unsigned char) (rand >> 24);
1107 }
1108
1109 static inline void z8530_isr(struct scc_info *info)
1110 {
1111 int is, i = 100;
1112
1113 while ((is = read_scc(&info->priv[0], R3)) && i--) {
1114 if (is & CHARxIP) {
1115 rx_isr(&info->priv[0]);
1116 } else if (is & CHATxIP) {
1117 tx_isr(&info->priv[0]);
1118 } else if (is & CHAEXT) {
1119 es_isr(&info->priv[0]);
1120 } else if (is & CHBRxIP) {
1121 rx_isr(&info->priv[1]);
1122 } else if (is & CHBTxIP) {
1123 tx_isr(&info->priv[1]);
1124 } else {
1125 es_isr(&info->priv[1]);
1126 }
1127 write_scc(&info->priv[0], R0, RES_H_IUS);
1128 i++;
1129 }
1130 if (i < 0) {
1131 printk(KERN_ERR "dmascc: stuck in ISR with RR3=0x%02x.\n",
1132 is);
1133 }
1134 /* Ok, no interrupts pending from this 8530. The INT line should
1135 be inactive now. */
1136 }
1137
1138
1139 static irqreturn_t scc_isr(int irq, void *dev_id)
1140 {
1141 struct scc_info *info = dev_id;
1142
1143 spin_lock(info->priv[0].register_lock);
1144 /* At this point interrupts are enabled, and the interrupt under service
1145 is already acknowledged, but masked off.
1146
1147 Interrupt processing: We loop until we know that the IRQ line is
1148 low. If another positive edge occurs afterwards during the ISR,
1149 another interrupt will be triggered by the interrupt controller
1150 as soon as the IRQ level is enabled again (see asm/irq.h).
1151
1152 Bottom-half handlers will be processed after scc_isr(). This is
1153 important, since we only have small ringbuffers and want new data
1154 to be fetched/delivered immediately. */
1155
1156 if (info->priv[0].type == TYPE_TWIN) {
1157 int is, card_base = info->priv[0].card_base;
1158 while ((is = ~inb(card_base + TWIN_INT_REG)) &
1159 TWIN_INT_MSK) {
1160 if (is & TWIN_SCC_MSK) {
1161 z8530_isr(info);
1162 } else if (is & TWIN_TMR1_MSK) {
1163 inb(card_base + TWIN_CLR_TMR1);
1164 tm_isr(&info->priv[0]);
1165 } else {
1166 inb(card_base + TWIN_CLR_TMR2);
1167 tm_isr(&info->priv[1]);
1168 }
1169 }
1170 } else
1171 z8530_isr(info);
1172 spin_unlock(info->priv[0].register_lock);
1173 return IRQ_HANDLED;
1174 }
1175
1176
1177 static void rx_isr(struct scc_priv *priv)
1178 {
1179 if (priv->param.dma >= 0) {
1180 /* Check special condition and perform error reset. See 2.4.7.5. */
1181 special_condition(priv, read_scc(priv, R1));
1182 write_scc(priv, R0, ERR_RES);
1183 } else {
1184 /* Check special condition for each character. Error reset not necessary.
1185 Same algorithm for SCC and ESCC. See 2.4.7.1 and 2.4.7.4. */
1186 int rc;
1187 while (read_scc(priv, R0) & Rx_CH_AV) {
1188 rc = read_scc(priv, R1);
1189 if (priv->rx_ptr < BUF_SIZE)
1190 priv->rx_buf[priv->rx_head][priv->
1191 rx_ptr++] =
1192 read_scc_data(priv);
1193 else {
1194 priv->rx_over = 2;
1195 read_scc_data(priv);
1196 }
1197 special_condition(priv, rc);
1198 }
1199 }
1200 }
1201
1202
1203 static void special_condition(struct scc_priv *priv, int rc)
1204 {
1205 int cb;
1206 unsigned long flags;
1207
1208 /* See Figure 2-15. Only overrun and EOF need to be checked. */
1209
1210 if (rc & Rx_OVR) {
1211 /* Receiver overrun */
1212 priv->rx_over = 1;
1213 if (priv->param.dma < 0)
1214 write_scc(priv, R0, ERR_RES);
1215 } else if (rc & END_FR) {
1216 /* End of frame. Get byte count */
1217 if (priv->param.dma >= 0) {
1218 flags = claim_dma_lock();
1219 cb = BUF_SIZE - get_dma_residue(priv->param.dma) -
1220 2;
1221 release_dma_lock(flags);
1222 } else {
1223 cb = priv->rx_ptr - 2;
1224 }
1225 if (priv->rx_over) {
1226 /* We had an overrun */
1227 priv->stats.rx_errors++;
1228 if (priv->rx_over == 2)
1229 priv->stats.rx_length_errors++;
1230 else
1231 priv->stats.rx_fifo_errors++;
1232 priv->rx_over = 0;
1233 } else if (rc & CRC_ERR) {
1234 /* Count invalid CRC only if packet length >= minimum */
1235 if (cb >= 15) {
1236 priv->stats.rx_errors++;
1237 priv->stats.rx_crc_errors++;
1238 }
1239 } else {
1240 if (cb >= 15) {
1241 if (priv->rx_count < NUM_RX_BUF - 1) {
1242 /* Put good frame in FIFO */
1243 priv->rx_len[priv->rx_head] = cb;
1244 priv->rx_head =
1245 (priv->rx_head +
1246 1) % NUM_RX_BUF;
1247 priv->rx_count++;
1248 schedule_work(&priv->rx_work);
1249 } else {
1250 priv->stats.rx_errors++;
1251 priv->stats.rx_over_errors++;
1252 }
1253 }
1254 }
1255 /* Get ready for new frame */
1256 if (priv->param.dma >= 0) {
1257 flags = claim_dma_lock();
1258 set_dma_addr(priv->param.dma,
1259 (int) priv->rx_buf[priv->rx_head]);
1260 set_dma_count(priv->param.dma, BUF_SIZE);
1261 release_dma_lock(flags);
1262 } else {
1263 priv->rx_ptr = 0;
1264 }
1265 }
1266 }
1267
1268
1269 static void rx_bh(struct work_struct *ugli_api)
1270 {
1271 struct scc_priv *priv = container_of(ugli_api, struct scc_priv, rx_work);
1272 int i = priv->rx_tail;
1273 int cb;
1274 unsigned long flags;
1275 struct sk_buff *skb;
1276 unsigned char *data;
1277
1278 spin_lock_irqsave(&priv->ring_lock, flags);
1279 while (priv->rx_count) {
1280 spin_unlock_irqrestore(&priv->ring_lock, flags);
1281 cb = priv->rx_len[i];
1282 /* Allocate buffer */
1283 skb = dev_alloc_skb(cb + 1);
1284 if (skb == NULL) {
1285 /* Drop packet */
1286 priv->stats.rx_dropped++;
1287 } else {
1288 /* Fill buffer */
1289 data = skb_put(skb, cb + 1);
1290 data[0] = 0;
1291 memcpy(&data[1], priv->rx_buf[i], cb);
1292 skb->protocol = ax25_type_trans(skb, priv->dev);
1293 netif_rx(skb);
1294 priv->dev->last_rx = jiffies;
1295 priv->stats.rx_packets++;
1296 priv->stats.rx_bytes += cb;
1297 }
1298 spin_lock_irqsave(&priv->ring_lock, flags);
1299 /* Move tail */
1300 priv->rx_tail = i = (i + 1) % NUM_RX_BUF;
1301 priv->rx_count--;
1302 }
1303 spin_unlock_irqrestore(&priv->ring_lock, flags);
1304 }
1305
1306
1307 static void tx_isr(struct scc_priv *priv)
1308 {
1309 int i = priv->tx_tail, p = priv->tx_ptr;
1310
1311 /* Suspend TX interrupts if we don't want to send anything.
1312 See Figure 2-22. */
1313 if (p == priv->tx_len[i]) {
1314 write_scc(priv, R0, RES_Tx_P);
1315 return;
1316 }
1317
1318 /* Write characters */
1319 while ((read_scc(priv, R0) & Tx_BUF_EMP) && p < priv->tx_len[i]) {
1320 write_scc_data(priv, priv->tx_buf[i][p++], 0);
1321 }
1322
1323 /* Reset EOM latch of Z8530 */
1324 if (!priv->tx_ptr && p && priv->chip == Z8530)
1325 write_scc(priv, R0, RES_EOM_L);
1326
1327 priv->tx_ptr = p;
1328 }
1329
1330
1331 static void es_isr(struct scc_priv *priv)
1332 {
1333 int i, rr0, drr0, res;
1334 unsigned long flags;
1335
1336 /* Read status, reset interrupt bit (open latches) */
1337 rr0 = read_scc(priv, R0);
1338 write_scc(priv, R0, RES_EXT_INT);
1339 drr0 = priv->rr0 ^ rr0;
1340 priv->rr0 = rr0;
1341
1342 /* Transmit underrun (2.4.9.6). We can't check the TxEOM flag, since
1343 it might have already been cleared again by AUTOEOM. */
1344 if (priv->state == TX_DATA) {
1345 /* Get remaining bytes */
1346 i = priv->tx_tail;
1347 if (priv->param.dma >= 0) {
1348 disable_dma(priv->param.dma);
1349 flags = claim_dma_lock();
1350 res = get_dma_residue(priv->param.dma);
1351 release_dma_lock(flags);
1352 } else {
1353 res = priv->tx_len[i] - priv->tx_ptr;
1354 priv->tx_ptr = 0;
1355 }
1356 /* Disable DREQ / TX interrupt */
1357 if (priv->param.dma >= 0 && priv->type == TYPE_TWIN)
1358 outb(0, priv->card_base + TWIN_DMA_CFG);
1359 else
1360 write_scc(priv, R1, EXT_INT_ENAB | WT_FN_RDYFN);
1361 if (res) {
1362 /* Update packet statistics */
1363 priv->stats.tx_errors++;
1364 priv->stats.tx_fifo_errors++;
1365 /* Other underrun interrupts may already be waiting */
1366 write_scc(priv, R0, RES_EXT_INT);
1367 write_scc(priv, R0, RES_EXT_INT);
1368 } else {
1369 /* Update packet statistics */
1370 priv->stats.tx_packets++;
1371 priv->stats.tx_bytes += priv->tx_len[i];
1372 /* Remove frame from FIFO */
1373 priv->tx_tail = (i + 1) % NUM_TX_BUF;
1374 priv->tx_count--;
1375 /* Inform upper layers */
1376 netif_wake_queue(priv->dev);
1377 }
1378 /* Switch state */
1379 write_scc(priv, R15, 0);
1380 if (priv->tx_count &&
1381 (jiffies - priv->tx_start) < priv->param.txtimeout) {
1382 priv->state = TX_PAUSE;
1383 start_timer(priv, priv->param.txpause, 0);
1384 } else {
1385 priv->state = TX_TAIL;
1386 start_timer(priv, priv->param.txtail, 0);
1387 }
1388 }
1389
1390 /* DCD transition */
1391 if (drr0 & DCD) {
1392 if (rr0 & DCD) {
1393 switch (priv->state) {
1394 case IDLE:
1395 case WAIT:
1396 priv->state = DCD_ON;
1397 write_scc(priv, R15, 0);
1398 start_timer(priv, priv->param.dcdon, 0);
1399 }
1400 } else {
1401 switch (priv->state) {
1402 case RX_ON:
1403 rx_off(priv);
1404 priv->state = DCD_OFF;
1405 write_scc(priv, R15, 0);
1406 start_timer(priv, priv->param.dcdoff, 0);
1407 }
1408 }
1409 }
1410
1411 /* CTS transition */
1412 if ((drr0 & CTS) && (~rr0 & CTS) && priv->type != TYPE_TWIN)
1413 tm_isr(priv);
1414
1415 }
1416
1417
1418 static void tm_isr(struct scc_priv *priv)
1419 {
1420 switch (priv->state) {
1421 case TX_HEAD:
1422 case TX_PAUSE:
1423 tx_on(priv);
1424 priv->state = TX_DATA;
1425 break;
1426 case TX_TAIL:
1427 write_scc(priv, R5, TxCRC_ENAB | Tx8);
1428 priv->state = RTS_OFF;
1429 if (priv->type != TYPE_TWIN)
1430 write_scc(priv, R15, 0);
1431 start_timer(priv, priv->param.rtsoff, 0);
1432 break;
1433 case RTS_OFF:
1434 write_scc(priv, R15, DCDIE);
1435 priv->rr0 = read_scc(priv, R0);
1436 if (priv->rr0 & DCD) {
1437 priv->stats.collisions++;
1438 rx_on(priv);
1439 priv->state = RX_ON;
1440 } else {
1441 priv->state = WAIT;
1442 start_timer(priv, priv->param.waittime, DCDIE);
1443 }
1444 break;
1445 case WAIT:
1446 if (priv->tx_count) {
1447 priv->state = TX_HEAD;
1448 priv->tx_start = jiffies;
1449 write_scc(priv, R5,
1450 TxCRC_ENAB | RTS | TxENAB | Tx8);
1451 write_scc(priv, R15, 0);
1452 start_timer(priv, priv->param.txdelay, 0);
1453 } else {
1454 priv->state = IDLE;
1455 if (priv->type != TYPE_TWIN)
1456 write_scc(priv, R15, DCDIE);
1457 }
1458 break;
1459 case DCD_ON:
1460 case DCD_OFF:
1461 write_scc(priv, R15, DCDIE);
1462 priv->rr0 = read_scc(priv, R0);
1463 if (priv->rr0 & DCD) {
1464 rx_on(priv);
1465 priv->state = RX_ON;
1466 } else {
1467 priv->state = WAIT;
1468 start_timer(priv,
1469 random() / priv->param.persist *
1470 priv->param.slottime, DCDIE);
1471 }
1472 break;
1473 }
1474 }
Linux kernel - Deliverables
This page took 0.125919 seconds and 5 git commands to generate.