#define RCS_ID "$Id: scc.c,v 1.75 1998/11/04 15:15:01 jreuter Exp jreuter $" #define VERSION "3.0" /* * Please use z8530drv - utils - 3 . 0 with this version . * - - - - - - - - - - - - - - - - - - * * You can find a subset of the documentation in * Documentation / networking / device_drivers / hamradio / z8530drv . rst . /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * SCC . C - Linux driver for Z8530 based HDLC cards for AX . 25 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Copyright ( c ) 1993 , 2000 Joerg Reuter DL1BKE portions ( c ) 1993 Guido ten Dolle PE1NNZ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * The driver and the programs in the archive are UNDER CONSTRUCTION . The code is likely to fail , and so your kernel could - - - even a whole network . This driver is intended for Amateur Radio use . If you are running it for commercial purposes , please drop me a note . I am nosy . . . . . . BUT : ! You m u s t recognize the appropriate legislations of your country ! ! before you connect a radio to the SCC board and start to transmit or ! ! receive . The GPL allows you to use the d r i v e r , NOT the RADIO ! ! For non - Amateur - Radio use please note that you might need a special allowance / licence from the designer of the SCC Board and / or the MODEM . This program is free software ; you can redistribute it and / or modify it under the terms of the ( modified ) GNU General Public License delivered with the Linux kernel source . This program is distributed in the hope that it will be useful , but WITHOUT ANY WARRANTY ; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU General Public License for more details . You should find a copy of the GNU General Public License in / usr / src / linux / COPYING ; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Incomplete history of z8530drv : - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1994 - 09 - 13 started to write the driver , rescued most of my own code ( and Hans Alblas ' memory buffer pool concept ) from an earlier project " sccdrv " which was initiated by Guido ten Dolle . Not much of the old driver survived , though . The first version I put my hands on was sccdrv1 . 3 from August 1993 . The memory buffer pool concept appeared in an unauthorized sccdrv version ( 1 . 5 ) from August 1994 . 1995 - 01 - 31 changed copyright notice to GPL without limitations . . . < SNIP > . 1996 - 10 - 05 New semester , new driver . . . * KISS TNC emulator removed ( TTY driver ) * Source moved to drivers / net / * Includes Z8530 defines from drivers / net / z8530 . h * Uses sk_buffer memory management * Reduced overhead of / proc / net / z8530drv output * Streamlined quite a lot things * Invents brand new bugs . . . ; - ) The move to version number 3 . 0 reflects theses changes . You can use ' kissbridge ' if you need a KISS TNC emulator . 1996 - 12 - 13 Fixed for Linux networking changes . ( G4KLX ) 1997 - 01 - 08 Fixed the remaining problems . 1997 - 04 - 02 Hopefully fixed the problems with the new * _ timer ( ) routines , added calibration code . 1997 - 10 - 12 Made SCC_DELAY a CONFIG option , added CONFIG_SCC_TRXECHO 1998 - 01 - 29 Small fix to avoid lock - up on initialization 1998 - 09 - 29 Fixed the " grouping " bugs , tx_inhibit works again , using dev - > tx_queue_len now instead of MAXQUEUE now . 1998 - 10 - 21 Postponed the spinlock changes , would need a lot of testing I currently don ' t have the time to . Softdcd doesn ' t work . 1998 - 11 - 04 Softdcd does not work correctly in DPLL mode , in fact it never did . The DPLL locks on noise , the SYNC unit sees flags that aren ' t . . . Restarting the DPLL does not help either , it resynchronizes too slow and the first received frame gets lost . 2000 - 02 - 13 Fixed for new network driver interface changes , still does TX timeouts itself since it uses its own queue scheme . Thanks to all who contributed to this driver with ideas and bug reports ! NB - - if you find errors , change something , please let me know first before you distribute it . . . And please don ' t touch the version number . Just replace my callsign in " v3 . 0 . dl1bke " with your own . Just to avoid confusion . . . If you want to add your modification to the linux distribution please ( ! ) contact me first . New versions of the driver will be announced on the linux - hams mailing list on vger . kernel . org . To subscribe send an e - mail to majordomo @ vger . kernel . org with the following line in the body of the mail : subscribe linux - hams The content of the " Subject " field will be ignored . vy 73 , Joerg Reuter ampr - net : dl1bke @ db0pra . ampr . org AX - 25 : DL1BKE @ DB0ABH . # BAY . DEU . EU Internet : jreuter @ yaina . de www : http : //yaina.de/jreuter /* ----------------------------------------------------------------------- */ #undef SCC_LDELAY /* slow it even a bit more down */ #undef SCC_DONT_CHECK /* don't look if the SCCs you specified are available */ #define SCC_MAXCHIPS 4 /* number of max. supported chips */ #define SCC_BUFSIZE 384 /* must not exceed 4096 */ #undef SCC_DEBUG#define SCC_DEFAULT_CLOCK 4915200 /* default pclock if nothing is specified */ /* ----------------------------------------------------------------------- */ #include <linux/compat.h>#include <linux/module.h>#include <linux/errno.h>#include <linux/signal.h>#include <linux/timer.h>#include <linux/interrupt.h>#include <linux/ioport.h>#include <linux/string.h>#include <linux/in.h>#include <linux/fcntl.h>#include <linux/ptrace.h>#include <linux/delay.h>#include <linux/skbuff.h>#include <linux/netdevice.h>#include <linux/rtnetlink.h>#include <linux/if_ether.h>#include <linux/if_arp.h>#include <linux/socket.h>#include <linux/init.h>#include <linux/scc.h>#include <linux/ctype.h>#include <linux/kernel.h>#include <linux/proc_fs.h>#include <linux/seq_file.h>#include <linux/bitops.h>#include <net/net_namespace.h>#include <net/ax25.h>#include <asm /irq.h>#include <asm /io.h>#include <linux/uaccess.h>#include "z8530.h" static const char banner[] __initconst = KERN_INFO \"AX.25: Z8530 SCC driver version " VERSION".dl1bke\n" ;static void t_dwait(struct timer_list *t);static void t_txdelay(struct timer_list *t);static void t_tail(struct timer_list *t);static void t_busy(struct timer_list *);static void t_maxkeyup(struct timer_list *);static void t_idle(struct timer_list *t);static void scc_tx_done(struct scc_channel *);static void scc_start_tx_timer(struct scc_channel *,void (*)(struct timer_list *), unsigned long );static void scc_start_maxkeyup(struct scc_channel *);static void scc_start_defer(struct scc_channel *);static void z8530_init(void );static void init_channel(struct scc_channel *scc);static void scc_key_trx (struct scc_channel *scc, char tx);static void scc_init_timer(struct scc_channel *scc);static int scc_net_alloc(const char *name, struct scc_channel *scc);static void scc_net_setup(struct net_device *dev);static int scc_net_open(struct net_device *dev);static int scc_net_close(struct net_device *dev);static void scc_net_rx(struct scc_channel *scc, struct sk_buff *skb);static netdev_tx_t scc_net_tx(struct sk_buff *skb,struct net_device *dev);static int scc_net_siocdevprivate(struct net_device *dev, struct ifreq *ifr,void __user *data, int cmd);static int scc_net_set_mac_address(struct net_device *dev, void *addr);static struct net_device_stats * scc_net_get_stats(struct net_device *dev);static unsigned char SCC_DriverName[] = "scc" ;static struct irqflags { unsigned char used : 1 ; } Ivec[NR_IRQS];static struct scc_channel SCC_Info[2 * SCC_MAXCHIPS]; /* information per channel */ static struct scc_ctrl {int irq;1 ];static unsigned char Driver_Initialized;static int Nchips;static io_port Vector_Latch;/* ******************************************************************** */ /* * Port Access Functions * */ /* ******************************************************************** */ /* These provide interrupt save 2-step access to the Z8530 registers */ static DEFINE_SPINLOCK(iolock); /* Guards paired accesses */ static inline unsigned char InReg(io_port port, unsigned char reg)unsigned long flags;unsigned char r;#ifdef SCC_LDELAY#else #endif return r;static inline void OutReg(io_port port, unsigned char reg, unsigned char val)unsigned long flags;#ifdef SCC_LDELAY#else #endif static inline void wr(struct scc_channel *scc, unsigned char reg,unsigned char val)static inline void or (struct scc_channel *scc, unsigned char reg, unsigned char val)static inline void cl(struct scc_channel *scc, unsigned char reg, unsigned char val)/* ******************************************************************** */ /* * Some useful macros * */ /* ******************************************************************** */ static inline void scc_discard_buffers(struct scc_channel *scc)unsigned long flags;if (scc->tx_buff != NULL)while (!skb_queue_empty(&scc->tx_queue))/* ******************************************************************** */ /* * Interrupt Service Routines * */ /* ******************************************************************** */ /* ----> subroutines for the interrupt handlers <---- */ static inline void scc_notify(struct scc_channel *scc, int event)struct sk_buff *skb;char *bp;if (scc->kiss.fulldup != KISS_DUPLEX_OPTIMA)return ;2 );if (skb != NULL)2 );else static inline void flush_rx_FIFO(struct scc_channel *scc)int k;for (k=0 ; k<3 ; k++)if (scc->rx_buff != NULL) /* did we receive something? */ /* then count it as an error */ static void start_hunt(struct scc_channel *scc)if ((scc->modem.clocksrc != CLK_EXTERNAL))/* DPLL: enter search mode */ or (scc,R3,ENT_HM|RxENABLE); /* enable the receiver, hunt mode */ /* ----> four different interrupt handlers for Tx, Rx, changing of */ /* DCD/CTS and Rx/Tx errors */ /* Transmitter interrupt handler */ static inline void scc_txint(struct scc_channel *scc)struct sk_buff *skb;/* send first octet */ if (skb == NULL)if (skb == NULL)return ;if (skb->len == 0 ) /* Paranoia... */ return ;/* reset CRC generator */ or (scc,R10,ABUNDER); /* re-install underrun protection */ /* send byte */ 1 );if (!scc->enhanced) /* reset EOM latch */ return ;/* End Of Frame... */ if (skb->len == 0 )/* reset pending int */ /* send CRC */ /* next frame... */ return ;/* send octet */ 1 );/* External/Status interrupt handler */ static inline void scc_exint(struct scc_channel *scc)unsigned char status,changes,chg_and_stat;/* ABORT: generated whenever DCD drops while receiving */ if (chg_and_stat & BRK_ABRT) /* Received an ABORT */ /* HUNT: software DCD; on = waiting for SYNC, off = receiving frame */ if ((changes & SYNC_HUNT) && scc->kiss.softdcd)if (status & SYNC_HUNT)0 ;if ((scc->modem.clocksrc != CLK_EXTERNAL))/* DPLL: enter search mode */ else {1 ;/* DCD: on = start to receive packet, off = ABORT condition */ /* (a successfully received packet generates a special condition int) */ if ((changes & DCD) && !scc->kiss.softdcd) /* DCD input changed state */ if (status & DCD) /* DCD is now ON */ 1 ;else { /* DCD is now OFF */ /* disable the receiver */ 0 ;#ifdef notdef/* CTS: use external TxDelay (what's that good for?!) * Anyway : If we _ could_ use it ( BayCom USCC uses CTS for * own purposes ) we _ should_ use the " autoenable " feature * of the Z8530 and not this interrupt . . . if (chg_and_stat & CTS) /* CTS is now ON */ if (scc->kiss.txdelay == 0 ) /* zero TXDELAY = wait for CTS */ 0 );#endif if (scc->stat.tx_state == TXS_ACTIVE && (status & TxEOM))/* oops, an underrun! count 'em */ /* reset ext/status interrupts */ if (scc->tx_buff != NULL)or (scc,R10,ABUNDER);0 ); /* restart transmission */ /* Receiver interrupt handler */ static inline void scc_rxint(struct scc_channel *scc)struct sk_buff *skb;if ((scc->wreg[5 ] & RTS) && scc->kiss.fulldup == KISS_DUPLEX_HALF)/* discard char */ or (scc,R3,ENT_HM); /* enter hunt mode for next flag */ return ;if (skb == NULL)if (skb == NULL)or (scc, R3, ENT_HM);return ;0 ); /* KISS data */ if (skb->len >= scc->stat.bufsize)#ifdef notdef"z8530drv: oops, scc_rxint() received huge frame...\n" );#endif or (scc, R3, ENT_HM);return ;/* Receive Special Condition interrupt handler */ static inline void scc_spint(struct scc_channel *scc)unsigned char status;struct sk_buff *skb;/* read receiver status */ /* throw away Rx byte */ if (status & Rx_OVR) /* receiver overrun */ /* count them */ or (scc,R3,ENT_HM); /* enter hunt mode for next flag */ if (skb != NULL) if (status & END_FR && skb != NULL) /* end of frame */ /* CRC okay, frame ends on 8 bit boundary and received something ? */ if (!(status & CRC_ERR) && (status & 0 xe) == RES8 && skb->len > 0 )/* ignore last received byte (first of the CRC bytes) */ 1 );else { /* a bad frame */ /* ----> interrupt service routine for the Z8530 <---- */ static void scc_isr_dispatch(struct scc_channel *scc, int vector)switch (vector & VECTOR_MASK)case TXINT: scc_txint(scc); break ;case EXINT: scc_exint(scc); break ;case RXINT: scc_rxint(scc); break ;case SPINT: scc_spint(scc); break ;/* If the card has a latch for the interrupt vector (like the PA0HZP card) use it to get the number of the chip that generated the int . If not : poll all defined chips . #define SCC_IRQTIMEOUT 30000 static irqreturn_t scc_isr(int irq, void *dev_id)int chip_irq = (long ) dev_id;unsigned char vector; struct scc_channel *scc;struct scc_ctrl *ctrl;int k;if (Vector_Latch)for (k=0 ; k < SCC_IRQTIMEOUT; k++)0 ); /* Generate INTACK */ /* Read the vector */ if ((vector=Inb(Vector_Latch)) >= 16 * Nchips) break ; if (vector & 0 x01) break ;3 ^ 0 x01];if (!scc->dev) break ;/* Reset Highest IUS */ if (k == SCC_IRQTIMEOUT)"z8530drv: endless loop in scc_isr()?\n" );return IRQ_HANDLED;/* Find the SCC generating the interrupt by polling all attached SCCs * reading RR3A ( the interrupt pending register ) while (ctrl->chan_A)if (ctrl->irq != chip_irq)continue ;for (k = 0 ; InReg(ctrl->chan_A,R3) && k < SCC_IRQTIMEOUT; k++)/* Read the vector */ if (vector & 0 x01) break ; 3 ^ 0 x01];if (!scc->dev) break ;if (k == SCC_IRQTIMEOUT)"z8530drv: endless loop in scc_isr()?!\n" );break ;/* This looks weird and it is. At least the BayCom USCC doesn't * use the Interrupt Daisy Chain , thus we ' ll have to start * all over again to be sure not to miss an interrupt from * ( any of ) the other chip ( s ) . . . * Honestly , the situation * is * braindamaged . . . if (scc != NULL)else return IRQ_HANDLED;/* ******************************************************************** */ /* * Init Channel */ /* ******************************************************************** */ /* ----> set SCC channel speed <---- */ static inline void set_brg(struct scc_channel *scc, unsigned int tc)/* disable baudrate generator */ 255 ); /* brg rate LOW */ 8 ); /* brg rate HIGH */ or (scc,R14,BRENABL); /* enable baudrate generator */ static inline void set_speed(struct scc_channel *scc)unsigned long flags;if (scc->modem.speed > 0 ) /* paranoia... */ unsigned ) (scc->clock / (scc->modem.speed * 64 )) - 2 );/* ----> initialize a SCC channel <---- */ static inline void init_brg(struct scc_channel *scc)/* BRG source = PCLK */ /* DPLL source = BRG */ /* DPLL NRZI mode */ /* * Initialization according to the Z8530 manual ( SGS - Thomson ' s version ) : * * 1 . Modes and constants * * WR9 11000000 chip reset * WR4 XXXXXXXX Tx / Rx control , async or sync mode * WR1 0 XX00X00 select W / REQ ( optional ) * WR2 XXXXXXXX program interrupt vector * WR3 XXXXXXX0 select Rx control * WR5 XXXX0XXX select Tx control * WR6 XXXXXXXX sync character * WR7 XXXXXXXX sync character * WR9 000 X0XXX select interrupt control * WR10 XXXXXXXX miscellaneous control ( optional ) * WR11 XXXXXXXX clock control * WR12 XXXXXXXX time constant lower byte ( optional ) * WR13 XXXXXXXX time constant upper byte ( optional ) * WR14 XXXXXXX0 miscellaneous control * WR14 XXXSSSSS commands ( optional ) * * 2 . Enables * * WR14 000 SSSS1 baud rate enable * WR3 SSSSSSS1 Rx enable * WR5 SSSS1SSS Tx enable * WR0 10000000 reset Tx CRG ( optional ) * WR1 XSS00S00 DMA enable ( optional ) * * 3 . Interrupt status * * WR15 XXXXXXXX enable external / status * WR0 00010000 reset external status * WR0 00010000 reset external status twice * WR1 SSSXXSXX enable Rx , Tx and Ext / status * WR9 000 SXSSS enable master interrupt enable * * 1 = set to one , 0 = reset to zero * X = user defined , S = same as previous init * * * Note that the implementation differs in some points from above scheme . * static void init_channel(struct scc_channel *scc)/* *1 clock, SDLC mode */ 0 ); /* no W/REQ operation */ /* RX 8 bits/char, CRC, disabled */ /* TX 8 bits/char, disabled, DTR */ 0 ); /* SDLC address zero (not used) */ /* SDLC flag value */ /* vector includes status */ /* abort on underrun, preset CRC generator, NRZ(I) */ 0 );/* set clock sources: CLK_DPLL : normal halfduplex operation RxClk : use DPLL TxClk : use DPLL TRxC mode DPLL output CLK_EXTERNAL : external clocking ( G3RUH or DF9IC modem ) BayCom : others : TxClk = pin RTxC TxClk = pin TRxC RxClk = pin TRxC RxClk = pin RTxC CLK_DIVIDER : RxClk = use DPLL TxClk = pin RTxC BayCom : others : pin TRxC = DPLL pin TRxC = BRG ( RxClk * 1 ) ( RxClk * 32 ) switch (scc->modem.clocksrc)case CLK_DPLL:break ;case CLK_DIVIDER:break ;case CLK_EXTERNAL:break ;/* set baudrate */ if (scc->enhanced)or (scc,R15,SHDLCE|FIFOE); /* enable FIFO, SDLC/HDLC Enhancements (From now R7 is R7') */ if (scc->kiss.softdcd || (InReg(scc->ctrl,R0) & DCD))/* DCD is now ON */ /* enable ABORT, DCD & SYNC/HUNT interrupts */ /* reset ext/status interrupts */ /* must be done twice */ or (scc,R1,INT_ALL_Rx|TxINT_ENAB|EXT_INT_ENAB); /* enable interrupts */ /* read initial status */ or (scc,R9,MIE); /* master interrupt enable */ /* ******************************************************************** */ /* * SCC timer functions * */ /* ******************************************************************** */ /* ----> scc_key_trx sets the time constant for the baudrate static void scc_key_trx(struct scc_channel *scc, char tx)unsigned int time_const;if (scc->brand & PRIMUS)4 , scc->option | (tx? 0 x80 : 0 ));if (scc->modem.speed < 300 ) 1200 ;unsigned ) (scc->clock / (scc->modem.speed * (tx? 2 :64 ))) - 2 ;if (tx)or (scc, R1, TxINT_ENAB); /* t_maxkeyup may have reset these */ or (scc, R15, TxUIE);if (scc->modem.clocksrc == CLK_DPLL)/* force simplex operation */ if (tx)#ifdef CONFIG_SCC_TRXECHO/* switch off receiver */ /* No DCD changes, please */ #endif /* reprogram baudrate generator */ /* DPLL -> Rx clk, BRG -> Tx CLK, TRxC mode output, TRxC = BRG */ /* By popular demand: tx_inhibit */ if (scc->kiss.tx_inhibit)or (scc,R5, TxENAB);else {or (scc,R5,RTS|TxENAB); /* set the RTS line and enable TX */ else {/* reprogram baudrate generator */ /* DPLL -> Rx clk, DPLL -> Tx CLK, TRxC mode output, TRxC = DPLL */ #ifndef CONFIG_SCC_TRXECHOif (scc->kiss.softdcd)#endif or (scc,R15, scc->kiss.softdcd? SYNCIE:DCDIE);else {if (tx)#ifdef CONFIG_SCC_TRXECHOif (scc->kiss.fulldup == KISS_DUPLEX_HALF)#endif if (scc->kiss.tx_inhibit)or (scc,R5, TxENAB);else { or (scc,R5,RTS|TxENAB); /* enable tx */ else {/* disable tx */ if ((scc->kiss.fulldup == KISS_DUPLEX_HALF) &&#ifndef CONFIG_SCC_TRXECHO#else 1 )#endif or (scc, R15, scc->kiss.softdcd? SYNCIE:DCDIE);/* ----> SCC timer interrupt handler and friends. <---- */ static void __scc_start_tx_timer(struct scc_channel *scc,void (*handler)(struct timer_list *t),unsigned long when)if (when == 0 )else if (when != TIMER_OFF)100 ;static void scc_start_tx_timer(struct scc_channel *scc,void (*handler)(struct timer_list *t),unsigned long when)unsigned long flags;static void scc_start_defer(struct scc_channel *scc)unsigned long flags;if (scc->kiss.maxdefer != 0 && scc->kiss.maxdefer != TIMER_OFF)static void scc_start_maxkeyup(struct scc_channel *scc)unsigned long flags;if (scc->kiss.maxkeyup != 0 && scc->kiss.maxkeyup != TIMER_OFF)/* * This is called from scc_txint ( ) when there are no more frames to send . * Not exactly a timer function , but it is a close friend of the family . . . static void scc_tx_done(struct scc_channel *scc)/* * trx remains keyed in fulldup mode 2 until t_idle expires . switch (scc->kiss.fulldup)case KISS_DUPLEX_LINK:if (scc->kiss.idletime != TIMER_OFF)100 );break ;case KISS_DUPLEX_OPTIMA:break ;default :static unsigned char Rand = 17 ;static inline int is_grouped(struct scc_channel *scc)int k;struct scc_channel *scc2;unsigned char grp1, grp2;for (k = 0 ; k < (Nchips * 2 ); k++)if (scc2 == scc || !(scc2->dev && grp2))continue ;if ((grp1 & 0 x3f) == (grp2 & 0 x3f))if ( (grp1 & TXGROUP) && (scc2->wreg[R5] & RTS) )return 1 ;if ( (grp1 & RXGROUP) && scc2->dcd )return 1 ;return 0 ;/* DWAIT and SLOTTIME expired * * fulldup = = 0 : DCD is active or Rand > P - persistence : start t_busy timer * else key trx and start txdelay * fulldup = = 1 : key trx and start txdelay * fulldup = = 2 : mintime expired , reset status or key trx and start txdelay static void t_dwait(struct timer_list *t)struct scc_channel *scc = timer_container_of(scc, t, tx_t);if (scc->stat.tx_state == TXS_WAIT) /* maxkeyup or idle timeout */ if (skb_queue_empty(&scc->tx_queue)) { /* nothing to send */ /* t_maxkeyup locked it. */ return ;if (scc->kiss.fulldup == KISS_DUPLEX_HALF)17 + 31 ;if (scc->dcd || (scc->kiss.persist) < Rand || (scc->kiss.group && is_grouped(scc)) )return ;if ( !(scc->wreg[R5] & RTS) )else {0 );/* TXDELAY expired * * kick transmission by a fake scc_txint ( scc ) , start ' maxkeyup ' watchdog . static void t_txdelay(struct timer_list *t)struct scc_channel *scc = timer_container_of(scc, t, tx_t);if (scc->tx_buff == NULL)/* TAILTIME expired * * switch off transmitter . If we were stopped by Maxkeyup restart * transmission after ' mintime ' seconds static void t_tail(struct timer_list *t)struct scc_channel *scc = timer_container_of(scc, t, tx_t);unsigned long flags;if (scc->stat.tx_state == TXS_TIMEOUT) /* we had a timeout? */ 100 );return ;/* BUSY timeout * * throw away send buffers if DCD remains active too long . static void t_busy(struct timer_list *t)struct scc_channel *scc = timer_container_of(scc, t, tx_wdog);/* don't pile on the wabbit! */ /* MAXKEYUP timeout * * this is our watchdog . static void t_maxkeyup(struct timer_list *t)struct scc_channel *scc = timer_container_of(scc, t, tx_wdog);unsigned long flags;/* * let things settle down before we start to * accept new data . /* force an ABORT, but don't */ /* count it. */ /* IDLE timeout * * in fulldup mode 2 it keys down the transmitter after ' idle ' seconds * of inactivity . We will not restart transmission before ' mintime ' * expires . static void t_idle(struct timer_list *t)struct scc_channel *scc = timer_container_of(scc, t, tx_t);if (scc->kiss.mintime)100 );static void scc_init_timer(struct scc_channel *scc)unsigned long flags;/* ******************************************************************** */ /* * Set/get L1 parameters * */ /* ******************************************************************** */ /* * this will set the " hardware " parameters through KISS commands or ioctl ( ) #define CAST(x) (unsigned long )(x)static unsigned int scc_set_param(struct scc_channel *scc, unsigned int cmd, unsigned int arg)switch (cmd)case PARAM_TXDELAY: scc->kiss.txdelay=arg; break ;case PARAM_PERSIST: scc->kiss.persist=arg; break ;case PARAM_SLOTTIME: scc->kiss.slottime=arg; break ;case PARAM_TXTAIL: scc->kiss.tailtime=arg; break ;case PARAM_FULLDUP: scc->kiss.fulldup=arg; break ;case PARAM_DTR: break ; /* does someone need this? */ case PARAM_GROUP: scc->kiss.group=arg; break ;case PARAM_IDLE: scc->kiss.idletime=arg; break ;case PARAM_MIN: scc->kiss.mintime=arg; break ;case PARAM_MAXKEY: scc->kiss.maxkeyup=arg; break ;case PARAM_WAIT: scc->kiss.waittime=arg; break ;case PARAM_MAXDEFER: scc->kiss.maxdefer=arg; break ;case PARAM_TX: scc->kiss.tx_inhibit=arg; break ;case PARAM_SOFTDCD: if (arg)or (scc, R15, SYNCIE);else {or (scc, R15, DCDIE);break ;case PARAM_SPEED:if (arg < 256 )100 ;else if (scc->stat.tx_state == 0 ) /* only switch baudrate on rx... ;-) */ break ;case PARAM_RTS: if ( !(scc->wreg[R5] & RTS) )if (arg != TX_OFF) {else {if (arg == TX_OFF)break ;case PARAM_HWEVENT:break ;default : return -EINVAL;return 0 ;static unsigned long scc_get_param(struct scc_channel *scc, unsigned int cmd)switch (cmd)case PARAM_TXDELAY: return CAST(scc->kiss.txdelay);case PARAM_PERSIST: return CAST(scc->kiss.persist);case PARAM_SLOTTIME: return CAST(scc->kiss.slottime);case PARAM_TXTAIL: return CAST(scc->kiss.tailtime);case PARAM_FULLDUP: return CAST(scc->kiss.fulldup);case PARAM_SOFTDCD: return CAST(scc->kiss.softdcd);case PARAM_DTR: return CAST((scc->wreg[R5] & DTR)? 1 :0 );case PARAM_RTS: return CAST((scc->wreg[R5] & RTS)? 1 :0 );case PARAM_SPEED: return CAST(scc->modem.speed);case PARAM_GROUP: return CAST(scc->kiss.group);case PARAM_IDLE: return CAST(scc->kiss.idletime);case PARAM_MIN: return CAST(scc->kiss.mintime);case PARAM_MAXKEY: return CAST(scc->kiss.maxkeyup);case PARAM_WAIT: return CAST(scc->kiss.waittime);case PARAM_MAXDEFER: return CAST(scc->kiss.maxdefer);case PARAM_TX: return CAST(scc->kiss.tx_inhibit);default : return NO_SUCH_PARAM;#undef CAST/* ******************************************************************* */ /* * Send calibration pattern * */ /* ******************************************************************* */ static void scc_stop_calibrate(struct timer_list *t)struct scc_channel *scc = timer_container_of(scc, t, tx_wdog);unsigned long flags;0 );/* reset ext/status interrupts */ static void struct scc_channel *scc, int duration, unsigned char pattern)unsigned long flags;/* This doesn't seem to work. Why not? */ 0 );/* * Don ' t know if this works . * Damn , where is my Z8530 programming manual . . . ? /* reset ext/status interrupts */ /* ******************************************************************* */ /* * Init channel structures, special HW, etc... * */ /* ******************************************************************* */ /* * Reset the Z8530s and setup special hardware static void z8530_init(void )const unsigned int nr_irqs = irq_get_nr_irqs();struct scc_channel *scc;int chip, k;unsigned long flags;char *flag;"Init Z8530 driver: %u channels, IRQ" , Nchips*2 );" " ;for (k = 0 ; k < nr_irqs; k++)if (Ivec[k].used) "%s%d" , flag, k);"," ;"\n" );/* reset and pre-init all chips in the system */ for (chip = 0 ; chip < Nchips; chip++)2 *chip];if (!scc->ctrl) continue ;/* Special SCC cards */ if (scc->brand & EAGLE) /* this is an EAGLE card */ 0 x08); /* enable interrupt on the board */ if (scc->brand & (PC100 | PRIMUS)) /* this is a PC100/PRIMUS card */ /* set the MODEM mode (0x22) */ /* Reset and pre-init Z8530 */ 0 );/* force hardware reset */ 100 ); /* give it 'a bit' more time than required */ 16 ); /* interrupt vector */ /* vector includes status */ 1 ;/* * Allocate device structure , err , instance , and register driver static int scc_net_alloc(const char *name, struct scc_channel *scc)int err;struct net_device *dev;0 , name, NET_NAME_UNKNOWN, scc_net_setup);if (!dev) return -ENOMEM;0 );0 );if (err) {"%s: can't register network device (%d)\n" , return err;return 0 ;/* ******************************************************************** */ /* * Network driver methods * */ /* ******************************************************************** */ static const struct net_device_ops scc_netdev_ops = {/* ----> Initialize device <----- */ static void scc_net_setup(struct net_device *dev)16 ; /* should be enough... */ 0 ;/* ----> open network device <---- */ static int scc_net_open(struct net_device *dev)struct scc_channel *scc = (struct scc_channel *) dev->ml_priv;if (!scc->init)return -EINVAL;return 0 ;/* ----> close network device <---- */ static int scc_net_close(struct net_device *dev)struct scc_channel *scc = (struct scc_channel *) dev->ml_priv;unsigned long flags;0 ); /* Make sure pointer is written */ 0 ); /* disable interrupts */ 0 );return 0 ;/* ----> receive frame, called from scc_rxint() <---- */ static void scc_net_rx(struct scc_channel *scc, struct sk_buff *skb)if (skb->len == 0 ) {return ;/* ----> transmit frame <---- */ static netdev_tx_t scc_net_tx(struct sk_buff *skb, struct net_device *dev)struct scc_channel *scc = (struct scc_channel *) dev->ml_priv;unsigned long flags;char kisscmd;if (skb->protocol == htons(ETH_P_IP))return ax25_ip_xmit(skb);if (skb->len > scc->stat.bufsize || skb->len < 2 ) {/* bogus frame */ return NETDEV_TX_OK;0 x1f;1 );if (kisscmd) {return NETDEV_TX_OK;if (skb_queue_len(&scc->tx_queue) > scc->dev->tx_queue_len) {struct sk_buff *skb_del;/* * Start transmission if the trx state is idle or * t_idle hasn ' t expired yet . Use dwait / persistence / slottime * algorithm for normal halfduplex operation . if (scc->stat.tx_state == TXS_IDLE || scc->stat.tx_state == TXS_IDLE2) {if (scc->kiss.fulldup == KISS_DUPLEX_HALF)else 0 );return NETDEV_TX_OK;/* ----> ioctl functions <---- */ /* * SIOCSCCCFG - configure driver arg : ( struct scc_hw_config * ) arg * SIOCSCCINI - initialize driver arg : - - - * SIOCSCCCHANINI - initialize channel arg : ( struct scc_modem * ) arg * SIOCSCCSMEM - set memory arg : ( struct scc_mem_config * ) arg * SIOCSCCGKISS - get level 1 parameter arg : ( struct scc_kiss_cmd * ) arg * SIOCSCCSKISS - set level 1 parameter arg : ( struct scc_kiss_cmd * ) arg * SIOCSCCGSTAT - get driver status arg : ( struct scc_stat * ) arg * SIOCSCCCAL - send calib . pattern arg : ( struct scc_calibrate * ) arg static int scc_net_siocdevprivate(struct net_device *dev,struct ifreq *ifr, void __user *arg, int cmd)struct scc_kiss_cmd kiss_cmd;struct scc_mem_config memcfg;struct scc_hw_config hwcfg;struct scc_calibrate cal;struct scc_channel *scc = (struct scc_channel *) dev->ml_priv;int chan;unsigned char device_name[IFNAMSIZ];if (!Driver_Initialized)if (cmd == SIOCSCCCFG)int found = 1 ;if (!capable(CAP_SYS_RAWIO)) return -EPERM;if (in_compat_syscall())return -EOPNOTSUPP;if (!arg) return -EFAULT;if (Nchips >= SCC_MAXCHIPS) return -EINVAL;if (copy_from_user(&hwcfg, arg, sizeof (hwcfg)))return -EFAULT;if (hwcfg.irq == 2 ) hwcfg.irq = 9 ;if (hwcfg.irq < 0 || hwcfg.irq >= irq_get_nr_irqs())return -EINVAL;if (!Ivec[hwcfg.irq].used && hwcfg.irq)if (request_irq(hwcfg.irq, scc_isr,0 , "AX.25 SCC" ,void *)(long ) hwcfg.irq))"z8530drv: warning, cannot get IRQ %d\n" , hwcfg.irq);else 1 ;if (hwcfg.vector_latch && !Vector_Latch) {if (!request_region(hwcfg.vector_latch, 1 , "scc vector latch" ))"z8530drv: warning, cannot reserve vector latch port 0x%lx\n, disabled." , hwcfg.vector_latch);else if (hwcfg.clock == 0 )#ifndef SCC_DONT_CHECKif (request_region(hwcfg.ctrl_a, 1 , "scc-probe" ))0 );100 );0 x55); /* is this chip really there? */ 5 );if (InReg(hwcfg.ctrl_a,R13) != 0 x55)0 ;1 );else 0 ;#endif if (found)2 *Nchips ].ctrl = hwcfg.ctrl_a;2 *Nchips ].data = hwcfg.data_a;2 *Nchips ].irq = hwcfg.irq;2 *Nchips+1 ].ctrl = hwcfg.ctrl_b;2 *Nchips+1 ].data = hwcfg.data_b;2 *Nchips+1 ].irq = hwcfg.irq;for (chan = 0 ; chan < 2 ; chan++)"%s%i" , SCC_DriverName, 2 *Nchips+chan);2 *Nchips+chan].special = hwcfg.special;2 *Nchips+chan].clock = hwcfg.clock;2 *Nchips+chan].brand = hwcfg.brand;2 *Nchips+chan].option = hwcfg.option;2 *Nchips+chan].enhanced = hwcfg.escc;#ifdef SCC_DONT_CHECK"%s: data port = 0x%3.3x control port = 0x%3.3x\n" ,2 *Nchips+chan].data, 2 *Nchips+chan].ctrl);#else "%s: data port = 0x%3.3lx control port = 0x%3.3lx -- %s\n" ,"found" : "missing" );#endif if (found)2 *Nchips+chan].ctrl, 1 , "scc ctrl" );2 *Nchips+chan].data, 1 , "scc data" );if (Nchips+chan != 0 &&2 *Nchips+chan]))return -EINVAL;if (found) Nchips++;return 0 ;if (cmd == SIOCSCCINI)if (!capable(CAP_SYS_RAWIO))return -EPERM;if (Nchips == 0 )return -EINVAL;return 0 ;return -EINVAL; /* confuse the user */ if (!scc->init)if (cmd == SIOCSCCCHANINI)if (!capable(CAP_NET_ADMIN)) return -EPERM;if (!arg) return -EINVAL;if (copy_from_user(&scc->modem, arg, sizeof (struct scc_modem)))return -EINVAL;/* default KISS Params */ if (scc->modem.speed < 4800 )36 ; /* 360 ms */ 42 ; /* 25% persistence */ /* was 25 */ 16 ; /* 160 ms */ 4 ; /* minimal reasonable value */ 0 ; /* CSMA */ 50 ; /* 500 ms */ 10 ; /* 10 s */ 3 ; /* 3 s */ 30 ; /* 30 s */ 120 ; /* 2 min */ 0 ; /* hardware dcd */ else {10 ; /* 100 ms */ 64 ; /* 25% persistence */ /* was 25 */ 8 ; /* 160 ms */ 1 ; /* minimal reasonable value */ 0 ; /* CSMA */ 50 ; /* 500 ms */ 7 ; /* 7 s */ 3 ; /* 3 s */ 30 ; /* 30 s */ 120 ; /* 2 min */ 0 ; /* hardware dcd */ 1 ;return 0 ;return -EINVAL;switch (cmd)case SIOCSCCRESERVED:return -ENOIOCTLCMD;case SIOCSCCSMEM:if (!capable(CAP_SYS_RAWIO)) return -EPERM;if (!arg || copy_from_user(&memcfg, arg, sizeof (memcfg)))return -EINVAL;return 0 ;case SIOCSCCGSTAT:if (!arg || copy_to_user(arg, &scc->stat, sizeof (scc->stat)))return -EINVAL;return 0 ;case SIOCSCCGKISS:if (!arg || copy_from_user(&kiss_cmd, arg, sizeof (kiss_cmd)))return -EINVAL;if (copy_to_user(arg, &kiss_cmd, sizeof (kiss_cmd)))return -EINVAL;return 0 ;case SIOCSCCSKISS:if (!capable(CAP_NET_ADMIN)) return -EPERM;if (!arg || copy_from_user(&kiss_cmd, arg, sizeof (kiss_cmd)))return -EINVAL;return scc_set_param(scc, kiss_cmd.command, kiss_cmd.param);case SIOCSCCCAL:if (!capable(CAP_SYS_RAWIO)) return -EPERM;if (!arg || copy_from_user(&cal, arg, sizeof (cal)) || cal.time == 0 )return -EINVAL;return 0 ;default :return -ENOIOCTLCMD;return -EINVAL;/* ----> set interface callsign <---- */ static int scc_net_set_mac_address(struct net_device *dev, void *addr)struct sockaddr *sa = (struct sockaddr *) addr;return 0 ;/* ----> get statistics <---- */ static struct net_device_stats *scc_net_get_stats(struct net_device *dev)struct scc_channel *scc = (struct scc_channel *) dev->ml_priv;return &scc->dev_stat;/* ******************************************************************** */ /* * dump statistics to /proc/net/z8530drv * */ /* ******************************************************************** */ #ifdef CONFIG_PROC_FSstatic inline struct scc_channel *scc_net_seq_idx(loff_t pos)int k;for (k = 0 ; k < Nchips*2 ; ++k) {if (!SCC_Info[k].init) continue ;if (pos-- == 0 )return &SCC_Info[k];return NULL;static void *scc_net_seq_start(struct seq_file *seq, loff_t *pos)return *pos ? scc_net_seq_idx(*pos - 1 ) : SEQ_START_TOKEN;static void *scc_net_seq_next(struct seq_file *seq, void *v, loff_t *pos)unsigned k;struct scc_channel *scc = v;for (k = (v == SEQ_START_TOKEN) ? 0 : (scc - SCC_Info)+1 ;2 ; ++k) {if (SCC_Info[k].init) return &SCC_Info[k];return NULL;static void scc_net_seq_stop(struct seq_file *seq, void *v)static int scc_net_seq_show(struct seq_file *seq, void *v)if (v == SEQ_START_TOKEN) {"z8530drv-" VERSION"\n" );else if (!Driver_Initialized) {"not initialized\n" );else if (!Nchips) {"chips missing\n" );else {const struct scc_channel *scc = v;const struct scc_stat *stat = &scc->stat;const struct scc_kiss *kiss = &scc->kiss;/* dev data ctrl irq clock brand enh vector special option * baud nrz clocksrc softdcd bufsize * rxints txints exints spints * rcvd rxerrs over / xmit txerrs under / nospace bufsize * txd pers slot tail ful wait min maxk idl defr txof grp * W # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # * R # # # # XX # # # # # # # # # # XX # # # # # # # # # # # # # # "%s\t%3.3lx %3.3lx %d %lu %2.2x %d %3.3lx %3.3lx %d\n" ,"\t%lu %d %d %d %d\n" ,"\t%lu %lu %lu %lu\n" ,"\t%lu %lu %d / %lu %lu %d / %d %d\n" ,#define K(x) kiss->x"\t%d %d %d %d %d %d %d %d %d %d %d %d\n" ,#undef K#ifdef SCC_DEBUGint reg;"\tW " );for (reg = 0 ; reg < 16 ; reg++)"%2.2x " , scc->wreg[reg]);"\n" );"\tR %2.2x %2.2x XX " , InReg(scc->ctrl,R0), InReg(scc->ctrl,R1));for (reg = 3 ; reg < 8 ; reg++)"%2.2x " , InReg(scc->ctrl, reg));"XX " );for (reg = 9 ; reg < 16 ; reg++)"%2.2x " , InReg(scc->ctrl, reg));"\n" );#endif '\n' );return 0 ;static const struct seq_operations scc_net_seq_ops = {#endif /* CONFIG_PROC_FS */ /* ******************************************************************** */ /* * Init SCC driver * */ /* ******************************************************************** */ static int __init scc_init_driver (void )char devname[IFNAMSIZ];"%s0" , SCC_DriverName);if (scc_net_alloc(devname, SCC_Info)) {"z8530drv: cannot initialize module\n" );return -EIO;"z8530drv" , 0 , init_net.proc_net, &scc_net_seq_ops);return 0 ;static void __exit scc_cleanup_driver(void )const unsigned int nr_irqs = irq_get_nr_irqs();int k;struct scc_channel *scc;struct net_device *dev;if (Nchips == 0 && (dev = SCC_Info[0 ].dev)) /* Guard against chip prattle */ for (k = 0 ; k < Nchips; k++)if ( (ctrl = SCC_ctrl[k].chan_A) )0 );/* force hardware reset */ 50 );/* To unload the port must be closed so no real IRQ pending */ for (k = 0 ; k < nr_irqs ; k++)if (Ivec[k].used) free_irq(k, NULL);/* Now clean up */ for (k = 0 ; k < Nchips*2 ; k++)if (scc->ctrl)1 );1 );if (scc->dev)if (Vector_Latch)1 );"z8530drv" , init_net.proc_net);"Joerg Reuter <jreuter@yaina.de>" );"AX.25 Device Driver for Z8530 based HDLC cards" );"GPL" );
Messung V0.5 in Prozent C=90 H=96 G=93
¤ Dauer der Verarbeitung: 0.77 Sekunden
(vorverarbeitet am 2026-09-29)
¤ *© Formatika GbR, Deutschland
