This source file includes following definitions.
- sdla_read
- sdla_write
- sdla_clear
- sdla_byte
- sdla_stop
- sdla_start
- sdla_z80_poll
- sdla_cpuspeed
- sdla_errors
- sdla_cmd
- sdla_activate
- sdla_deactivate
- sdla_assoc
- sdla_deassoc
- sdla_dlci_conf
- sdla_transmit
- sdla_receive
- sdla_isr
- sdla_poll
- sdla_close
- sdla_open
- sdla_config
- sdla_xfer
- sdla_reconfig
- sdla_ioctl
- sdla_change_mtu
- sdla_set_config
- sdla_stats
- sdla_init
- sdla_setup
- init_module
- cleanup_module
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 #include <linux/module.h>
26
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/types.h>
30 #include <linux/fcntl.h>
31 #include <linux/interrupt.h>
32 #include <linux/ptrace.h>
33 #include <linux/ioport.h>
34 #include <linux/in.h>
35 #include <linux/malloc.h>
36 #include <linux/string.h>
37 #include <linux/timer.h>
38 #include <linux/errno.h>
39
40 #include <asm/system.h>
41 #include <asm/bitops.h>
42 #include <asm/io.h>
43 #include <asm/dma.h>
44
45 #include <linux/netdevice.h>
46 #include <linux/skbuff.h>
47 #include <linux/if_arp.h>
48 #include <linux/if_frad.h>
49
50 #include <linux/sdla.h>
51
52 static const char* version = "SDLA driver v0.10, 23 Mar 1996, mike.mclagan@linux.org";
53
54 static const char* devname = "sdla";
55
56 static unsigned int valid_port[] = { 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390};
57
58 static unsigned int valid_mem[] = {0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000,
59 0xB0000, 0xB2000, 0xB4000, 0xB6000, 0xB8000, 0xBA000, 0xBC000, 0xBE000,
60 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
61 0xD0000, 0xD2000, 0xD4000, 0xD6000, 0xD8000, 0xDA000, 0xDC000, 0xDE000,
62 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000, 0xEE000};
63
64
65
66
67
68
69
70 #define SDLA_WINDOW(dev,addr) outb((((addr) >> 13) & 0x1F), (dev)->base_addr + SDLA_REG_Z80_WINDOW)
71
72 static void sdla_read(struct device *dev, int addr, void *buf, short len)
73 {
74 unsigned long flags;
75 char *temp, *base;
76 int offset, bytes;
77
78 temp = buf;
79 while(len)
80 {
81 offset = addr & 0x1FFF;
82 if (offset + len > 0x2000)
83 bytes = 0x2000 - offset;
84 else
85 bytes = len;
86
87 base = (void *) dev->mem_start;
88 base += offset;
89
90 save_flags(flags);
91 cli();
92 SDLA_WINDOW(dev, addr);
93 memcpy(temp, base, bytes);
94 restore_flags(flags);
95
96 addr += bytes;
97 temp += bytes;
98 len -= bytes;
99 }
100 }
101
102 static void sdla_write(struct device *dev, int addr, void *buf, short len)
103 {
104 unsigned long flags;
105 char *temp, *base;
106 int offset, bytes;
107
108 temp = buf;
109 while(len)
110 {
111 offset = addr & 0x1FFF;
112 if (offset + len > 0x2000)
113 bytes = 0x2000 - offset;
114 else
115 bytes = len;
116
117 base = (void *) dev->mem_start;
118 base += offset;
119
120 save_flags(flags);
121 cli();
122 SDLA_WINDOW(dev, addr);
123 memcpy(base, temp, bytes);
124 restore_flags(flags);
125
126 addr += bytes;
127 temp += bytes;
128 len -= bytes;
129 }
130 }
131
132 static void sdla_clear(struct device *dev)
133 {
134 unsigned long flags;
135 char *base;
136 int offset, len, addr, bytes;
137
138 len = 65536;
139 addr = 0;
140 while(len)
141 {
142 offset = addr & 0x1FFF;
143 if (offset + len > 0x2000)
144 bytes = offset + len - 0x2000;
145 else
146 bytes = len;
147
148 base = (void *) dev->mem_start;
149 base += offset;
150
151 save_flags(flags);
152 cli();
153 SDLA_WINDOW(dev, addr);
154 memset(base, 0, bytes);
155 restore_flags(flags);
156
157 addr += bytes;
158 len -= bytes;
159 }
160 }
161
162 static char sdla_byte(struct device *dev, int addr)
163 {
164 unsigned long flags;
165 char byte, *temp;
166
167 temp = (void *) dev->mem_start;
168 temp += addr & 0x1FFF;
169
170 save_flags(flags);
171 cli();
172 SDLA_WINDOW(dev, addr);
173 byte = *temp;
174 restore_flags(flags);
175
176 return(byte);
177 }
178
179 void sdla_stop(struct device *dev)
180 {
181 struct frad_local *flp;
182
183 flp = dev->priv;
184 switch(flp->type)
185 {
186 case SDLA_S502A:
187 outb(SDLA_S502A_HALT, dev->base_addr + SDLA_REG_CONTROL);
188 flp->state = SDLA_HALT;
189 break;
190 case SDLA_S502E:
191 outb(SDLA_HALT, dev->base_addr + SDLA_REG_Z80_CONTROL);
192 outb(SDLA_S502E_ENABLE, dev->base_addr + SDLA_REG_CONTROL);
193 flp->state = SDLA_S502E_ENABLE;
194 break;
195 case SDLA_S507:
196 flp->state &= ~SDLA_CPUEN;
197 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
198 break;
199 case SDLA_S508:
200 flp->state &= ~SDLA_CPUEN;
201 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
202 break;
203 }
204 }
205
206 void sdla_start(struct device *dev)
207 {
208 struct frad_local *flp;
209
210 flp = dev->priv;
211 switch(flp->type)
212 {
213 case SDLA_S502A:
214 outb(SDLA_S502A_NMI, dev->base_addr + SDLA_REG_CONTROL);
215 outb(SDLA_S502A_START, dev->base_addr + SDLA_REG_CONTROL);
216 flp->state = SDLA_S502A_START;
217 break;
218 case SDLA_S502E:
219 outb(SDLA_S502E_CPUEN, dev->base_addr + SDLA_REG_Z80_CONTROL);
220 outb(0x00, dev->base_addr + SDLA_REG_CONTROL);
221 flp->state = 0;
222 break;
223 case SDLA_S507:
224 flp->state |= SDLA_CPUEN;
225 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
226 break;
227 case SDLA_S508:
228 flp->state |= SDLA_CPUEN;
229 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
230 break;
231 }
232 }
233
234
235
236
237
238
239
240
241
242
243
244 int sdla_z80_poll(struct device *dev, int z80_addr, int jiffs, char resp1, char resp2)
245 {
246 unsigned long start, done, now;
247 char resp, *temp;
248
249 start = now = jiffies;
250 done = jiffies + jiffs;
251
252 temp = (void *)dev->mem_start;
253 temp += z80_addr & 0x1FFF;
254
255 resp = ~resp1;
256 while ((jiffies < done) && (resp != resp1) && (!resp2 || (resp != resp2)))
257 {
258 if (jiffies != now)
259 {
260 SDLA_WINDOW(dev, z80_addr);
261 now = jiffies;
262 resp = *temp;
263 }
264 }
265 return(jiffies < done ? jiffies - start : -1);
266 }
267
268
269 #define Z80_READY '1'
270 #define LOADER_READY '2'
271 #define Z80_SCC_OK '3'
272 #define Z80_SCC_BAD '4'
273
274 static int sdla_cpuspeed(struct device *dev, struct ifreq *ifr)
275 {
276 int jiffs;
277 char data;
278
279 sdla_start(dev);
280 if (sdla_z80_poll(dev, 0, 3*HZ, Z80_READY, 0) < 0)
281 return(-EIO);
282
283 data = LOADER_READY;
284 sdla_write(dev, 0, &data, 1);
285
286 if ((jiffs = sdla_z80_poll(dev, 0, 8*HZ, Z80_SCC_OK, Z80_SCC_BAD)) < 0)
287 return(-EIO);
288
289 sdla_stop(dev);
290 sdla_read(dev, 0, &data, 1);
291
292 if (data == Z80_SCC_BAD)
293 return(-EIO);
294
295 if (data != Z80_SCC_OK)
296 return(-EINVAL);
297
298 if (jiffs < 165)
299 ifr->ifr_mtu = SDLA_CPU_16M;
300 else
301 if (jiffs < 220)
302 ifr->ifr_mtu = SDLA_CPU_10M;
303 else
304 if (jiffs < 258)
305 ifr->ifr_mtu = SDLA_CPU_8M;
306 else
307 if (jiffs < 357)
308 ifr->ifr_mtu = SDLA_CPU_7M;
309 else
310 if (jiffs < 467)
311 ifr->ifr_mtu = SDLA_CPU_5M;
312 else
313 ifr->ifr_mtu = SDLA_CPU_3M;
314
315 return(0);
316 }
317
318
319
320
321
322
323
324
325 struct _dlci_stat {
326 short dlci __attribute__((packed));
327 char flags __attribute__((packed));
328 };
329
330 struct _frad_stat {
331 char flags;
332 struct _dlci_stat dlcis[SDLA_MAX_DLCI];
333 };
334
335 static void sdla_errors(struct device *dev, int cmd, int dlci, int ret, int len, void *data)
336 {
337 struct _dlci_stat *pstatus;
338 short *pdlci;
339 int i;
340 char *state;
341
342 switch (ret)
343 {
344 case SDLA_RET_MODEM:
345 state = data;
346 if (*state & SDLA_MODEM_DCD_LOW)
347 printk(KERN_INFO "%s: Modem DCD unexpectedly low!\n", dev->name);
348 if (*state & SDLA_MODEM_CTS_LOW)
349 printk(KERN_INFO "%s: Modem CTS unexpectedly low!\n", dev->name);
350
351 break;
352
353 case SDLA_RET_CHANNEL_OFF:
354 printk(KERN_INFO "%s: Channel became inoperative!\n", dev->name);
355
356 break;
357
358 case SDLA_RET_CHANNEL_ON:
359 printk(KERN_INFO "%s: Channel became operative!\n", dev->name);
360
361 break;
362
363 case SDLA_RET_DLCI_STATUS:
364 printk(KERN_INFO "%s: Status change reported by Access Node.\n", dev->name);
365 len /= sizeof(struct _dlci_stat);
366 for(pstatus = data, i=0;i < len;i++,pstatus++)
367 {
368 if (pstatus->flags & SDLA_DLCI_NEW)
369 state = "new";
370 else
371 if (pstatus->flags & SDLA_DLCI_DELETED)
372 state = "deleted";
373 else
374 if (pstatus->flags & SDLA_DLCI_ACTIVE)
375 state = "active";
376 else
377 state = "unknown status";
378
379 printk(KERN_INFO "%s: DLCI %i: %s.\n", dev->name, pstatus->dlci, state);
380
381 }
382 break;
383
384 case SDLA_RET_DLCI_UNKNOWN:
385 printk(KERN_INFO "%s: Received unknown DLCIs:", dev->name);
386 len /= sizeof(short);
387 for(pdlci = data,i=0;i < len;i++,pdlci++)
388 printk(" %i", *pdlci);
389 printk("\n");
390 break;
391
392 case SDLA_RET_TIMEOUT:
393 printk(KERN_ERR "%s: Command timed out!\n", dev->name);
394 break;
395
396 default:
397
398
399
400
401
402 }
403 }
404
405 static int sdla_cmd(struct device *dev, int cmd, short dlci, short flags,
406 void *inbuf, short inlen, void *outbuf, short *outlen)
407 {
408 static struct _frad_stat status;
409 struct frad_local *flp;
410 struct sdla_cmd *cmd_buf;
411 unsigned long pflags;
412 int jiffs, ret, waiting, len;
413 long temp, window;
414
415 flp = dev->priv;
416
417 window = flp->type == SDLA_S508 ? SDLA_508_CMD_BUF : SDLA_502_CMD_BUF;
418 temp = (int) dev->mem_start;
419 temp += window & 0x1FFF;
420 cmd_buf = (struct sdla_cmd *)temp;
421 ret = 0;
422 jiffs = jiffies + HZ / 2;
423 save_flags(pflags);
424 cli();
425 SDLA_WINDOW(dev, window);
426 cmd_buf->cmd = cmd;
427 cmd_buf->dlci = dlci;
428 cmd_buf->flags = flags;
429
430 if (inbuf)
431 memcpy(cmd_buf->data, inbuf, inlen);
432
433 cmd_buf->length = inlen;
434
435 cmd_buf->opp_flag = 1;
436 restore_flags(pflags);
437
438 waiting = 1;
439 len = 0;
440 while (waiting && (jiffies <= jiffs))
441 {
442 if (waiting++ % 4)
443 {
444 save_flags(pflags);
445 cli();
446 SDLA_WINDOW(dev, window);
447 waiting = ((volatile)(cmd_buf->opp_flag));
448 restore_flags(pflags);
449 }
450 }
451
452 if (!waiting)
453 {
454 save_flags(pflags);
455 cli();
456 SDLA_WINDOW(dev, window);
457 ret = cmd_buf->retval;
458 len = cmd_buf->length;
459 if (outbuf && len)
460 {
461 *outlen = *outlen >= len ? len : *outlen;
462 memcpy(outbuf, cmd_buf->data, *outlen);
463 }
464 if (ret)
465 memcpy(&status, cmd_buf->data, len);
466 restore_flags(pflags);
467 }
468 else
469 ret = SDLA_RET_TIMEOUT;
470
471 if (ret != SDLA_RET_OK)
472 sdla_errors(dev, cmd, dlci, ret, len, &status);
473
474 return(ret);
475 }
476
477
478
479
480
481
482
483 static int sdla_reconfig(struct device *dev);
484
485 int sdla_activate(struct device *slave, struct device *master)
486 {
487 struct frad_local *flp;
488 int i;
489
490 flp = slave->priv;
491
492 for(i=0;i<CONFIG_DLCI_MAX;i++)
493 if (flp->master[i] == master)
494 break;
495
496 if (i == CONFIG_DLCI_MAX)
497 return(-ENODEV);
498
499 flp->dlci[i] = abs(flp->dlci[i]);
500
501 if (slave->start && (flp->config.station == FRAD_STATION_NODE))
502 sdla_cmd(slave, SDLA_ACTIVATE_DLCI, 0, 0, &flp->dlci[i], sizeof(short), NULL, NULL);
503
504 return(0);
505 }
506
507 int sdla_deactivate(struct device *slave, struct device *master)
508 {
509 struct frad_local *flp;
510 int i;
511
512 flp = slave->priv;
513
514 for(i=0;i<CONFIG_DLCI_MAX;i++)
515 if (flp->master[i] == master)
516 break;
517
518 flp->dlci[i] = -abs(flp->dlci[i]);
519
520 if (slave->start && (flp->config.station == FRAD_STATION_NODE))
521 sdla_cmd(slave, SDLA_DEACTIVATE_DLCI, 0, 0, &flp->dlci[i], sizeof(short), NULL, NULL);
522
523 return(0);
524 }
525
526 int sdla_assoc(struct device *slave, struct device *master)
527 {
528 struct frad_local *flp;
529 int i;
530
531 if (master->type != ARPHRD_DLCI)
532 return(-EINVAL);
533
534 flp = slave->priv;
535
536 for(i=0;i<CONFIG_DLCI_MAX;i++)
537 {
538 if (!flp->master[i])
539 break;
540 if (abs(flp->dlci[i]) == *(short *)(master->dev_addr))
541 return(-EADDRINUSE);
542 }
543
544 if (i == CONFIG_DLCI_MAX)
545 return(-EMLINK);
546
547 MOD_INC_USE_COUNT;
548
549 flp->master[i] = master;
550 flp->dlci[i] = -*(short *)(master->dev_addr);
551 master->mtu = slave->mtu;
552
553 if (slave->start)
554 if (flp->config.station == FRAD_STATION_CPE)
555 sdla_reconfig(slave);
556 else
557 sdla_cmd(slave, SDLA_ADD_DLCI, 0, 0, master->dev_addr, sizeof(short), NULL, NULL);
558
559 return(0);
560 }
561
562 int sdla_deassoc(struct device *slave, struct device *master)
563 {
564 struct frad_local *flp;
565 int i;
566
567 flp = slave->priv;
568
569 for(i=0;i<CONFIG_DLCI_MAX;i++)
570 if (flp->master[i] == master)
571 break;
572
573 if (i == CONFIG_DLCI_MAX)
574 return(-ENODEV);
575
576 flp->master[i] = NULL;
577 flp->dlci[i] = 0;
578
579 MOD_DEC_USE_COUNT;
580
581 if (slave->start)
582 if (flp->config.station == FRAD_STATION_CPE)
583 sdla_reconfig(slave);
584 else
585 sdla_cmd(slave, SDLA_DELETE_DLCI, 0, 0, master->dev_addr, sizeof(short), NULL, NULL);
586
587 return(0);
588 }
589
590 int sdla_dlci_conf(struct device *slave, struct device *master, int get)
591 {
592 struct frad_local *flp;
593 struct frad_local *dlp;
594 int i;
595
596 flp = slave->priv;
597
598 for(i=0;i<CONFIG_DLCI_MAX;i++)
599 if (flp->master[i] == master)
600 break;
601
602 if (i == CONFIG_DLCI_MAX)
603 return(-ENODEV);
604
605 dlp = master->priv;
606 if (slave->start)
607 sdla_cmd(slave, SDLA_SET_DLCI_CONFIGURATION, flp->dlci[i], 0,
608 &dlp->config, sizeof(struct dlci_conf) - 4 * sizeof(short), NULL, NULL);
609
610 return(0);
611 }
612
613
614
615
616
617
618
619 static int sdla_transmit(struct sk_buff *skb, struct device *dev)
620 {
621 struct frad_local *flp;
622 int ret, addr;
623 short size;
624 unsigned long flags;
625 struct buf_entry *pbuf;
626
627 flp = dev->priv;
628 ret = 0;
629
630 if (dev->tbusy)
631 return(1);
632
633 if (skb == NULL)
634 return(0);
635
636 if (set_bit(0, (void*)&dev->tbusy) != 0)
637 printk(KERN_WARNING "%s: transmitter access conflict.\n", dev->name);
638 else
639 {
640 switch (flp->type)
641 {
642 case SDLA_S502A:
643 case SDLA_S502E:
644 ret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, skb->data, skb->len, NULL, NULL);
645 break;
646
647 case SDLA_S508:
648 size = sizeof(addr);
649 ret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, NULL, skb->len, &addr, &size);
650 if (ret == SDLA_RET_OK)
651 {
652 save_flags(flags);
653 cli();
654 SDLA_WINDOW(dev, addr);
655 pbuf = (void *)(((int) dev->mem_start) + (addr & 0x1FFF));
656
657 sdla_write(dev, pbuf->buf_addr, skb->data, skb->len);
658
659 SDLA_WINDOW(dev, addr);
660 pbuf->opp_flag = 1;
661 restore_flags(flags);
662 }
663 break;
664 }
665
666 switch (ret)
667 {
668 case SDLA_RET_OK:
669 flp->stats.tx_packets++;
670 ret = 0;
671 break;
672
673 default:
674 flp->stats.tx_errors++;
675 ret = 1;
676 }
677
678
679 dev_kfree_skb(skb, FREE_WRITE);
680
681 dev->tbusy = 0;
682 }
683 return(ret);
684 }
685
686 static void sdla_receive(struct device *dev)
687 {
688 struct device *master;
689 struct frad_local *flp;
690 struct dlci_local *dlp;
691 struct sk_buff *skb;
692
693 struct sdla_cmd *cmd;
694 struct buf_info *pbufi;
695 struct buf_entry *pbuf;
696
697 unsigned long flags;
698 int i, received, success, addr;
699 short dlci, len, split;
700 char bogus;
701
702 flp = dev->priv;
703 bogus = 0;
704 success = 0;
705 received = 0;
706 addr = 0;
707 skb = NULL;
708 master = NULL;
709
710 save_flags(flags);
711 cli();
712
713 switch (flp->type)
714 {
715 case SDLA_S502A:
716 case SDLA_S502E:
717 cmd = (void *) (dev->mem_start + (SDLA_502_RCV_BUF & 0x1FFF));
718 SDLA_WINDOW(dev, SDLA_502_RCV_BUF);
719 if (!cmd->opp_flag)
720 break;
721
722 dlci = cmd->dlci;
723 len = cmd->length;
724
725 for (i=0;i<CONFIG_DLCI_MAX;i++)
726 if (flp->dlci[i] == dlci)
727 break;
728
729 if (i == CONFIG_DLCI_MAX)
730 {
731 printk(KERN_NOTICE "%s: Recieved packet from invalid DLCI %i, ignoring.", dev->name, dlci);
732 flp->stats.rx_errors++;
733 cmd->opp_flag = 0;
734 break;
735 }
736
737 master = flp->master[i];
738 skb = dev_alloc_skb(len);
739 if (skb == NULL)
740 {
741 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
742 flp->stats.rx_dropped++;
743 cmd->opp_flag = 0;
744 break;
745 }
746
747
748 sdla_read(dev, dev->mem_start + ((SDLA_502_RCV_BUF + SDLA_502_DATA_OFS) & 0x1FFF), skb_put(skb,len), len);
749 cmd->opp_flag = 0;
750 success = 1;
751 break;
752
753 case SDLA_S508:
754 pbufi = (void *) (dev->mem_start + (SDLA_508_RXBUF_INFO & 0x1FFF));
755 SDLA_WINDOW(dev, SDLA_508_RXBUF_INFO);
756 pbuf = (void *) (dev->mem_start + ((pbufi->rse_base + flp->buffer * sizeof(struct buf_entry)) & 0x1FFF));
757 if (!pbuf->opp_flag)
758 break;
759
760 dlci = pbuf->dlci;
761 len = pbuf->length;
762 addr = pbuf->buf_addr;
763
764 for (i=0;i<CONFIG_DLCI_MAX;i++)
765 if (flp->dlci[i] == dlci)
766 break;
767
768 if (i == CONFIG_DLCI_MAX)
769 {
770 printk(KERN_NOTICE "%s: Recieved packet from invalid DLCI %i, ignoring.", dev->name, dlci);
771 flp->stats.rx_errors++;
772 pbuf->opp_flag = 0;
773 break;
774 }
775
776 master = flp->master[i];
777 skb = dev_alloc_skb(len);
778 if (skb == NULL)
779 {
780 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
781 flp->stats.rx_dropped++;
782 pbuf->opp_flag = 0;
783 break;
784 }
785
786
787 split = addr + len > pbufi->buf_top + 1 ? pbufi->buf_top - addr + 1 : 0;
788 len -= split;
789
790
791 sdla_read(dev, addr, skb_put(skb, len), len);
792 if (split)
793 {
794 SDLA_WINDOW(dev, SDLA_508_RXBUF_INFO);
795 sdla_read(dev, pbufi->buf_base, skb_put(skb, split), split);
796 }
797
798 SDLA_WINDOW(dev, SDLA_508_RXBUF_INFO);
799 pbuf->opp_flag = 0;
800 success = 1;
801
802
803 flp->buffer = (flp->buffer + 1) % pbufi->rse_num;
804 break;
805 }
806
807 if (success)
808 {
809 flp->stats.rx_packets++;
810 dlp = master->priv;
811 (*dlp->receive)(skb, master);
812 }
813
814 restore_flags(flags);
815 }
816
817 static void sdla_isr(int irq, void *dev_id, struct pt_regs * regs)
818 {
819 struct device *dev;
820 struct frad_local *flp;
821 char byte;
822
823 dev = irq2dev_map[irq];
824
825 if (dev == NULL)
826 {
827 printk(KERN_WARNING "sdla_isr(): irq %d for unknown device.\n", irq);
828 return;
829 }
830
831 flp = dev->priv;
832
833 if (!flp->initialized)
834 {
835 printk(KERN_WARNING "%s: irq %d for unintialiazed device.\n", dev->name, irq);
836 return;
837 }
838
839 dev->interrupt = 1;
840 byte = sdla_byte(dev, flp->type == SDLA_S508 ? SDLA_508_IRQ_INTERFACE : SDLA_502_IRQ_INTERFACE);
841 switch (byte)
842 {
843 case SDLA_INTR_RX:
844 sdla_receive(dev);
845 break;
846
847
848 case SDLA_INTR_MODEM:
849 case SDLA_INTR_STATUS:
850 sdla_cmd(dev, SDLA_READ_DLC_STATUS, 0, 0, NULL, 0, NULL, NULL);
851 break;
852
853 case SDLA_INTR_TX:
854 case SDLA_INTR_COMPLETE:
855 case SDLA_INTR_TIMER:
856 printk(KERN_WARNING "%s: invalid irq flag 0x%02X.\n", dev->name, byte);
857 break;
858 }
859
860
861 if (flp->type == SDLA_S502E)
862 {
863 flp->state &= ~SDLA_S502E_INTACK;
864 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
865 flp->state |= SDLA_S502E_INTACK;
866 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
867 }
868
869 dev->interrupt = 0;
870
871 byte = 0;
872 sdla_write(dev, flp->type == SDLA_S508 ? SDLA_508_IRQ_INTERFACE : SDLA_502_IRQ_INTERFACE, &byte, sizeof(byte));
873 }
874
875 static void sdla_poll(unsigned long device)
876 {
877 struct device *dev;
878 struct frad_local *flp;
879
880 dev = (struct device *) device;
881 flp = dev->priv;
882
883 if (sdla_byte(dev, SDLA_502_RCV_BUF))
884 sdla_receive(dev);
885
886 flp->timer.expires = 1;
887 add_timer(&flp->timer);
888 }
889
890 static int sdla_close(struct device *dev)
891 {
892 struct frad_local *flp;
893 struct intr_info intr;
894 int len, i;
895 short dlcis[CONFIG_DLCI_MAX];
896
897 flp = dev->priv;
898
899 len = 0;
900 for(i=0;i<CONFIG_DLCI_MAX;i++)
901 if (flp->dlci[i])
902 dlcis[len++] = abs(flp->dlci[i]);
903 len *= 2;
904
905 if (flp->config.station == FRAD_STATION_NODE)
906 {
907 for(i=0;i<CONFIG_DLCI_MAX;i++)
908 if (flp->dlci[i] > 0)
909 sdla_cmd(dev, SDLA_DEACTIVATE_DLCI, 0, 0, dlcis, len, NULL, NULL);
910 sdla_cmd(dev, SDLA_DELETE_DLCI, 0, 0, &flp->dlci[i], sizeof(flp->dlci[i]), NULL, NULL);
911 }
912
913 memset(&intr, 0, sizeof(intr));
914
915 switch(flp->type)
916 {
917 case SDLA_S502A:
918 del_timer(&flp->timer);
919 break;
920
921 case SDLA_S502E:
922 sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(char) + sizeof(short), NULL, NULL);
923 flp->state &= ~SDLA_S502E_INTACK;
924 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
925 break;
926
927 case SDLA_S507:
928 break;
929
930 case SDLA_S508:
931 sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(struct intr_info), NULL, NULL);
932 flp->state &= ~SDLA_S508_INTEN;
933 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
934 break;
935 }
936
937 sdla_cmd(dev, SDLA_DISABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
938 sdla_stop(dev);
939
940 dev->tbusy = 1;
941 dev->start = 0;
942
943 MOD_DEC_USE_COUNT;
944
945 return(0);
946 }
947
948 struct conf_data {
949 struct frad_conf config;
950 short dlci[CONFIG_DLCI_MAX];
951 };
952
953 static int sdla_open(struct device *dev)
954 {
955 struct frad_local *flp;
956 struct dlci_local *dlp;
957 struct conf_data data;
958 struct intr_info intr;
959 int len, i;
960 char byte;
961
962 flp = dev->priv;
963
964 if (!flp->initialized)
965 return(-EPERM);
966
967 if (!flp->configured)
968 return(-EPERM);
969
970
971 sdla_start(dev);
972
973
974 len = 0;
975 for(i=0;i<CONFIG_DLCI_MAX;i++)
976 if (flp->dlci[i])
977 data.dlci[len++] = abs(flp->dlci[i]);
978 len *= 2;
979
980 memcpy(&data.config, &flp->config, sizeof(struct frad_conf));
981 len += sizeof(struct frad_conf);
982
983 sdla_cmd(dev, SDLA_DISABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
984 sdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, 0, 0, &data, len, NULL, NULL);
985
986 if (flp->type == SDLA_S508)
987 flp->buffer = 0;
988
989 sdla_cmd(dev, SDLA_ENABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
990
991
992 memset(&intr, 0, sizeof(intr));
993 switch(flp->type)
994 {
995 case SDLA_S502A:
996 flp->timer.expires = 1;
997 add_timer(&flp->timer);
998 break;
999
1000 case SDLA_S502E:
1001 flp->state |= SDLA_S502E_ENABLE;
1002 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
1003 flp->state |= SDLA_S502E_INTACK;
1004 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
1005 byte = 0;
1006 sdla_write(dev, SDLA_502_IRQ_INTERFACE, &byte, sizeof(byte));
1007 intr.flags = SDLA_INTR_RX | SDLA_INTR_STATUS | SDLA_INTR_MODEM;
1008 sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(char) + sizeof(short), NULL, NULL);
1009 break;
1010
1011 case SDLA_S507:
1012 break;
1013
1014 case SDLA_S508:
1015 flp->state |= SDLA_S508_INTEN;
1016 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
1017 byte = 0;
1018 sdla_write(dev, SDLA_508_IRQ_INTERFACE, &byte, sizeof(byte));
1019 intr.flags = SDLA_INTR_RX | SDLA_INTR_STATUS | SDLA_INTR_MODEM;
1020 intr.irq = dev->irq;
1021 sdla_cmd(dev, SDLA_SET_IRQ_TRIGGER, 0, 0, &intr, sizeof(struct intr_info), NULL, NULL);
1022 break;
1023 }
1024
1025 if (flp->config.station == FRAD_STATION_CPE)
1026 {
1027 byte = SDLA_ICS_STATUS_ENQ;
1028 sdla_cmd(dev, SDLA_ISSUE_IN_CHANNEL_SIGNAL, 0, 0, &byte, sizeof(byte), NULL, NULL);
1029 }
1030 else
1031 {
1032 sdla_cmd(dev, SDLA_ADD_DLCI, 0, 0, data.dlci, len - sizeof(struct frad_conf), NULL, NULL);
1033 for(i=0;i<CONFIG_DLCI_MAX;i++)
1034 if (flp->dlci[i] > 0)
1035 sdla_cmd(dev, SDLA_ACTIVATE_DLCI, 0, 0, &flp->dlci[i], 2*sizeof(flp->dlci[i]), NULL, NULL);
1036 }
1037
1038
1039 for(i=0;i<CONFIG_DLCI_MAX;i++)
1040 if (flp->dlci[i])
1041 {
1042 dlp = flp->master[i]->priv;
1043 if (dlp->configured)
1044 sdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, abs(flp->dlci[i]), 0, &dlp->config, sizeof(struct dlci_conf), NULL, NULL);
1045 }
1046
1047 dev->tbusy = 0;
1048 dev->interrupt = 0;
1049 dev->start = 1;
1050
1051 MOD_INC_USE_COUNT;
1052
1053 return(0);
1054 }
1055
1056 static int sdla_config(struct device *dev, struct frad_conf *conf, int get)
1057 {
1058 struct frad_local *flp;
1059 struct conf_data data;
1060 int i, err;
1061 short size;
1062
1063 if (dev->type == 0xFFFF)
1064 return(-EUNATCH);
1065
1066 flp = dev->priv;
1067
1068 if (!get)
1069 {
1070 if (dev->start)
1071 return(-EBUSY);
1072
1073 err = verify_area(VERIFY_READ, conf, sizeof(struct frad_conf));
1074 if (err)
1075 return(err);
1076
1077 memcpy_fromfs(&data.config, conf, sizeof(struct frad_conf));
1078
1079 if (data.config.station & ~FRAD_STATION_NODE)
1080 return(-EINVAL);
1081
1082 if (data.config.flags & ~FRAD_VALID_FLAGS)
1083 return(-EINVAL);
1084
1085 if ((data.config.kbaud < 0) ||
1086 ((data.config.kbaud > 128) && (flp->type != SDLA_S508)))
1087 return(-EINVAL);
1088
1089 if (data.config.clocking & ~(FRAD_CLOCK_INT | SDLA_S508_PORT_RS232))
1090 return(-EINVAL);
1091
1092 if ((data.config.mtu < 0) || (data.config.mtu > SDLA_MAX_MTU))
1093 return(-EINVAL);
1094
1095 if ((data.config.T391 < 5) || (data.config.T391 > 30))
1096 return(-EINVAL);
1097
1098 if ((data.config.T392 < 5) || (data.config.T392 > 30))
1099 return(-EINVAL);
1100
1101 if ((data.config.N391 < 1) || (data.config.N391 > 255))
1102 return(-EINVAL);
1103
1104 if ((data.config.N392 < 1) || (data.config.N392 > 10))
1105 return(-EINVAL);
1106
1107 if ((data.config.N393 < 1) || (data.config.N393 > 10))
1108 return(-EINVAL);
1109
1110 memcpy(&flp->config, &data.config, sizeof(struct frad_conf));
1111 flp->config.flags |= SDLA_DIRECT_RECV;
1112
1113 if (dev->mtu != flp->config.mtu)
1114 {
1115
1116 dev->mtu = flp->config.mtu;
1117 for(i=0;i<CONFIG_DLCI_MAX;i++)
1118 if (flp->master[i])
1119 flp->master[i]->mtu = flp->config.mtu;
1120 }
1121
1122 flp->config.mtu += sizeof(struct fradhdr);
1123 flp->configured = 1;
1124 }
1125 else
1126 {
1127 err = verify_area(VERIFY_WRITE, conf, sizeof(struct frad_conf));
1128 if (err)
1129 return(err);
1130
1131
1132 if (dev->start)
1133 {
1134 size = sizeof(data);
1135 if (sdla_cmd(dev, SDLA_READ_DLCI_CONFIGURATION, 0, 0, NULL, 0, &data, &size) != SDLA_RET_OK)
1136 return(-EIO);
1137 }
1138 else
1139 if (flp->configured)
1140 memcpy(&data.config, &flp->config, sizeof(struct frad_conf));
1141 else
1142 memset(&data.config, 0, sizeof(struct frad_conf));
1143
1144 memcpy(&flp->config, &data.config, sizeof(struct frad_conf));
1145 data.config.flags &= ~SDLA_DIRECT_RECV;
1146 data.config.mtu -= data.config.mtu > sizeof(struct fradhdr) ? sizeof(struct fradhdr) : data.config.mtu;
1147 memcpy_tofs(conf, &data.config, sizeof(struct frad_conf));
1148 }
1149
1150 return(0);
1151 }
1152
1153 static int sdla_xfer(struct device *dev, struct sdla_mem *info, int read)
1154 {
1155 struct sdla_mem mem;
1156 int err;
1157 char *temp;
1158
1159 err = verify_area(VERIFY_READ, info, sizeof(struct sdla_mem));
1160 if (err)
1161 return(err);
1162
1163 memcpy_fromfs(&mem, info, sizeof(mem));
1164 if (read)
1165 {
1166 err = verify_area(VERIFY_WRITE, mem.data, mem.len);
1167 if (err)
1168 return(err);
1169
1170 temp = kmalloc(mem.len, GFP_KERNEL);
1171 if (!temp)
1172 return(-ENOMEM);
1173 sdla_read(dev, mem.addr, temp, mem.len);
1174 memcpy_tofs(mem.data, temp, mem.len);
1175 kfree(temp);
1176 }
1177 else
1178 {
1179 err = verify_area(VERIFY_READ, mem.data, mem.len);
1180 if (err)
1181 return(err);
1182
1183 temp = kmalloc(mem.len, GFP_KERNEL);
1184 if (!temp)
1185 return(-ENOMEM);
1186 memcpy_fromfs(temp, mem.data, mem.len);
1187 sdla_write(dev, mem.addr, temp, mem.len);
1188 kfree(temp);
1189 }
1190 return(0);
1191 }
1192
1193 static int sdla_reconfig(struct device *dev)
1194 {
1195 struct frad_local *flp;
1196 struct conf_data data;
1197 int i, len;
1198
1199 flp = dev->priv;
1200
1201 memcpy(&data, &flp->config, sizeof(struct frad_conf));
1202
1203 len = 0;
1204 for(i=0;i<CONFIG_DLCI_MAX;i++)
1205 if (flp->dlci[i])
1206 data.dlci[len++] = flp->dlci[i];
1207 len *= 2;
1208 len += sizeof(struct frad_conf);
1209
1210 sdla_cmd(dev, SDLA_DISABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
1211 sdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, 0, 0, &data, len, NULL, NULL);
1212 sdla_cmd(dev, SDLA_ENABLE_COMMUNICATIONS, 0, 0, NULL, 0, NULL, NULL);
1213
1214 return(0);
1215 }
1216
1217 static int sdla_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
1218 {
1219 struct frad_local *flp;
1220
1221 flp = dev->priv;
1222
1223 if (!flp->initialized)
1224 return(-EPERM);
1225
1226 switch (cmd)
1227 {
1228 case FRAD_GET_CONF:
1229 case FRAD_SET_CONF:
1230 return(sdla_config(dev, (struct frad_conf *)ifr->ifr_data, cmd == FRAD_GET_CONF));
1231
1232 case SDLA_IDENTIFY:
1233 ifr->ifr_flags = flp->type;
1234 break;
1235
1236 case SDLA_CPUSPEED:
1237 return(sdla_cpuspeed(dev, ifr));
1238
1239
1240
1241
1242
1243
1244
1245 case SDLA_PROTOCOL:
1246 if (flp->configured)
1247 return(-EALREADY);
1248
1249 switch (ifr->ifr_flags)
1250 {
1251 case ARPHRD_FRAD:
1252 dev->type = ifr->ifr_flags;
1253 dev->family = AF_UNSPEC;
1254 break;
1255
1256 default:
1257 return(-ENOPROTOOPT);
1258 }
1259 break;
1260
1261 case SDLA_CLEARMEM:
1262 sdla_clear(dev);
1263 break;
1264
1265 case SDLA_WRITEMEM:
1266 case SDLA_READMEM:
1267 return(sdla_xfer(dev, (struct sdla_mem *)ifr->ifr_data, cmd == SDLA_READMEM));
1268
1269 case SDLA_START:
1270 sdla_start(dev);
1271 break;
1272
1273 case SDLA_STOP:
1274 sdla_stop(dev);
1275 break;
1276
1277 default:
1278 return(-EOPNOTSUPP);
1279 }
1280 return(0);
1281 }
1282
1283 int sdla_change_mtu(struct device *dev, int new_mtu)
1284 {
1285 struct frad_local *flp;
1286
1287 flp = dev->priv;
1288
1289 if (dev->start)
1290 return(-EBUSY);
1291
1292
1293 return(-EACCES);
1294 }
1295
1296 int sdla_set_config(struct device *dev, struct ifmap *map)
1297 {
1298 struct frad_local *flp;
1299 int i;
1300 char byte;
1301
1302 flp = dev->priv;
1303
1304 if (flp->initialized)
1305 return(-EINVAL);
1306
1307 for(i=0;i < sizeof(valid_port) / sizeof (int) ; i++)
1308 if (valid_port[i] == map->base_addr)
1309 break;
1310
1311 if (i == sizeof(valid_port) / sizeof(int))
1312 return(-EINVAL);
1313
1314 dev->base_addr = map->base_addr;
1315 request_region(dev->base_addr, SDLA_IO_EXTENTS, dev->name);
1316
1317
1318
1319 flp->type = SDLA_UNKNOWN;
1320 flp->state = 0;
1321
1322 for(i=1;i<SDLA_IO_EXTENTS;i++)
1323 if (inb(dev->base_addr + i) != 0xFF)
1324 break;
1325
1326 if (i == SDLA_IO_EXTENTS)
1327 {
1328 outb(SDLA_HALT, dev->base_addr + SDLA_REG_Z80_CONTROL);
1329 if ((inb(dev->base_addr + SDLA_S502_STS) & 0x0F) == 0x08)
1330 {
1331 outb(SDLA_S502E_INTACK, dev->base_addr + SDLA_REG_CONTROL);
1332 if ((inb(dev->base_addr + SDLA_S502_STS) & 0x0F) == 0x0C)
1333 {
1334 outb(SDLA_HALT, dev->base_addr + SDLA_REG_CONTROL);
1335 flp->type = SDLA_S502E;
1336 }
1337 }
1338 }
1339
1340 if (flp->type == SDLA_UNKNOWN)
1341 {
1342 for(byte=inb(dev->base_addr),i=0;i<SDLA_IO_EXTENTS;i++)
1343 if (inb(dev->base_addr + i) != byte)
1344 break;
1345
1346 if (i == SDLA_IO_EXTENTS)
1347 {
1348 outb(SDLA_HALT, dev->base_addr + SDLA_REG_CONTROL);
1349 if ((inb(dev->base_addr + SDLA_S502_STS) & 0x7E) == 0x30)
1350 {
1351 outb(SDLA_S507_ENABLE, dev->base_addr + SDLA_REG_CONTROL);
1352 if ((inb(dev->base_addr + SDLA_S502_STS) & 0x7E) == 0x32)
1353 {
1354 outb(SDLA_HALT, dev->base_addr + SDLA_REG_CONTROL);
1355 flp->type = SDLA_S507;
1356 }
1357 }
1358 }
1359 }
1360
1361 if (flp->type == SDLA_UNKNOWN)
1362 {
1363 outb(SDLA_HALT, dev->base_addr + SDLA_REG_CONTROL);
1364 if ((inb(dev->base_addr + SDLA_S508_STS) & 0x3F) == 0x00)
1365 {
1366 outb(SDLA_S508_INTEN, dev->base_addr + SDLA_REG_CONTROL);
1367 if ((inb(dev->base_addr + SDLA_S508_STS) & 0x3F) == 0x10)
1368 {
1369 outb(SDLA_HALT, dev->base_addr + SDLA_REG_CONTROL);
1370 flp->type = SDLA_S508;
1371 }
1372 }
1373 }
1374
1375 if (flp->type == SDLA_UNKNOWN)
1376 {
1377 outb(SDLA_S502A_HALT, dev->base_addr + SDLA_REG_CONTROL);
1378 if (inb(dev->base_addr + SDLA_S502_STS) == 0x40)
1379 {
1380 outb(SDLA_S502A_START, dev->base_addr + SDLA_REG_CONTROL);
1381 if (inb(dev->base_addr + SDLA_S502_STS) == 0x40)
1382 {
1383 outb(SDLA_S502A_INTEN, dev->base_addr + SDLA_REG_CONTROL);
1384 if (inb(dev->base_addr + SDLA_S502_STS) == 0x44)
1385 {
1386 outb(SDLA_S502A_START, dev->base_addr + SDLA_REG_CONTROL);
1387 flp->type = SDLA_S502A;
1388 }
1389 }
1390 }
1391 }
1392
1393 if (flp->type == SDLA_UNKNOWN)
1394 {
1395 printk(KERN_NOTICE "%s: Unknown card type\n", dev->name);
1396 return(-ENODEV);
1397 }
1398
1399 switch(dev->base_addr)
1400 {
1401 case 0x270:
1402 case 0x280:
1403 case 0x380:
1404 case 0x390:
1405 if ((flp->type != SDLA_S508) && (flp->type != SDLA_S507))
1406 return(-EINVAL);
1407 }
1408
1409 switch (map->irq)
1410 {
1411 case 2:
1412 if (flp->type != SDLA_S502E)
1413 return(-EINVAL);
1414 break;
1415
1416 case 10:
1417 case 11:
1418 case 12:
1419 case 15:
1420 case 4:
1421 if ((flp->type != SDLA_S508) && (flp->type != SDLA_S507))
1422 return(-EINVAL);
1423
1424 case 3:
1425 case 5:
1426 case 7:
1427 if (flp->type == SDLA_S502A)
1428 return(-EINVAL);
1429 break;
1430
1431 default:
1432 return(-EINVAL);
1433 }
1434 dev->irq = map->irq;
1435
1436 if (request_irq(dev->irq, &sdla_isr, 0, dev->name, NULL))
1437 return(-EADDRINUSE);
1438
1439 irq2dev_map[dev->irq] = dev;
1440
1441 if (flp->type == SDLA_S507)
1442 {
1443 switch(dev->irq)
1444 {
1445 case 3:
1446 flp->state = SDLA_S507_IRQ3;
1447 break;
1448 case 4:
1449 flp->state = SDLA_S507_IRQ4;
1450 break;
1451 case 5:
1452 flp->state = SDLA_S507_IRQ5;
1453 break;
1454 case 7:
1455 flp->state = SDLA_S507_IRQ7;
1456 break;
1457 case 10:
1458 flp->state = SDLA_S507_IRQ10;
1459 break;
1460 case 11:
1461 flp->state = SDLA_S507_IRQ11;
1462 break;
1463 case 12:
1464 flp->state = SDLA_S507_IRQ12;
1465 break;
1466 case 15:
1467 flp->state = SDLA_S507_IRQ15;
1468 break;
1469 }
1470 }
1471
1472 for(i=0;i < sizeof(valid_mem) / sizeof (int) ; i++)
1473 if (valid_mem[i] == map->mem_start)
1474 break;
1475
1476 if (i == sizeof(valid_mem) / sizeof(int))
1477 return(-EINVAL);
1478
1479 if ((flp->type == SDLA_S502A) && (((map->mem_start & 0xF000) >> 12) == 0x0E))
1480 return(-EINVAL);
1481
1482 if ((flp->type != SDLA_S507) && ((map->mem_start >> 16) == 0x0B))
1483 return(-EINVAL);
1484
1485 if ((flp->type == SDLA_S507) && ((map->mem_start >> 16) == 0x0D))
1486 return(-EINVAL);
1487
1488 dev->mem_start = map->mem_start;
1489 dev->mem_end = dev->mem_start + 0x2000;
1490
1491 byte = flp->type != SDLA_S508 ? SDLA_8K_WINDOW : 0;
1492 byte |= (map->mem_start & 0xF000) >> (12 + (flp->type == SDLA_S508 ? 1 : 0));
1493 switch(flp->type)
1494 {
1495 case SDLA_S502A:
1496 case SDLA_S502E:
1497 switch (map->mem_start >> 16)
1498 {
1499 case 0x0A:
1500 byte |= SDLA_S502_SEG_A;
1501 break;
1502 case 0x0C:
1503 byte |= SDLA_S502_SEG_C;
1504 break;
1505 case 0x0D:
1506 byte |= SDLA_S502_SEG_D;
1507 break;
1508 case 0x0E:
1509 byte |= SDLA_S502_SEG_E;
1510 break;
1511 }
1512 break;
1513 case SDLA_S507:
1514 switch (map->mem_start >> 16)
1515 {
1516 case 0x0A:
1517 byte |= SDLA_S507_SEG_A;
1518 break;
1519 case 0x0B:
1520 byte |= SDLA_S507_SEG_B;
1521 break;
1522 case 0x0C:
1523 byte |= SDLA_S507_SEG_C;
1524 break;
1525 case 0x0E:
1526 byte |= SDLA_S507_SEG_E;
1527 break;
1528 }
1529 break;
1530 case SDLA_S508:
1531 switch (map->mem_start >> 16)
1532 {
1533 case 0x0A:
1534 byte |= SDLA_S508_SEG_A;
1535 break;
1536 case 0x0C:
1537 byte |= SDLA_S508_SEG_C;
1538 break;
1539 case 0x0D:
1540 byte |= SDLA_S508_SEG_D;
1541 break;
1542 case 0x0E:
1543 byte |= SDLA_S508_SEG_E;
1544 break;
1545 }
1546 break;
1547 }
1548
1549
1550 outb(byte, dev->base_addr + SDLA_REG_PC_WINDOW);
1551 switch(flp->type)
1552 {
1553 case SDLA_S502E:
1554 flp->state = SDLA_S502E_ENABLE;
1555 break;
1556 case SDLA_S507:
1557 flp->state |= SDLA_MEMEN;
1558 break;
1559 case SDLA_S508:
1560 flp->state = SDLA_MEMEN;
1561 break;
1562 }
1563 outb(flp->state, dev->base_addr + SDLA_REG_CONTROL);
1564
1565 flp->initialized = 1;
1566 return(0);
1567 }
1568
1569 static struct enet_statistics *sdla_stats(struct device *dev)
1570 {
1571 struct frad_local *flp;
1572
1573 flp = dev->priv;
1574
1575 return(&flp->stats);
1576 }
1577
1578 int sdla_init(struct device *dev)
1579 {
1580 struct frad_local *flp;
1581 int i;
1582
1583
1584 flp = kmalloc(sizeof(struct frad_local), GFP_KERNEL);
1585 if (!flp)
1586 return(-ENOMEM);
1587
1588 memset(flp, 0, sizeof(struct frad_local));
1589 dev->priv = flp;
1590
1591 dev->flags = 0;
1592 dev->open = sdla_open;
1593 dev->stop = sdla_close;
1594 dev->do_ioctl = sdla_ioctl;
1595 dev->set_config = sdla_set_config;
1596 dev->get_stats = sdla_stats;
1597 dev->hard_start_xmit = sdla_transmit;
1598 dev->change_mtu = sdla_change_mtu;
1599
1600 dev->type = 0xFFFF;
1601 dev->family = AF_UNSPEC;
1602 dev->pa_alen = sizeof(unsigned long);
1603 dev->hard_header_len = 0;
1604 dev->mtu = SDLA_MAX_MTU;
1605
1606 for (i = 0; i < DEV_NUMBUFFS; i++)
1607 skb_queue_head_init(&dev->buffs[i]);
1608
1609 flp->activate = sdla_activate;
1610 flp->deactivate = sdla_deactivate;
1611 flp->assoc = sdla_assoc;
1612 flp->deassoc = sdla_deassoc;
1613 flp->dlci_conf = sdla_dlci_conf;
1614
1615 init_timer(&flp->timer);
1616 flp->timer.expires = 1;
1617 flp->timer.data = (unsigned long) dev;
1618 flp->timer.function = sdla_poll;
1619
1620 return(0);
1621 }
1622
1623 void sdla_setup(void)
1624 {
1625 printk("%s.\n", version);
1626 register_frad(devname);
1627 }
1628
1629 #ifdef MODULE
1630 static struct device sdla0 = {"sdla0", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, sdla_init};
1631
1632 int init_module(void)
1633 {
1634 int result;
1635
1636 sdla_setup();
1637 if ((result = register_netdev(&sdla0)) != 0)
1638 return result;
1639
1640 return 0;
1641 }
1642
1643 void cleanup_module(void)
1644 {
1645 unregister_netdev(&sdla0);
1646 if (sdla0.priv)
1647 kfree(sdla0.priv);
1648 if (sdla0.irq)
1649 free_irq(sdla0.irq, NULL);
1650 }
1651 #endif