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 (slave
->start
&& (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 (slave
->start
&& (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
;
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
;
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
);
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
;
652 struct buf_entry
*pbuf
;
664 if (test_and_set_bit(0, (void*)&dev
->tbusy
) != 0)
665 printk(KERN_WARNING
"%s: transmitter access conflict.\n", dev
->name
);
669 * stupid GateD insists on setting up the multicast router thru us
670 * and we're ill equipped to handle a non Frame Relay packet at this
678 if (skb
->dev
->type
!= ARPHRD_DLCI
)
680 printk(KERN_WARNING
"%s: Non DLCI device, type %i, tried to send on FRAD module.\n", dev
->name
, skb
->dev
->type
);
686 printk(KERN_WARNING
"%s: unknown firmware type 0x%4.4X\n", dev
->name
, dev
->type
);
693 /* this is frame specific, but till there's a PPP module, it's the default */
698 ret
= sdla_cmd(dev
, SDLA_INFORMATION_WRITE
, *(short *)(skb
->dev
->dev_addr
), 0, skb
->data
, skb
->len
, NULL
, NULL
);
703 ret
= sdla_cmd(dev
, SDLA_INFORMATION_WRITE
, *(short *)(skb
->dev
->dev_addr
), 0, NULL
, skb
->len
, &addr
, &size
);
704 if (ret
== SDLA_RET_OK
)
708 SDLA_WINDOW(dev
, addr
);
709 pbuf
= (void *)(((int) dev
->mem_start
) + (addr
& SDLA_ADDR_MASK
));
711 sdla_write(dev
, pbuf
->buf_addr
, skb
->data
, skb
->len
);
713 SDLA_WINDOW(dev
, addr
);
715 restore_flags(flags
);
723 flp
->stats
.tx_packets
++;
727 case SDLA_RET_CIR_OVERFLOW
:
728 case SDLA_RET_BUF_OVERSIZE
:
729 case SDLA_RET_NO_BUFS
:
730 flp
->stats
.tx_dropped
++;
735 flp
->stats
.tx_errors
++;
745 static void sdla_receive(struct net_device
*dev
)
747 struct net_device
*master
;
748 struct frad_local
*flp
;
749 struct dlci_local
*dlp
;
752 struct sdla_cmd
*cmd
;
753 struct buf_info
*pbufi
;
754 struct buf_entry
*pbuf
;
757 int i
, received
, success
, addr
, buf_base
, buf_top
;
758 short dlci
, len
, len2
, split
;
762 received
= addr
= buf_top
= buf_base
= 0;
777 cmd
= (void *) (dev
->mem_start
+ (SDLA_502_RCV_BUF
& SDLA_ADDR_MASK
));
778 SDLA_WINDOW(dev
, SDLA_502_RCV_BUF
);
779 success
= cmd
->opp_flag
;
788 pbufi
= (void *) (dev
->mem_start
+ (SDLA_508_RXBUF_INFO
& SDLA_ADDR_MASK
));
789 SDLA_WINDOW(dev
, SDLA_508_RXBUF_INFO
);
790 pbuf
= (void *) (dev
->mem_start
+ ((pbufi
->rse_base
+ flp
->buffer
* sizeof(struct buf_entry
)) & SDLA_ADDR_MASK
));
791 success
= pbuf
->opp_flag
;
795 buf_top
= pbufi
->buf_top
;
796 buf_base
= pbufi
->buf_base
;
799 addr
= pbuf
->buf_addr
;
803 /* common code, find the DLCI and get the SKB */
806 for (i
=0;i
<CONFIG_DLCI_MAX
;i
++)
807 if (flp
->dlci
[i
] == dlci
)
810 if (i
== CONFIG_DLCI_MAX
)
812 printk(KERN_NOTICE
"%s: Received packet from invalid DLCI %i, ignoring.", dev
->name
, dlci
);
813 flp
->stats
.rx_errors
++;
820 master
= flp
->master
[i
];
821 skb
= dev_alloc_skb(len
+ sizeof(struct frhdr
));
824 printk(KERN_NOTICE
"%s: Memory squeeze, dropping packet.\n", dev
->name
);
825 flp
->stats
.rx_dropped
++;
829 skb_reserve(skb
, sizeof(struct frhdr
));
832 /* pick up the data */
838 sdla_read(dev
, SDLA_502_RCV_BUF
+ SDLA_502_DATA_OFS
, skb_put(skb
,len
), len
);
840 SDLA_WINDOW(dev
, SDLA_502_RCV_BUF
);
847 /* is this buffer split off the end of the internal ring buffer */
848 split
= addr
+ len
> buf_top
+ 1 ? len
- (buf_top
- addr
+ 1) : 0;
851 sdla_read(dev
, addr
, skb_put(skb
, len2
), len2
);
853 sdla_read(dev
, buf_base
, skb_put(skb
, split
), split
);
856 /* increment the buffer we're looking at */
857 SDLA_WINDOW(dev
, SDLA_508_RXBUF_INFO
);
858 flp
->buffer
= (flp
->buffer
+ 1) % pbufi
->rse_num
;
865 flp
->stats
.rx_packets
++;
867 (*dlp
->receive
)(skb
, master
);
870 restore_flags(flags
);
873 static void sdla_isr(int irq
, void *dev_id
, struct pt_regs
* regs
)
875 struct net_device
*dev
;
876 struct frad_local
*flp
;
883 printk(KERN_WARNING
"sdla_isr(): irq %d for unknown device.\n", irq
);
889 if (!flp
->initialized
)
891 printk(KERN_WARNING
"%s: irq %d for uninitialized device.\n", dev
->name
, irq
);
896 byte
= sdla_byte(dev
, flp
->type
== SDLA_S508
? SDLA_508_IRQ_INTERFACE
: SDLA_502_IRQ_INTERFACE
);
903 /* the command will get an error return, which is processed above */
904 case SDLA_INTR_MODEM
:
905 case SDLA_INTR_STATUS
:
906 sdla_cmd(dev
, SDLA_READ_DLC_STATUS
, 0, 0, NULL
, 0, NULL
, NULL
);
910 case SDLA_INTR_COMPLETE
:
911 case SDLA_INTR_TIMER
:
912 printk(KERN_WARNING
"%s: invalid irq flag 0x%02X.\n", dev
->name
, byte
);
916 /* the S502E requires a manual acknowledgement of the interrupt */
917 if (flp
->type
== SDLA_S502E
)
919 flp
->state
&= ~SDLA_S502E_INTACK
;
920 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
921 flp
->state
|= SDLA_S502E_INTACK
;
922 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
925 /* this clears the byte, informing the Z80 we're done */
927 sdla_write(dev
, flp
->type
== SDLA_S508
? SDLA_508_IRQ_INTERFACE
: SDLA_502_IRQ_INTERFACE
, &byte
, sizeof(byte
));
931 static void sdla_poll(unsigned long device
)
933 struct net_device
*dev
;
934 struct frad_local
*flp
;
936 dev
= (struct net_device
*) device
;
939 if (sdla_byte(dev
, SDLA_502_RCV_BUF
))
942 flp
->timer
.expires
= 1;
943 add_timer(&flp
->timer
);
946 static int sdla_close(struct net_device
*dev
)
948 struct frad_local
*flp
;
949 struct intr_info intr
;
951 short dlcis
[CONFIG_DLCI_MAX
];
956 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
958 dlcis
[len
++] = abs(flp
->dlci
[i
]);
961 if (flp
->config
.station
== FRAD_STATION_NODE
)
963 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
964 if (flp
->dlci
[i
] > 0)
965 sdla_cmd(dev
, SDLA_DEACTIVATE_DLCI
, 0, 0, dlcis
, len
, NULL
, NULL
);
966 sdla_cmd(dev
, SDLA_DELETE_DLCI
, 0, 0, &flp
->dlci
[i
], sizeof(flp
->dlci
[i
]), NULL
, NULL
);
969 memset(&intr
, 0, sizeof(intr
));
970 /* let's start up the reception */
974 del_timer(&flp
->timer
);
978 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(char) + sizeof(short), NULL
, NULL
);
979 flp
->state
&= ~SDLA_S502E_INTACK
;
980 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
987 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(struct intr_info
), NULL
, NULL
);
988 flp
->state
&= ~SDLA_S508_INTEN
;
989 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
993 sdla_cmd(dev
, SDLA_DISABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1004 struct frad_conf config
;
1005 short dlci
[CONFIG_DLCI_MAX
];
1008 static int sdla_open(struct net_device
*dev
)
1010 struct frad_local
*flp
;
1011 struct dlci_local
*dlp
;
1012 struct conf_data data
;
1013 struct intr_info intr
;
1019 if (!flp
->initialized
)
1022 if (!flp
->configured
)
1025 /* time to send in the configuration */
1027 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1029 data
.dlci
[len
++] = abs(flp
->dlci
[i
]);
1032 memcpy(&data
.config
, &flp
->config
, sizeof(struct frad_conf
));
1033 len
+= sizeof(struct frad_conf
);
1035 sdla_cmd(dev
, SDLA_DISABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1036 sdla_cmd(dev
, SDLA_SET_DLCI_CONFIGURATION
, 0, 0, &data
, len
, NULL
, NULL
);
1038 if (flp
->type
== SDLA_S508
)
1041 sdla_cmd(dev
, SDLA_ENABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1043 /* let's start up the reception */
1044 memset(&intr
, 0, sizeof(intr
));
1048 flp
->timer
.expires
= 1;
1049 add_timer(&flp
->timer
);
1053 flp
->state
|= SDLA_S502E_ENABLE
;
1054 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1055 flp
->state
|= SDLA_S502E_INTACK
;
1056 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1058 sdla_write(dev
, SDLA_502_IRQ_INTERFACE
, &byte
, sizeof(byte
));
1059 intr
.flags
= SDLA_INTR_RX
| SDLA_INTR_STATUS
| SDLA_INTR_MODEM
;
1060 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(char) + sizeof(short), NULL
, NULL
);
1067 flp
->state
|= SDLA_S508_INTEN
;
1068 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1070 sdla_write(dev
, SDLA_508_IRQ_INTERFACE
, &byte
, sizeof(byte
));
1071 intr
.flags
= SDLA_INTR_RX
| SDLA_INTR_STATUS
| SDLA_INTR_MODEM
;
1072 intr
.irq
= dev
->irq
;
1073 sdla_cmd(dev
, SDLA_SET_IRQ_TRIGGER
, 0, 0, &intr
, sizeof(struct intr_info
), NULL
, NULL
);
1077 if (flp
->config
.station
== FRAD_STATION_CPE
)
1079 byte
= SDLA_ICS_STATUS_ENQ
;
1080 sdla_cmd(dev
, SDLA_ISSUE_IN_CHANNEL_SIGNAL
, 0, 0, &byte
, sizeof(byte
), NULL
, NULL
);
1084 sdla_cmd(dev
, SDLA_ADD_DLCI
, 0, 0, data
.dlci
, len
- sizeof(struct frad_conf
), NULL
, NULL
);
1085 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1086 if (flp
->dlci
[i
] > 0)
1087 sdla_cmd(dev
, SDLA_ACTIVATE_DLCI
, 0, 0, &flp
->dlci
[i
], 2*sizeof(flp
->dlci
[i
]), NULL
, NULL
);
1090 /* configure any specific DLCI settings */
1091 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1094 dlp
= flp
->master
[i
]->priv
;
1095 if (dlp
->configured
)
1096 sdla_cmd(dev
, SDLA_SET_DLCI_CONFIGURATION
, abs(flp
->dlci
[i
]), 0, &dlp
->config
, sizeof(struct dlci_conf
), NULL
, NULL
);
1108 static int sdla_config(struct net_device
*dev
, struct frad_conf
*conf
, int get
)
1110 struct frad_local
*flp
;
1111 struct conf_data data
;
1115 if (dev
->type
== 0xFFFF)
1125 if(copy_from_user(&data
.config
, conf
, sizeof(struct frad_conf
)))
1128 if (data
.config
.station
& ~FRAD_STATION_NODE
)
1131 if (data
.config
.flags
& ~FRAD_VALID_FLAGS
)
1134 if ((data
.config
.kbaud
< 0) ||
1135 ((data
.config
.kbaud
> 128) && (flp
->type
!= SDLA_S508
)))
1138 if (data
.config
.clocking
& ~(FRAD_CLOCK_INT
| SDLA_S508_PORT_RS232
))
1141 if ((data
.config
.mtu
< 0) || (data
.config
.mtu
> SDLA_MAX_MTU
))
1144 if ((data
.config
.T391
< 5) || (data
.config
.T391
> 30))
1147 if ((data
.config
.T392
< 5) || (data
.config
.T392
> 30))
1150 if ((data
.config
.N391
< 1) || (data
.config
.N391
> 255))
1153 if ((data
.config
.N392
< 1) || (data
.config
.N392
> 10))
1156 if ((data
.config
.N393
< 1) || (data
.config
.N393
> 10))
1159 memcpy(&flp
->config
, &data
.config
, sizeof(struct frad_conf
));
1160 flp
->config
.flags
|= SDLA_DIRECT_RECV
;
1162 if (flp
->type
== SDLA_S508
)
1163 flp
->config
.flags
|= SDLA_TX70_RX30
;
1165 if (dev
->mtu
!= flp
->config
.mtu
)
1167 /* this is required to change the MTU */
1168 dev
->mtu
= flp
->config
.mtu
;
1169 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1171 flp
->master
[i
]->mtu
= flp
->config
.mtu
;
1174 flp
->config
.mtu
+= sizeof(struct frhdr
);
1176 /* off to the races! */
1177 if (!flp
->configured
)
1180 flp
->configured
= 1;
1184 /* no sense reading if the CPU isn't started */
1187 size
= sizeof(data
);
1188 if (sdla_cmd(dev
, SDLA_READ_DLCI_CONFIGURATION
, 0, 0, NULL
, 0, &data
, &size
) != SDLA_RET_OK
)
1192 if (flp
->configured
)
1193 memcpy(&data
.config
, &flp
->config
, sizeof(struct frad_conf
));
1195 memset(&data
.config
, 0, sizeof(struct frad_conf
));
1197 memcpy(&flp
->config
, &data
.config
, sizeof(struct frad_conf
));
1198 data
.config
.flags
&= FRAD_VALID_FLAGS
;
1199 data
.config
.mtu
-= data
.config
.mtu
> sizeof(struct frhdr
) ? sizeof(struct frhdr
) : data
.config
.mtu
;
1200 return copy_to_user(conf
, &data
.config
, sizeof(struct frad_conf
))?-EFAULT
:0;
1206 static int sdla_xfer(struct net_device
*dev
, struct sdla_mem
*info
, int read
)
1208 struct sdla_mem mem
;
1211 if(copy_from_user(&mem
, info
, sizeof(mem
)))
1216 temp
= kmalloc(mem
.len
, GFP_KERNEL
);
1219 sdla_read(dev
, mem
.addr
, temp
, mem
.len
);
1220 if(copy_to_user(mem
.data
, temp
, mem
.len
))
1226 temp
= kmalloc(mem
.len
, GFP_KERNEL
);
1229 if(copy_from_user(temp
, mem
.data
, mem
.len
))
1231 sdla_write(dev
, mem
.addr
, temp
, mem
.len
);
1237 static int sdla_reconfig(struct net_device
*dev
)
1239 struct frad_local
*flp
;
1240 struct conf_data data
;
1246 for(i
=0;i
<CONFIG_DLCI_MAX
;i
++)
1248 data
.dlci
[len
++] = flp
->dlci
[i
];
1251 memcpy(&data
, &flp
->config
, sizeof(struct frad_conf
));
1252 len
+= sizeof(struct frad_conf
);
1254 sdla_cmd(dev
, SDLA_DISABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1255 sdla_cmd(dev
, SDLA_SET_DLCI_CONFIGURATION
, 0, 0, &data
, len
, NULL
, NULL
);
1256 sdla_cmd(dev
, SDLA_ENABLE_COMMUNICATIONS
, 0, 0, NULL
, 0, NULL
, NULL
);
1261 static int sdla_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1263 struct frad_local
*flp
;
1270 if (!flp
->initialized
)
1277 return(sdla_config(dev
, (struct frad_conf
*)ifr
->ifr_data
, cmd
== FRAD_GET_CONF
));
1280 ifr
->ifr_flags
= flp
->type
;
1284 return(sdla_cpuspeed(dev
, ifr
));
1286 /* ==========================================================
1287 NOTE: This is rather a useless action right now, as the
1288 current driver does not support protocols other than
1289 FR. However, Sangoma has modules for a number of
1290 other protocols in the works.
1291 ============================================================*/
1293 if (flp
->configured
)
1296 switch (ifr
->ifr_flags
)
1299 dev
->type
= ifr
->ifr_flags
;
1302 return(-ENOPROTOOPT
);
1312 return(sdla_xfer(dev
, (struct sdla_mem
*)ifr
->ifr_data
, cmd
== SDLA_READMEM
));
1323 return(-EOPNOTSUPP
);
1328 int sdla_change_mtu(struct net_device
*dev
, int new_mtu
)
1330 struct frad_local
*flp
;
1337 /* for now, you can't change the MTU! */
1338 return(-EOPNOTSUPP
);
1341 int sdla_set_config(struct net_device
*dev
, struct ifmap
*map
)
1343 struct frad_local
*flp
;
1349 if (flp
->initialized
)
1352 for(i
=0;i
< sizeof(valid_port
) / sizeof (int) ; i
++)
1353 if (valid_port
[i
] == map
->base_addr
)
1356 if (i
== sizeof(valid_port
) / sizeof(int))
1359 dev
->base_addr
= map
->base_addr
;
1360 request_region(dev
->base_addr
, SDLA_IO_EXTENTS
, dev
->name
);
1362 /* test for card types, S502A, S502E, S507, S508 */
1363 /* these tests shut down the card completely, so clear the state */
1364 flp
->type
= SDLA_UNKNOWN
;
1367 for(i
=1;i
<SDLA_IO_EXTENTS
;i
++)
1368 if (inb(dev
->base_addr
+ i
) != 0xFF)
1371 if (i
== SDLA_IO_EXTENTS
)
1373 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_Z80_CONTROL
);
1374 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x0F) == 0x08)
1376 outb(SDLA_S502E_INTACK
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1377 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x0F) == 0x0C)
1379 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1380 flp
->type
= SDLA_S502E
;
1385 if (flp
->type
== SDLA_UNKNOWN
)
1387 for(byte
=inb(dev
->base_addr
),i
=0;i
<SDLA_IO_EXTENTS
;i
++)
1388 if (inb(dev
->base_addr
+ i
) != byte
)
1391 if (i
== SDLA_IO_EXTENTS
)
1393 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1394 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x7E) == 0x30)
1396 outb(SDLA_S507_ENABLE
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1397 if ((inb(dev
->base_addr
+ SDLA_S502_STS
) & 0x7E) == 0x32)
1399 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1400 flp
->type
= SDLA_S507
;
1406 if (flp
->type
== SDLA_UNKNOWN
)
1408 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1409 if ((inb(dev
->base_addr
+ SDLA_S508_STS
) & 0x3F) == 0x00)
1411 outb(SDLA_S508_INTEN
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1412 if ((inb(dev
->base_addr
+ SDLA_S508_STS
) & 0x3F) == 0x10)
1414 outb(SDLA_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1415 flp
->type
= SDLA_S508
;
1420 if (flp
->type
== SDLA_UNKNOWN
)
1422 outb(SDLA_S502A_HALT
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1423 if (inb(dev
->base_addr
+ SDLA_S502_STS
) == 0x40)
1425 outb(SDLA_S502A_START
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1426 if (inb(dev
->base_addr
+ SDLA_S502_STS
) == 0x40)
1428 outb(SDLA_S502A_INTEN
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1429 if (inb(dev
->base_addr
+ SDLA_S502_STS
) == 0x44)
1431 outb(SDLA_S502A_START
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1432 flp
->type
= SDLA_S502A
;
1438 if (flp
->type
== SDLA_UNKNOWN
)
1440 printk(KERN_NOTICE
"%s: Unknown card type\n", dev
->name
);
1444 switch(dev
->base_addr
)
1450 if ((flp
->type
!= SDLA_S508
) && (flp
->type
!= SDLA_S507
))
1457 if (flp
->type
!= SDLA_S502E
)
1466 if ((flp
->type
!= SDLA_S508
) && (flp
->type
!= SDLA_S507
))
1472 if (flp
->type
== SDLA_S502A
)
1479 dev
->irq
= map
->irq
;
1481 if (request_irq(dev
->irq
, &sdla_isr
, 0, dev
->name
, dev
))
1484 if (flp
->type
== SDLA_S507
)
1489 flp
->state
= SDLA_S507_IRQ3
;
1492 flp
->state
= SDLA_S507_IRQ4
;
1495 flp
->state
= SDLA_S507_IRQ5
;
1498 flp
->state
= SDLA_S507_IRQ7
;
1501 flp
->state
= SDLA_S507_IRQ10
;
1504 flp
->state
= SDLA_S507_IRQ11
;
1507 flp
->state
= SDLA_S507_IRQ12
;
1510 flp
->state
= SDLA_S507_IRQ15
;
1515 for(i
=0;i
< sizeof(valid_mem
) / sizeof (int) ; i
++)
1516 if (valid_mem
[i
] == map
->mem_start
)
1519 if (i
== sizeof(valid_mem
) / sizeof(int))
1522 * BUG BUG BUG: MUST RELEASE THE IRQ WE ALLOCATED IN
1528 if ((flp
->type
== SDLA_S502A
) && (((map
->mem_start
& 0xF000) >> 12) == 0x0E))
1531 if ((flp
->type
!= SDLA_S507
) && ((map
->mem_start
>> 16) == 0x0B))
1534 if ((flp
->type
== SDLA_S507
) && ((map
->mem_start
>> 16) == 0x0D))
1537 dev
->mem_start
= map
->mem_start
;
1538 dev
->mem_end
= dev
->mem_start
+ 0x2000;
1540 byte
= flp
->type
!= SDLA_S508
? SDLA_8K_WINDOW
: 0;
1541 byte
|= (map
->mem_start
& 0xF000) >> (12 + (flp
->type
== SDLA_S508
? 1 : 0));
1546 switch (map
->mem_start
>> 16)
1549 byte
|= SDLA_S502_SEG_A
;
1552 byte
|= SDLA_S502_SEG_C
;
1555 byte
|= SDLA_S502_SEG_D
;
1558 byte
|= SDLA_S502_SEG_E
;
1563 switch (map
->mem_start
>> 16)
1566 byte
|= SDLA_S507_SEG_A
;
1569 byte
|= SDLA_S507_SEG_B
;
1572 byte
|= SDLA_S507_SEG_C
;
1575 byte
|= SDLA_S507_SEG_E
;
1580 switch (map
->mem_start
>> 16)
1583 byte
|= SDLA_S508_SEG_A
;
1586 byte
|= SDLA_S508_SEG_C
;
1589 byte
|= SDLA_S508_SEG_D
;
1592 byte
|= SDLA_S508_SEG_E
;
1598 /* set the memory bits, and enable access */
1599 outb(byte
, dev
->base_addr
+ SDLA_REG_PC_WINDOW
);
1604 flp
->state
= SDLA_S502E_ENABLE
;
1607 flp
->state
|= SDLA_MEMEN
;
1610 flp
->state
= SDLA_MEMEN
;
1613 outb(flp
->state
, dev
->base_addr
+ SDLA_REG_CONTROL
);
1615 flp
->initialized
= 1;
1619 static struct net_device_stats
*sdla_stats(struct net_device
*dev
)
1621 struct frad_local
*flp
;
1624 return(&flp
->stats
);
1627 int __init
sdla_init(struct net_device
*dev
)
1629 struct frad_local
*flp
;
1631 /* allocate the private data structure */
1632 flp
= kmalloc(sizeof(struct frad_local
), GFP_KERNEL
);
1636 memset(flp
, 0, sizeof(struct frad_local
));
1640 dev
->open
= sdla_open
;
1641 dev
->stop
= sdla_close
;
1642 dev
->do_ioctl
= sdla_ioctl
;
1643 dev
->set_config
= sdla_set_config
;
1644 dev
->get_stats
= sdla_stats
;
1645 dev
->hard_start_xmit
= sdla_transmit
;
1646 dev
->change_mtu
= sdla_change_mtu
;
1649 dev
->hard_header_len
= 0;
1651 dev
->mtu
= SDLA_MAX_MTU
;
1653 dev_init_buffers(dev
);
1655 flp
->activate
= sdla_activate
;
1656 flp
->deactivate
= sdla_deactivate
;
1657 flp
->assoc
= sdla_assoc
;
1658 flp
->deassoc
= sdla_deassoc
;
1659 flp
->dlci_conf
= sdla_dlci_conf
;
1661 init_timer(&flp
->timer
);
1662 flp
->timer
.expires
= 1;
1663 flp
->timer
.data
= (unsigned long) dev
;
1664 flp
->timer
.function
= sdla_poll
;
1669 int __init
sdla_c_setup(void)
1671 printk("%s.\n", version
);
1672 register_frad(devname
);
1677 static struct net_device sdla0
= {"sdla0", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
, sdla_init
};
1679 int init_module(void)
1684 if ((result
= register_netdev(&sdla0
)) != 0)
1689 void cleanup_module(void)
1691 unregister_netdev(&sdla0
);
1695 free_irq(sdla0
.irq
, &sdla0
);