2 * SDLA An implementation of a driver for the Sangoma S502/S508 series
3 * multi-protocol PC interface card. Initial offering is with
4 * the DLCI driver, providing Frame Relay support for linux.
6 * Global definitions for the Frame relay interface.
8 * Version: @(#)sdla.c 0.30 12 Sep 1996
10 * Credits: Sangoma Technologies, for the use of 2 cards for an extended
12 * David Mandelstam <dm@sangoma.com> for getting me started on
13 * this project, and incentive to complete it.
14 * Gene Kozen <74604.152@compuserve.com> for providing me with
15 * important information about the cards.
17 * Author: Mike McLagan <mike.mclagan@linux.org>
20 * 0.15 Mike McLagan Improved error handling, packet dropping
21 * 0.20 Mike McLagan New transmit/receive flags for config
22 * If in FR mode, don't accept packets from
24 * 0.25 Mike McLagan Fixed problem with rejecting packets
25 * from non DLCI devices.
26 * 0.30 Mike McLagan Fixed kernel panic when used with modified
29 * This program is free software; you can redistribute it and/or
30 * modify it under the terms of the GNU General Public License
31 * as published by the Free Software Foundation; either version
32 * 2 of the License, or (at your option) any later version.
35 #include <linux/config.h> /* for CONFIG_DLCI_MAX */
36 #include <linux/module.h>
38 #include <linux/kernel.h>
39 #include <linux/sched.h>
40 #include <linux/types.h>
41 #include <linux/fcntl.h>
42 #include <linux/interrupt.h>
43 #include <linux/ptrace.h>
44 #include <linux/ioport.h>
46 #include <linux/malloc.h>
47 #include <linux/string.h>
48 #include <linux/timer.h>
49 #include <linux/errno.h>
50 #include <linux/init.h>
52 #include <asm/system.h>
53 #include <asm/bitops.h>
56 #include <asm/uaccess.h>
58 #include <linux/netdevice.h>
59 #include <linux/skbuff.h>
60 #include <linux/if_arp.h>
61 #include <linux/if_frad.h>
63 #include <linux/sdla.h>
65 static const char* version
= "SDLA driver v0.30, 12 Sep 1996, mike.mclagan@linux.org";
67 static const char* devname
= "sdla";
69 static unsigned int valid_port
[] __initdata
= { 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390};
71 static unsigned int valid_mem
[] __initdata
= {
72 0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000,
73 0xB0000, 0xB2000, 0xB4000, 0xB6000, 0xB8000, 0xBA000, 0xBC000, 0xBE000,
74 0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
75 0xD0000, 0xD2000, 0xD4000, 0xD6000, 0xD8000, 0xDA000, 0xDC000, 0xDE000,
76 0xE0000, 0xE2000, 0xE4000, 0xE6000, 0xE8000, 0xEA000, 0xEC000, 0xEE000};
78 /*********************************************************
80 * these are the core routines that access the card itself
82 *********************************************************/
84 #define SDLA_WINDOW(dev,addr) outb((((addr) >> 13) & 0x1F), (dev)->base_addr + SDLA_REG_Z80_WINDOW)
86 static void sdla_read(struct net_device
*dev
, int addr
, void *buf
, short len
)
95 offset
= addr
& SDLA_ADDR_MASK
;
96 bytes
= offset
+ len
> SDLA_WINDOW_SIZE
? SDLA_WINDOW_SIZE
- offset
: len
;
97 base
= (void *) (dev
->mem_start
+ offset
);
101 SDLA_WINDOW(dev
, addr
);
102 memcpy(temp
, base
, bytes
);
103 restore_flags(flags
);
111 static void sdla_write(struct net_device
*dev
, int addr
, void *buf
, short len
)
120 offset
= addr
& SDLA_ADDR_MASK
;
121 bytes
= offset
+ len
> SDLA_WINDOW_SIZE
? SDLA_WINDOW_SIZE
- offset
: len
;
122 base
= (void *) (dev
->mem_start
+ offset
);
125 SDLA_WINDOW(dev
, addr
);
126 memcpy(base
, temp
, bytes
);
127 restore_flags(flags
);
134 static void sdla_clear(struct net_device
*dev
)
138 int len
, addr
, bytes
;
142 bytes
= SDLA_WINDOW_SIZE
;
143 base
= (void *) dev
->mem_start
;
149 SDLA_WINDOW(dev
, addr
);
150 memset(base
, 0, bytes
);
155 restore_flags(flags
);
158 static char sdla_byte(struct net_device
*dev
, int addr
)
163 temp
= (void *) (dev
->mem_start
+ (addr
& SDLA_ADDR_MASK
));
167 SDLA_WINDOW(dev
, addr
);
169 restore_flags(flags
);
174 void sdla_stop(struct net_device
*dev
)
176 struct frad_local
*flp
;
182 outb(SDLA_S502A_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
183 flp
->state
= SDLA_HALT
;
186 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_Z80_CONTROL
);
187 outb(SDLA_S502E_ENABLE
, dev
->base_addr
+ SDLA_REG_CONTROL
);
188 flp
->state
= SDLA_S502E_ENABLE
;
191 flp
->state
&= ~SDLA_CPUEN
;
192 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
195 flp
->state
&= ~SDLA_CPUEN
;
196 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
201 void sdla_start(struct net_device
*dev
)
203 struct frad_local
*flp
;
209 outb(SDLA_S502A_NMI
, dev
->base_addr
+ SDLA_REG_CONTROL
);
210 outb(SDLA_S502A_START
, dev
->base_addr
+ SDLA_REG_CONTROL
);
211 flp
->state
= SDLA_S502A_START
;
214 outb(SDLA_S502E_CPUEN
, dev
->base_addr
+ SDLA_REG_Z80_CONTROL
);
215 outb(0x00, dev
->base_addr
+ SDLA_REG_CONTROL
);
219 flp
->state
|= SDLA_CPUEN
;
220 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
223 flp
->state
|= SDLA_CPUEN
;
224 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
229 /****************************************************
231 * this is used for the S502A/E cards to determine
232 * the speed of the onboard CPU. Calibration is
233 * necessary for the Frame Relay code uploaded
234 * later. Incorrect results cause timing problems
235 * with link checks & status messages
237 ***************************************************/
239 int sdla_z80_poll(struct net_device
*dev
, int z80_addr
, int jiffs
, char resp1
, char resp2
)
241 unsigned long start
, done
, now
;
244 start
= now
= jiffies
;
245 done
= jiffies
+ jiffs
;
247 temp
= (void *)dev
->mem_start
;
248 temp
+= z80_addr
& SDLA_ADDR_MASK
;
251 while (time_before(jiffies
, done
) && (resp
!= resp1
) && (!resp2
|| (resp
!= resp2
)))
255 SDLA_WINDOW(dev
, z80_addr
);
260 return(time_before(jiffies
, done
) ? jiffies
- start
: -1);
263 /* constants for Z80 CPU speed */
264 #define Z80_READY '1' /* Z80 is ready to begin */
265 #define LOADER_READY '2' /* driver is ready to begin */
266 #define Z80_SCC_OK '3' /* SCC is on board */
267 #define Z80_SCC_BAD '4' /* SCC was not found */
269 static int sdla_cpuspeed(struct net_device
*dev
, struct ifreq
*ifr
)
275 if (sdla_z80_poll(dev
, 0, 3*HZ
, Z80_READY
, 0) < 0)
279 sdla_write(dev
, 0, &data
, 1);
281 if ((jiffs
= sdla_z80_poll(dev
, 0, 8*HZ
, Z80_SCC_OK
, Z80_SCC_BAD
)) < 0)
285 sdla_read(dev
, 0, &data
, 1);
287 if (data
== Z80_SCC_BAD
)
289 printk("%s: SCC bad\n", dev
->name
);
293 if (data
!= Z80_SCC_OK
)
297 ifr
->ifr_mtu
= SDLA_CPU_16M
;
298 else if (jiffs
< 220)
299 ifr
->ifr_mtu
= SDLA_CPU_10M
;
300 else if (jiffs
< 258)
301 ifr
->ifr_mtu
= SDLA_CPU_8M
;
302 else if (jiffs
< 357)
303 ifr
->ifr_mtu
= SDLA_CPU_7M
;
304 else if (jiffs
< 467)
305 ifr
->ifr_mtu
= SDLA_CPU_5M
;
307 ifr
->ifr_mtu
= SDLA_CPU_3M
;
312 /************************************************
314 * Direct interaction with the Frame Relay code
317 ************************************************/
321 short dlci
__attribute__((packed
));
322 char flags
__attribute__((packed
));
328 struct _dlci_stat dlcis
[SDLA_MAX_DLCI
];
331 static void sdla_errors(struct net_device
*dev
, int cmd
, int dlci
, int ret
, int len
, void *data
)
333 struct _dlci_stat
*pstatus
;
336 char *state
, line
[30];
342 if (*state
& SDLA_MODEM_DCD_LOW
)
343 printk(KERN_INFO
"%s: Modem DCD unexpectedly low!\n", dev
->name
);
344 if (*state
& SDLA_MODEM_CTS_LOW
)
345 printk(KERN_INFO
"%s: Modem CTS unexpectedly low!\n", dev
->name
);
346 /* I should probably do something about this! */
349 case SDLA_RET_CHANNEL_OFF
:
350 printk(KERN_INFO
"%s: Channel became inoperative!\n", dev
->name
);
354 case SDLA_RET_CHANNEL_ON
:
355 printk(KERN_INFO
"%s: Channel became operative!\n", dev
->name
);
359 case SDLA_RET_DLCI_STATUS
:
360 printk(KERN_INFO
"%s: Status change reported by Access Node.\n", dev
->name
);
361 len
/= sizeof(struct _dlci_stat
);
362 for(pstatus
= data
, i
=0;i
< len
;i
++,pstatus
++)
364 if (pstatus
->flags
& SDLA_DLCI_NEW
)
366 else if (pstatus
->flags
& SDLA_DLCI_DELETED
)
368 else if (pstatus
->flags
& SDLA_DLCI_ACTIVE
)
372 sprintf(line
, "unknown status: %02X", pstatus
->flags
);
375 printk(KERN_INFO
"%s: DLCI %i: %s.\n", dev
->name
, pstatus
->dlci
, state
);
380 case SDLA_RET_DLCI_UNKNOWN
:
381 printk(KERN_INFO
"%s: Received unknown DLCIs:", dev
->name
);
382 len
/= sizeof(short);
383 for(pdlci
= data
,i
=0;i
< len
;i
++,pdlci
++)
384 printk(" %i", *pdlci
);
388 case SDLA_RET_TIMEOUT
:
389 printk(KERN_ERR
"%s: Command timed out!\n", dev
->name
);
392 case SDLA_RET_BUF_OVERSIZE
:
393 printk(KERN_INFO
"%s: Bc/CIR overflow, acceptable size is %i\n", dev
->name
, len
);
396 case SDLA_RET_BUF_TOO_BIG
:
397 printk(KERN_INFO
"%s: Buffer size over specified max of %i\n", dev
->name
, len
);
400 case SDLA_RET_CHANNEL_INACTIVE
:
401 case SDLA_RET_DLCI_INACTIVE
:
402 case SDLA_RET_CIR_OVERFLOW
:
403 case SDLA_RET_NO_BUFS
:
404 if (cmd
== SDLA_INFORMATION_WRITE
)
408 printk(KERN_DEBUG
"%s: Cmd 0x%2.2X generated return code 0x%2.2X\n", dev
->name
, cmd
, ret
);
409 /* Further processing could be done here */
414 static int sdla_cmd(struct net_device
*dev
, int cmd
, short dlci
, short flags
,
415 void *inbuf
, short inlen
, void *outbuf
, short *outlen
)
417 static struct _frad_stat status
;
418 struct frad_local
*flp
;
419 struct sdla_cmd
*cmd_buf
;
420 unsigned long pflags
;
421 int jiffs
, ret
, waiting
, len
;
425 window
= flp
->type
== SDLA_S508
? SDLA_508_CMD_BUF
: SDLA_502_CMD_BUF
;
426 cmd_buf
= (struct sdla_cmd
*)(dev
->mem_start
+ (window
& SDLA_ADDR_MASK
));
429 jiffs
= jiffies
+ HZ
; /* 1 second is plenty */
432 SDLA_WINDOW(dev
, window
);
434 cmd_buf
->dlci
= dlci
;
435 cmd_buf
->flags
= flags
;
438 memcpy(cmd_buf
->data
, inbuf
, inlen
);
440 cmd_buf
->length
= inlen
;
442 cmd_buf
->opp_flag
= 1;
443 restore_flags(pflags
);
447 while (waiting
&& time_before_eq(jiffies
, jiffs
))
453 SDLA_WINDOW(dev
, window
);
454 waiting
= ((volatile int)(cmd_buf
->opp_flag
));
455 restore_flags(pflags
);
463 SDLA_WINDOW(dev
, window
);
464 ret
= cmd_buf
->retval
;
465 len
= cmd_buf
->length
;
466 if (outbuf
&& outlen
)
468 *outlen
= *outlen
>= len
? len
: *outlen
;
471 memcpy(outbuf
, cmd_buf
->data
, *outlen
);
474 /* This is a local copy that's used for error handling */
476 memcpy(&status
, cmd_buf
->data
, len
> sizeof(status
) ? sizeof(status
) : len
);
478 restore_flags(pflags
);
481 ret
= SDLA_RET_TIMEOUT
;
483 if (ret
!= SDLA_RET_OK
)
484 sdla_errors(dev
, cmd
, dlci
, ret
, len
, &status
);
489 /***********************************************
491 * these functions are called by the DLCI driver
493 ***********************************************/
495 static int sdla_reconfig(struct net_device
*dev
);
497 int sdla_activate(struct net_device
*slave
, struct net_device
*master
)
499 struct frad_local
*flp
;
504 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
505 if (flp
->master
[i
] == master
)
508 if (i
== CONFIG_DLCI_MAX
)
511 flp
->dlci
[i
] = abs(flp
->dlci
[i
]);
513 if (netif_running(slave
) && (flp
->config
.station
== FRAD_STATION_NODE
))
514 sdla_cmd(slave
, SDLA_ACTIVATE_DLCI
, 0, 0, &flp
->dlci
[i
], sizeof(short), NULL
, NULL
);
519 int sdla_deactivate(struct net_device
*slave
, struct net_device
*master
)
521 struct frad_local
*flp
;
526 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
527 if (flp
->master
[i
] == master
)
530 if (i
== CONFIG_DLCI_MAX
)
533 flp
->dlci
[i
] = -abs(flp
->dlci
[i
]);
535 if (netif_running(slave
) && (flp
->config
.station
== FRAD_STATION_NODE
))
536 sdla_cmd(slave
, SDLA_DEACTIVATE_DLCI
, 0, 0, &flp
->dlci
[i
], sizeof(short), NULL
, NULL
);
541 int sdla_assoc(struct net_device
*slave
, struct net_device
*master
)
543 struct frad_local
*flp
;
546 if (master
->type
!= ARPHRD_DLCI
)
551 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
555 if (abs(flp
->dlci
[i
]) == *(short *)(master
->dev_addr
))
559 if (i
== CONFIG_DLCI_MAX
)
560 return(-EMLINK
); /* #### Alan: Comments on this ?? */
564 flp
->master
[i
] = master
;
565 flp
->dlci
[i
] = -*(short *)(master
->dev_addr
);
566 master
->mtu
= slave
->mtu
;
568 if (netif_running(slave
)) {
569 if (flp
->config
.station
== FRAD_STATION_CPE
)
570 sdla_reconfig(slave
);
572 sdla_cmd(slave
, SDLA_ADD_DLCI
, 0, 0, master
->dev_addr
, sizeof(short), NULL
, NULL
);
578 int sdla_deassoc(struct net_device
*slave
, struct net_device
*master
)
580 struct frad_local
*flp
;
585 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
586 if (flp
->master
[i
] == master
)
589 if (i
== CONFIG_DLCI_MAX
)
592 flp
->master
[i
] = NULL
;
597 if (netif_running(slave
)) {
598 if (flp
->config
.station
== FRAD_STATION_CPE
)
599 sdla_reconfig(slave
);
601 sdla_cmd(slave
, SDLA_DELETE_DLCI
, 0, 0, master
->dev_addr
, sizeof(short), NULL
, NULL
);
607 int sdla_dlci_conf(struct net_device
*slave
, struct net_device
*master
, int get
)
609 struct frad_local
*flp
;
610 struct dlci_local
*dlp
;
616 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
617 if (flp
->master
[i
] == master
)
620 if (i
== CONFIG_DLCI_MAX
)
626 len
= sizeof(struct dlci_conf
);
627 if (netif_running(slave
)) {
629 ret
= sdla_cmd(slave
, SDLA_READ_DLCI_CONFIGURATION
, abs(flp
->dlci
[i
]), 0,
630 NULL
, 0, &dlp
->config
, &len
);
632 ret
= sdla_cmd(slave
, SDLA_SET_DLCI_CONFIGURATION
, abs(flp
->dlci
[i
]), 0,
633 &dlp
->config
, sizeof(struct dlci_conf
) - 4 * sizeof(short), NULL
, NULL
);
636 return(ret
== SDLA_RET_OK
? 0 : -EIO
);
639 /**************************
641 * now for the Linux driver
643 **************************/
645 /* NOTE: the DLCI driver deals with freeing the SKB!! */
646 static int sdla_transmit(struct sk_buff
*skb
, struct net_device
*dev
)
648 struct frad_local
*flp
;
649 int ret
, addr
, accept
, i
;
652 struct buf_entry
*pbuf
;
658 netif_stop_queue(dev
);
661 * stupid GateD insists on setting up the multicast router thru us
662 * and we're ill equipped to handle a non Frame Relay packet at this
670 if (skb
->dev
->type
!= ARPHRD_DLCI
)
672 printk(KERN_WARNING
"%s: Non DLCI device, type %i, tried to send on FRAD module.\n", dev
->name
, skb
->dev
->type
);
677 printk(KERN_WARNING
"%s: unknown firmware type 0x%4.4X\n", dev
->name
, dev
->type
);
683 /* this is frame specific, but till there's a PPP module, it's the default */
688 ret
= sdla_cmd(dev
, SDLA_INFORMATION_WRITE
, *(short *)(skb
->dev
->dev_addr
), 0, skb
->data
, skb
->len
, NULL
, NULL
);
692 ret
= sdla_cmd(dev
, SDLA_INFORMATION_WRITE
, *(short *)(skb
->dev
->dev_addr
), 0, NULL
, skb
->len
, &addr
, &size
);
693 if (ret
== SDLA_RET_OK
)
697 SDLA_WINDOW(dev
, addr
);
698 pbuf
= (void *)(((int) dev
->mem_start
) + (addr
& SDLA_ADDR_MASK
));
699 sdla_write(dev
, pbuf
->buf_addr
, skb
->data
, skb
->len
);
700 SDLA_WINDOW(dev
, addr
);
702 restore_flags(flags
);
709 flp
->stats
.tx_packets
++;
713 case SDLA_RET_CIR_OVERFLOW
:
714 case SDLA_RET_BUF_OVERSIZE
:
715 case SDLA_RET_NO_BUFS
:
716 flp
->stats
.tx_dropped
++;
721 flp
->stats
.tx_errors
++;
726 netif_wake_queue(dev
);
727 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
729 if(flp
->master
[i
]!=NULL
)
730 netif_wake_queue(flp
->master
[i
]);
735 static void sdla_receive(struct net_device
*dev
)
737 struct net_device
*master
;
738 struct frad_local
*flp
;
739 struct dlci_local
*dlp
;
742 struct sdla_cmd
*cmd
;
743 struct buf_info
*pbufi
;
744 struct buf_entry
*pbuf
;
747 int i
, received
, success
, addr
, buf_base
, buf_top
;
748 short dlci
, len
, len2
, split
;
752 received
= addr
= buf_top
= buf_base
= 0;
767 cmd
= (void *) (dev
->mem_start
+ (SDLA_502_RCV_BUF
& SDLA_ADDR_MASK
));
768 SDLA_WINDOW(dev
, SDLA_502_RCV_BUF
);
769 success
= cmd
->opp_flag
;
778 pbufi
= (void *) (dev
->mem_start
+ (SDLA_508_RXBUF_INFO
& SDLA_ADDR_MASK
));
779 SDLA_WINDOW(dev
, SDLA_508_RXBUF_INFO
);
780 pbuf
= (void *) (dev
->mem_start
+ ((pbufi
->rse_base
+ flp
->buffer
* sizeof(struct buf_entry
)) & SDLA_ADDR_MASK
));
781 success
= pbuf
->opp_flag
;
785 buf_top
= pbufi
->buf_top
;
786 buf_base
= pbufi
->buf_base
;
789 addr
= pbuf
->buf_addr
;
793 /* common code, find the DLCI and get the SKB */
796 for (i
=0;i
<CONFIG_DLCI_MAX
;i
++)
797 if (flp
->dlci
[i
] == dlci
)
800 if (i
== CONFIG_DLCI_MAX
)
802 printk(KERN_NOTICE
"%s: Received packet from invalid DLCI %i, ignoring.", dev
->name
, dlci
);
803 flp
->stats
.rx_errors
++;
810 master
= flp
->master
[i
];
811 skb
= dev_alloc_skb(len
+ sizeof(struct frhdr
));
814 printk(KERN_NOTICE
"%s: Memory squeeze, dropping packet.\n", dev
->name
);
815 flp
->stats
.rx_dropped
++;
819 skb_reserve(skb
, sizeof(struct frhdr
));
822 /* pick up the data */
828 sdla_read(dev
, SDLA_502_RCV_BUF
+ SDLA_502_DATA_OFS
, skb_put(skb
,len
), len
);
830 SDLA_WINDOW(dev
, SDLA_502_RCV_BUF
);
837 /* is this buffer split off the end of the internal ring buffer */
838 split
= addr
+ len
> buf_top
+ 1 ? len
- (buf_top
- addr
+ 1) : 0;
841 sdla_read(dev
, addr
, skb_put(skb
, len2
), len2
);
843 sdla_read(dev
, buf_base
, skb_put(skb
, split
), split
);
846 /* increment the buffer we're looking at */
847 SDLA_WINDOW(dev
, SDLA_508_RXBUF_INFO
);
848 flp
->buffer
= (flp
->buffer
+ 1) % pbufi
->rse_num
;
855 flp
->stats
.rx_packets
++;
857 (*dlp
->receive
)(skb
, master
);
860 restore_flags(flags
);
863 static void sdla_isr(int irq
, void *dev_id
, struct pt_regs
* regs
)
865 struct net_device
*dev
;
866 struct frad_local
*flp
;
873 printk(KERN_WARNING
"sdla_isr(): irq %d for unknown device.\n", irq
);
879 if (!flp
->initialized
)
881 printk(KERN_WARNING
"%s: irq %d for uninitialized device.\n", dev
->name
, irq
);
885 byte
= sdla_byte(dev
, flp
->type
== SDLA_S508
? SDLA_508_IRQ_INTERFACE
: SDLA_502_IRQ_INTERFACE
);
892 /* the command will get an error return, which is processed above */
893 case SDLA_INTR_MODEM
:
894 case SDLA_INTR_STATUS
:
895 sdla_cmd(dev
, SDLA_READ_DLC_STATUS
, 0, 0, NULL
, 0, NULL
, NULL
);
899 case SDLA_INTR_COMPLETE
:
900 case SDLA_INTR_TIMER
:
901 printk(KERN_WARNING
"%s: invalid irq flag 0x%02X.\n", dev
->name
, byte
);
905 /* the S502E requires a manual acknowledgement of the interrupt */
906 if (flp
->type
== SDLA_S502E
)
908 flp
->state
&= ~SDLA_S502E_INTACK
;
909 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
910 flp
->state
|= SDLA_S502E_INTACK
;
911 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
914 /* this clears the byte, informing the Z80 we're done */
916 sdla_write(dev
, flp
->type
== SDLA_S508
? SDLA_508_IRQ_INTERFACE
: SDLA_502_IRQ_INTERFACE
, &byte
, sizeof(byte
));
919 static void sdla_poll(unsigned long device
)
921 struct net_device
*dev
;
922 struct frad_local
*flp
;
924 dev
= (struct net_device
*) device
;
927 if (sdla_byte(dev
, SDLA_502_RCV_BUF
))
930 flp
->timer
.expires
= 1;
931 add_timer(&flp
->timer
);
934 static int sdla_close(struct net_device
*dev
)
936 struct frad_local
*flp
;
937 struct intr_info intr
;
939 short dlcis
[CONFIG_DLCI_MAX
];
944 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
946 dlcis
[len
++] = abs(flp
->dlci
[i
]);
949 if (flp
->config
.station
== FRAD_STATION_NODE
)
951 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
952 if (flp
->dlci
[i
] > 0)
953 sdla_cmd(dev
, SDLA_DEACTIVATE_DLCI
, 0, 0, dlcis
, len
, NULL
, NULL
);
954 sdla_cmd(dev
, SDLA_DELETE_DLCI
, 0, 0, &flp
->dlci
[i
], sizeof(flp
->dlci
[i
]), NULL
, NULL
);
957 memset(&intr
, 0, sizeof(intr
));
958 /* let's start up the reception */
962 del_timer(&flp
->timer
);
966 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(char) + sizeof(short), NULL
, NULL
);
967 flp
->state
&= ~SDLA_S502E_INTACK
;
968 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
975 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(struct intr_info
), NULL
, NULL
);
976 flp
->state
&= ~SDLA_S508_INTEN
;
977 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
981 sdla_cmd(dev
, SDLA_DISABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
983 netif_stop_queue(dev
);
991 struct frad_conf config
;
992 short dlci
[CONFIG_DLCI_MAX
];
995 static int sdla_open(struct net_device
*dev
)
997 struct frad_local
*flp
;
998 struct dlci_local
*dlp
;
999 struct conf_data data
;
1000 struct intr_info intr
;
1006 if (!flp
->initialized
)
1009 if (!flp
->configured
)
1012 /* time to send in the configuration */
1014 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1016 data
.dlci
[len
++] = abs(flp
->dlci
[i
]);
1019 memcpy(&data
.config
, &flp
->config
, sizeof(struct frad_conf
));
1020 len
+= sizeof(struct frad_conf
);
1022 sdla_cmd(dev
, SDLA_DISABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1023 sdla_cmd(dev
, SDLA_SET_DLCI_CONFIGURATION
, 0, 0, &data
, len
, NULL
, NULL
);
1025 if (flp
->type
== SDLA_S508
)
1028 sdla_cmd(dev
, SDLA_ENABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1030 /* let's start up the reception */
1031 memset(&intr
, 0, sizeof(intr
));
1035 flp
->timer
.expires
= 1;
1036 add_timer(&flp
->timer
);
1040 flp
->state
|= SDLA_S502E_ENABLE
;
1041 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1042 flp
->state
|= SDLA_S502E_INTACK
;
1043 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1045 sdla_write(dev
, SDLA_502_IRQ_INTERFACE
, &byte
, sizeof(byte
));
1046 intr
.flags
= SDLA_INTR_RX
| SDLA_INTR_STATUS
| SDLA_INTR_MODEM
;
1047 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(char) + sizeof(short), NULL
, NULL
);
1054 flp
->state
|= SDLA_S508_INTEN
;
1055 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1057 sdla_write(dev
, SDLA_508_IRQ_INTERFACE
, &byte
, sizeof(byte
));
1058 intr
.flags
= SDLA_INTR_RX
| SDLA_INTR_STATUS
| SDLA_INTR_MODEM
;
1059 intr
.irq
= dev
->irq
;
1060 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(struct intr_info
), NULL
, NULL
);
1064 if (flp
->config
.station
== FRAD_STATION_CPE
)
1066 byte
= SDLA_ICS_STATUS_ENQ
;
1067 sdla_cmd(dev
, SDLA_ISSUE_IN_CHANNEL_SIGNAL
, 0, 0, &byte
, sizeof(byte
), NULL
, NULL
);
1071 sdla_cmd(dev
, SDLA_ADD_DLCI
, 0, 0, data
.dlci
, len
- sizeof(struct frad_conf
), NULL
, NULL
);
1072 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1073 if (flp
->dlci
[i
] > 0)
1074 sdla_cmd(dev
, SDLA_ACTIVATE_DLCI
, 0, 0, &flp
->dlci
[i
], 2*sizeof(flp
->dlci
[i
]), NULL
, NULL
);
1077 /* configure any specific DLCI settings */
1078 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1081 dlp
= flp
->master
[i
]->priv
;
1082 if (dlp
->configured
)
1083 sdla_cmd(dev
, SDLA_SET_DLCI_CONFIGURATION
, abs(flp
->dlci
[i
]), 0, &dlp
->config
, sizeof(struct dlci_conf
), NULL
, NULL
);
1086 netif_start_queue(dev
);
1093 static int sdla_config(struct net_device
*dev
, struct frad_conf
*conf
, int get
)
1095 struct frad_local
*flp
;
1096 struct conf_data data
;
1100 if (dev
->type
== 0xFFFF)
1107 if (netif_running(dev
))
1110 if(copy_from_user(&data
.config
, conf
, sizeof(struct frad_conf
)))
1113 if (data
.config
.station
& ~FRAD_STATION_NODE
)
1116 if (data
.config
.flags
& ~FRAD_VALID_FLAGS
)
1119 if ((data
.config
.kbaud
< 0) ||
1120 ((data
.config
.kbaud
> 128) && (flp
->type
!= SDLA_S508
)))
1123 if (data
.config
.clocking
& ~(FRAD_CLOCK_INT
| SDLA_S508_PORT_RS232
))
1126 if ((data
.config
.mtu
< 0) || (data
.config
.mtu
> SDLA_MAX_MTU
))
1129 if ((data
.config
.T391
< 5) || (data
.config
.T391
> 30))
1132 if ((data
.config
.T392
< 5) || (data
.config
.T392
> 30))
1135 if ((data
.config
.N391
< 1) || (data
.config
.N391
> 255))
1138 if ((data
.config
.N392
< 1) || (data
.config
.N392
> 10))
1141 if ((data
.config
.N393
< 1) || (data
.config
.N393
> 10))
1144 memcpy(&flp
->config
, &data
.config
, sizeof(struct frad_conf
));
1145 flp
->config
.flags
|= SDLA_DIRECT_RECV
;
1147 if (flp
->type
== SDLA_S508
)
1148 flp
->config
.flags
|= SDLA_TX70_RX30
;
1150 if (dev
->mtu
!= flp
->config
.mtu
)
1152 /* this is required to change the MTU */
1153 dev
->mtu
= flp
->config
.mtu
;
1154 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1156 flp
->master
[i
]->mtu
= flp
->config
.mtu
;
1159 flp
->config
.mtu
+= sizeof(struct frhdr
);
1161 /* off to the races! */
1162 if (!flp
->configured
)
1165 flp
->configured
= 1;
1169 /* no sense reading if the CPU isn't started */
1170 if (netif_running(dev
))
1172 size
= sizeof(data
);
1173 if (sdla_cmd(dev
, SDLA_READ_DLCI_CONFIGURATION
, 0, 0, NULL
, 0, &data
, &size
) != SDLA_RET_OK
)
1177 if (flp
->configured
)
1178 memcpy(&data
.config
, &flp
->config
, sizeof(struct frad_conf
));
1180 memset(&data
.config
, 0, sizeof(struct frad_conf
));
1182 memcpy(&flp
->config
, &data
.config
, sizeof(struct frad_conf
));
1183 data
.config
.flags
&= FRAD_VALID_FLAGS
;
1184 data
.config
.mtu
-= data
.config
.mtu
> sizeof(struct frhdr
) ? sizeof(struct frhdr
) : data
.config
.mtu
;
1185 return copy_to_user(conf
, &data
.config
, sizeof(struct frad_conf
))?-EFAULT
:0;
1191 static int sdla_xfer(struct net_device
*dev
, struct sdla_mem
*info
, int read
)
1193 struct sdla_mem mem
;
1196 if(copy_from_user(&mem
, info
, sizeof(mem
)))
1201 temp
= kmalloc(mem
.len
, GFP_KERNEL
);
1204 sdla_read(dev
, mem
.addr
, temp
, mem
.len
);
1205 if(copy_to_user(mem
.data
, temp
, mem
.len
))
1211 temp
= kmalloc(mem
.len
, GFP_KERNEL
);
1214 if(copy_from_user(temp
, mem
.data
, mem
.len
))
1216 sdla_write(dev
, mem
.addr
, temp
, mem
.len
);
1222 static int sdla_reconfig(struct net_device
*dev
)
1224 struct frad_local
*flp
;
1225 struct conf_data data
;
1231 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1233 data
.dlci
[len
++] = flp
->dlci
[i
];
1236 memcpy(&data
, &flp
->config
, sizeof(struct frad_conf
));
1237 len
+= sizeof(struct frad_conf
);
1239 sdla_cmd(dev
, SDLA_DISABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1240 sdla_cmd(dev
, SDLA_SET_DLCI_CONFIGURATION
, 0, 0, &data
, len
, NULL
, NULL
);
1241 sdla_cmd(dev
, SDLA_ENABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1246 static int sdla_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1248 struct frad_local
*flp
;
1255 if (!flp
->initialized
)
1262 return(sdla_config(dev
, (struct frad_conf
*)ifr
->ifr_data
, cmd
== FRAD_GET_CONF
));
1265 ifr
->ifr_flags
= flp
->type
;
1269 return(sdla_cpuspeed(dev
, ifr
));
1271 /* ==========================================================
1272 NOTE: This is rather a useless action right now, as the
1273 current driver does not support protocols other than
1274 FR. However, Sangoma has modules for a number of
1275 other protocols in the works.
1276 ============================================================*/
1278 if (flp
->configured
)
1281 switch (ifr
->ifr_flags
)
1284 dev
->type
= ifr
->ifr_flags
;
1287 return(-ENOPROTOOPT
);
1297 return(sdla_xfer(dev
, (struct sdla_mem
*)ifr
->ifr_data
, cmd
== SDLA_READMEM
));
1308 return(-EOPNOTSUPP
);
1313 int sdla_change_mtu(struct net_device
*dev
, int new_mtu
)
1315 struct frad_local
*flp
;
1319 if (netif_running(dev
))
1322 /* for now, you can't change the MTU! */
1323 return(-EOPNOTSUPP
);
1326 int sdla_set_config(struct net_device
*dev
, struct ifmap
*map
)
1328 struct frad_local
*flp
;
1334 if (flp
->initialized
)
1337 for(i
=0;i
< sizeof(valid_port
) / sizeof (int) ; i
++)
1338 if (valid_port
[i
] == map
->base_addr
)
1341 if (i
== sizeof(valid_port
) / sizeof(int))
1344 dev
->base_addr
= map
->base_addr
;
1345 request_region(dev
->base_addr
, SDLA_IO_EXTENTS
, dev
->name
);
1347 /* test for card types, S502A, S502E, S507, S508 */
1348 /* these tests shut down the card completely, so clear the state */
1349 flp
->type
= SDLA_UNKNOWN
;
1352 for(i
=1;i
<SDLA_IO_EXTENTS
;i
++)
1353 if (inb(dev
->base_addr
+ i
) != 0xFF)
1356 if (i
== SDLA_IO_EXTENTS
)
1358 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_Z80_CONTROL
);
1359 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x0F) == 0x08)
1361 outb(SDLA_S502E_INTACK
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1362 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x0F) == 0x0C)
1364 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1365 flp
->type
= SDLA_S502E
;
1370 if (flp
->type
== SDLA_UNKNOWN
)
1372 for(byte
=inb(dev
->base_addr
),i
=0;i
<SDLA_IO_EXTENTS
;i
++)
1373 if (inb(dev
->base_addr
+ i
) != byte
)
1376 if (i
== SDLA_IO_EXTENTS
)
1378 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1379 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x7E) == 0x30)
1381 outb(SDLA_S507_ENABLE
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1382 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x7E) == 0x32)
1384 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1385 flp
->type
= SDLA_S507
;
1391 if (flp
->type
== SDLA_UNKNOWN
)
1393 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1394 if ((inb(dev
->base_addr
+ SDLA_S508_STS
) & 0x3F) == 0x00)
1396 outb(SDLA_S508_INTEN
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1397 if ((inb(dev
->base_addr
+ SDLA_S508_STS
) & 0x3F) == 0x10)
1399 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1400 flp
->type
= SDLA_S508
;
1405 if (flp
->type
== SDLA_UNKNOWN
)
1407 outb(SDLA_S502A_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1408 if (inb(dev
->base_addr
+ SDLA_S502_STS
) == 0x40)
1410 outb(SDLA_S502A_START
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1411 if (inb(dev
->base_addr
+ SDLA_S502_STS
) == 0x40)
1413 outb(SDLA_S502A_INTEN
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1414 if (inb(dev
->base_addr
+ SDLA_S502_STS
) == 0x44)
1416 outb(SDLA_S502A_START
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1417 flp
->type
= SDLA_S502A
;
1423 if (flp
->type
== SDLA_UNKNOWN
)
1425 printk(KERN_NOTICE
"%s: Unknown card type\n", dev
->name
);
1429 switch(dev
->base_addr
)
1435 if ((flp
->type
!= SDLA_S508
) && (flp
->type
!= SDLA_S507
))
1442 if (flp
->type
!= SDLA_S502E
)
1451 if ((flp
->type
!= SDLA_S508
) && (flp
->type
!= SDLA_S507
))
1457 if (flp
->type
== SDLA_S502A
)
1464 dev
->irq
= map
->irq
;
1466 if (request_irq(dev
->irq
, &sdla_isr
, 0, dev
->name
, dev
))
1469 if (flp
->type
== SDLA_S507
)
1474 flp
->state
= SDLA_S507_IRQ3
;
1477 flp
->state
= SDLA_S507_IRQ4
;
1480 flp
->state
= SDLA_S507_IRQ5
;
1483 flp
->state
= SDLA_S507_IRQ7
;
1486 flp
->state
= SDLA_S507_IRQ10
;
1489 flp
->state
= SDLA_S507_IRQ11
;
1492 flp
->state
= SDLA_S507_IRQ12
;
1495 flp
->state
= SDLA_S507_IRQ15
;
1500 for(i
=0;i
< sizeof(valid_mem
) / sizeof (int) ; i
++)
1501 if (valid_mem
[i
] == map
->mem_start
)
1504 if (i
== sizeof(valid_mem
) / sizeof(int))
1507 * BUG BUG BUG: MUST RELEASE THE IRQ WE ALLOCATED IN
1513 if ((flp
->type
== SDLA_S502A
) && (((map
->mem_start
& 0xF000) >> 12) == 0x0E))
1516 if ((flp
->type
!= SDLA_S507
) && ((map
->mem_start
>> 16) == 0x0B))
1519 if ((flp
->type
== SDLA_S507
) && ((map
->mem_start
>> 16) == 0x0D))
1522 dev
->mem_start
= map
->mem_start
;
1523 dev
->mem_end
= dev
->mem_start
+ 0x2000;
1525 byte
= flp
->type
!= SDLA_S508
? SDLA_8K_WINDOW
: 0;
1526 byte
|= (map
->mem_start
& 0xF000) >> (12 + (flp
->type
== SDLA_S508
? 1 : 0));
1531 switch (map
->mem_start
>> 16)
1534 byte
|= SDLA_S502_SEG_A
;
1537 byte
|= SDLA_S502_SEG_C
;
1540 byte
|= SDLA_S502_SEG_D
;
1543 byte
|= SDLA_S502_SEG_E
;
1548 switch (map
->mem_start
>> 16)
1551 byte
|= SDLA_S507_SEG_A
;
1554 byte
|= SDLA_S507_SEG_B
;
1557 byte
|= SDLA_S507_SEG_C
;
1560 byte
|= SDLA_S507_SEG_E
;
1565 switch (map
->mem_start
>> 16)
1568 byte
|= SDLA_S508_SEG_A
;
1571 byte
|= SDLA_S508_SEG_C
;
1574 byte
|= SDLA_S508_SEG_D
;
1577 byte
|= SDLA_S508_SEG_E
;
1583 /* set the memory bits, and enable access */
1584 outb(byte
, dev
->base_addr
+ SDLA_REG_PC_WINDOW
);
1589 flp
->state
= SDLA_S502E_ENABLE
;
1592 flp
->state
|= SDLA_MEMEN
;
1595 flp
->state
= SDLA_MEMEN
;
1598 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1600 flp
->initialized
= 1;
1604 static struct net_device_stats
*sdla_stats(struct net_device
*dev
)
1606 struct frad_local
*flp
;
1609 return(&flp
->stats
);
1612 int __init
sdla_init(struct net_device
*dev
)
1614 struct frad_local
*flp
;
1616 /* allocate the private data structure */
1617 flp
= kmalloc(sizeof(struct frad_local
), GFP_KERNEL
);
1621 memset(flp
, 0, sizeof(struct frad_local
));
1625 dev
->open
= sdla_open
;
1626 dev
->stop
= sdla_close
;
1627 dev
->do_ioctl
= sdla_ioctl
;
1628 dev
->set_config
= sdla_set_config
;
1629 dev
->get_stats
= sdla_stats
;
1630 dev
->hard_start_xmit
= sdla_transmit
;
1631 dev
->change_mtu
= sdla_change_mtu
;
1634 dev
->hard_header_len
= 0;
1636 dev
->mtu
= SDLA_MAX_MTU
;
1638 dev_init_buffers(dev
);
1640 flp
->activate
= sdla_activate
;
1641 flp
->deactivate
= sdla_deactivate
;
1642 flp
->assoc
= sdla_assoc
;
1643 flp
->deassoc
= sdla_deassoc
;
1644 flp
->dlci_conf
= sdla_dlci_conf
;
1646 init_timer(&flp
->timer
);
1647 flp
->timer
.expires
= 1;
1648 flp
->timer
.data
= (unsigned long) dev
;
1649 flp
->timer
.function
= sdla_poll
;
1654 int __init
sdla_c_setup(void)
1656 printk("%s.\n", version
);
1657 register_frad(devname
);
1662 static struct net_device sdla0
= {"sdla0", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
, sdla_init
};
1664 int init_module(void)
1669 if ((result
= register_netdev(&sdla0
)) != 0)
1674 void cleanup_module(void)
1676 unregister_netdev(&sdla0
);
1680 free_irq(sdla0
.irq
, &sdla0
);