#define RCS_ID "$Id: scc.c,v 1.75 1998/11/04 15:15:01 jreuter Exp jreuter $" #define VERSION "4.0" #define BANNER "Z8530 SCC driver version "VERSION".dl1bke by DL1BKE\n" /* * Please use z8530drv-utils-4.0 with this version. * ------------------ * * You can find a subset of the documentation in * linux/Documentation/networking/z8530drv.txt. */ /* ******************************************************************** * 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. . . . 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. 1999-02-21 Started to implement the new AX.25 device interface 2000-07-18 Ported to 2.4.x 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 "v4.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_DONT_CHECK /* don't look if the SCCs you specified are available */ #define SCC_BUFSIZE 384 /* must not exceed 4096 */ #undef SCC_DEBUG #define SCC_DEFAULT_CLOCK 4915200 /* default pclock if nothing is specified */ #define SCC_SIMPLE_MAC /* no rts/cts control by DDI layer */ #define SCC_WATCHDOG_TIMEOUT 10 /* ten seconds */ /* ----------------------------------------------------------------------- */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "z8530.h" int scc_init(void); static void scc_tx_done(struct scc_channel *); static void scc_kick_tx(struct scc_channel *); static void scc_start_tx_timer(struct scc_channel *, void (*)(struct scc_channel *), unsigned long); static void scc_tail(struct scc_channel *scc); #ifndef SCC_SIMPLE_MAC static void scc_tx_forced(struct scc_channel *scc); static void scc_set_rts(struct scc_channel *scc); #endif static void init_channel(struct scc_channel *scc); static void scc_key_trx (struct scc_channel *scc, char tx); static void scc_isr(int irq, void *dev_id, struct pt_regs *regs); static void scc_init_timer(struct scc_channel *scc); static unsigned int scc_ddi_report_dcd(struct net_device *); static unsigned int scc_ddi_report_ptt(struct net_device *); #ifndef SCC_SIMPLE_MAC static unsigned int scc_ddi_report_cts(struct net_device *); static void scc_ddi_set_rts(struct net_device *); #endif static void scc_ddi_set_bitrate(struct net_device *, unsigned int); static void scc_ddi_param_update(struct net_device *); static void scc_ddi_param_notify(struct net_device *, int, int, int); static int scc_net_setup(struct scc_channel *scc); static int scc_net_init(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 int scc_net_tx(struct sk_buff *skb, struct net_device *dev); static void scc_net_timeout(struct net_device *dev); static int scc_net_ioctl(struct net_device *dev, struct ifreq *ifr, 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 int scc_proc_intvec_nchips(ctl_table *, int *, int, void *, size_t *, void *, size_t, void **); static int scc_proc_intvec_modem(ctl_table *, int *, int, void *, size_t *, void *, size_t, void **); static int scc_proc_intvec_port(ctl_table *, int *, int, void *, size_t *, void *, size_t, void **); static int scc_proc_intvec_chip(ctl_table *, int *, int, void *, size_t *, void *, size_t, void **); struct scc_ctrl_proc_tables { ctl_table parent[2]; /* /proc/sys/net/dev/ */ ctl_table dir[2]; /* /.../dev/z8530drv/ */ ctl_table chip[10]; /* /.../dev/z8530drv/chip */ }; static int scc_irq_used[16]; static struct scc_ctrl { struct scc_channel channel_a; struct scc_channel channel_b; struct scc_ctrl_proc_tables proc_tables; struct ctl_table_header * proc_table_head; } **scc_ctrl; static struct ctl_table_header *scc_proc_table_header; static int maxchips = 4; static int Nchips = 0; static long IO_Delay = 0; static spinlock_t IO_Spinlock = SPIN_LOCK_UNLOCKED; static ctl_table scc_proc_parent_table[]; static ctl_table scc_proc_nchips_table[]; /* ******************************************************************** */ /* * Port Access Functions * */ /* ******************************************************************** */ static inline unsigned char Inb(io_port port) { int r; r = inb(port); if (IO_Delay) udelay(IO_Delay); return r; } static inline void Outb(io_port port, unsigned char val) { outb(val, port); if (IO_Delay) udelay(IO_Delay); } /* These provide interrupt save 2-step access to the Z8530 registers */ static unsigned char InReg(io_port port, unsigned char reg) { unsigned long flags; unsigned char r; spin_lock_irqsave(&IO_Spinlock, flags); if (IO_Delay) { outb(reg, port); udelay(IO_Delay); r=inb(port); udelay(IO_Delay); } else { outb(reg, port); r=inb(port); } spin_unlock_irqrestore(&IO_Spinlock, flags); return r; } static void OutReg(io_port port, unsigned char reg, unsigned char val) { unsigned long flags; spin_lock_irqsave(&IO_Spinlock, flags); if (IO_Delay) { outb(reg, port); udelay(IO_Delay); outb(val, port); udelay(IO_Delay); } else { outb(reg, port); outb(val, port); } spin_unlock_irqrestore(&IO_Spinlock, flags); } static inline void wr(struct scc_channel *scc, unsigned char reg, unsigned char val) { OutReg(scc->ctrl, reg, (scc->wreg[reg] = val)); } static inline void or(struct scc_channel *scc, unsigned char reg, unsigned char val) { OutReg(scc->ctrl, reg, (scc->wreg[reg] |= val)); } static inline void cl(struct scc_channel *scc, unsigned char reg, unsigned char val) { OutReg(scc->ctrl, reg, (scc->wreg[reg] &= ~val)); } /* ******************************************************************** */ /* * Interrupt Service Routines * */ /* ******************************************************************** */ static inline void flush_rx_FIFO(struct scc_channel *scc) { int k; for (k=0; k<(scc->enhanced? 8:4); k++) Inb(scc->data); if(scc->rx_buff != NULL) /* did we receive something? */ { scc->stat.rxerrs++; /* then count it as an error */ kfree_skb(scc->rx_buff); scc->rx_buff = NULL; } } static void start_hunt(struct scc_channel *scc) { if ((scc->modem.rx_clock_source == CLOCK_SOURCE_DPLL)) OutReg(scc->ctrl,R14,SEARCH|scc->wreg[R14]); /* 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; scc->stat.txints++; skb = scc->tx_buff; /* send first octet */ if (skb == NULL) { netif_wake_queue(scc->dev); scc_tx_done(scc); Outb(scc->ctrl, RES_Tx_P); return; } /* End Of Frame... */ if (skb->len == 0) { Outb(scc->ctrl, RES_Tx_P); /* reset pending int */ cl(scc, R10, ABUNDER); /* send CRC */ dev_kfree_skb(skb); scc->tx_buff = NULL; scc_kick_tx(scc); /* next frame */ return; } /* send octet */ Outb(scc->data,*skb->data); skb_pull(skb, 1); } /* External/Status interrupt handler */ static inline void scc_exint(struct scc_channel *scc) { unsigned char status,changes,chg_and_stat; scc->stat.exints++; status = InReg(scc->ctrl,R0); changes = status ^ scc->status; chg_and_stat = changes & status; /* ABORT: generated whenever DCD drops while receiving */ if (chg_and_stat & BRK_ABRT) /* Received an ABORT */ flush_rx_FIFO(scc); /* HUNT: software DCD; on = waiting for SYNC, off = receiving frame */ if ((changes & SYNC_HUNT) && scc->modem.softdcd) { if (status & SYNC_HUNT) { scc->dcd = 0; flush_rx_FIFO(scc); if ((scc->modem.rx_clock_source == CLOCK_SOURCE_DPLL)) OutReg(scc->ctrl,R14,SEARCH|scc->wreg[R14]); /* DPLL: enter search mode */ } else { scc->dcd = 1; } } /* DCD: on = start to receive packet, off = ABORT condition */ /* (a successfully received packet generates a special condition int) */ if((changes & DCD) && !scc->modem.softdcd) /* DCD input changed state */ { if(status & DCD) /* DCD is now ON */ { start_hunt(scc); scc->dcd = 1; } else { /* DCD is now OFF */ cl(scc,R3,ENT_HM|RxENABLE); /* disable the receiver */ flush_rx_FIFO(scc); scc->dcd = 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->modem.tx_delay == 0) /* zero TXDELAY = wait for CTS */ scc_start_tx_timer(scc, t_tx_delay, 0); } #endif if (scc->stat.tx_state == TXS_ACTIVE && (status & TxEOM)) { scc->stat.tx_under++; /* oops, an underrun! count 'em */ Outb(scc->ctrl, RES_EXT_INT); /* reset ext/status interrupts */ if (scc->tx_buff != NULL) { dev_kfree_skb(scc->tx_buff); scc->tx_buff = NULL; } or(scc,R10,ABUNDER); scc_tx_done(scc); } scc->status = status; Outb(scc->ctrl,RES_EXT_INT); } /* Receiver interrupt handler */ static inline void scc_rxint(struct scc_channel *scc) { unsigned char status; struct sk_buff *skb; scc->stat.rxints++; if((scc->wreg[5] & RTS) && (scc->modem.fullduplex == 0)) { Inb(scc->data); /* discard char */ or(scc,R3,ENT_HM); /* enter hunt mode for next flag */ return; } skb = scc->rx_buff; if (skb == NULL) { skb = dev_alloc_skb(scc->stat.bufsize); if (skb == NULL) { scc->dev_stat.rx_dropped++; scc->stat.nospace++; Inb(scc->data); or(scc, R3, ENT_HM); return; } scc->rx_buff = skb; } while(InReg(scc->ctrl, R0) & Rx_CH_AV) { status = InReg(scc->ctrl, R1); if (skb->len > scc->stat.bufsize) { #ifdef notdef printk(KERN_DEBUG "z8530drv: oops, scc_rxint() received huge frame...\n"); #endif kfree_skb(skb); scc->rx_buff = NULL; Inb(scc->data); or(scc, R3, ENT_HM); return; } *(skb_put(skb, 1)) = Inb(scc->data); if (status & Rx_OVR) { scc->stat.rx_over++; or(scc, R3, ENT_HM); if (skb != NULL) kfree_skb(skb); scc->rx_buff = NULL; Outb(scc->ctrl,ERR_RES); } if (status & END_FR && skb != NULL) { /* CRC okay, frame ends on 8 bit boundary and received something ? */ if (!(status & CRC_ERR) && (status & 0xe) == RES8 && skb->len > 0) { /* ignore last received byte (first of the CRC bytes) */ skb_trim(skb, skb->len-1); scc_net_rx(scc, skb); scc->rx_buff = NULL; scc->stat.rxframes++; } else { /* a bad frame */ kfree_skb(skb); scc->rx_buff = NULL; scc->stat.rxerrs++; Outb(scc->ctrl,ERR_RES); } } } } #define SCC_IRQTIMEOUT 5000 static void scc_isr(int irq, void *dev_id, struct pt_regs *regs) { unsigned char istat; struct scc_channel *scc; struct scc_ctrl **ctrl_p, *ctrl; int k; /* Find the SCC generating the interrupt by polling all attached SCCs * reading RR3A (the interrupt pending register) */ ctrl = *scc_ctrl; for (ctrl_p=scc_ctrl; *ctrl_p; ctrl_p++) { ctrl = *ctrl_p; if (ctrl->channel_a.irq != irq) continue; for (k = 0; k < SCC_IRQTIMEOUT; k++) { istat = InReg(ctrl->channel_a.ctrl, R3); if (!(istat & (CHARxIP|CHATxIP|CHAEXT|CHBRxIP|CHBTxIP|CHBEXT))) break; scc = &ctrl->channel_a; if ((istat & (CHARxIP|CHATxIP|CHAEXT)) && scc->dev) { scc = &ctrl->channel_a; if (istat & CHARxIP) scc_rxint(scc); if (istat & CHATxIP) scc_txint(scc); if (istat & CHAEXT) scc_exint(scc); } scc = &ctrl->channel_b; if ((istat & (CHBRxIP|CHBTxIP|CHBEXT)) && scc->dev) { scc = &ctrl->channel_a; if (istat & CHBRxIP) scc_rxint(scc); if (istat & CHBTxIP) scc_txint(scc); if (istat & CHBEXT) scc_exint(scc); } } if (k == SCC_IRQTIMEOUT) { printk(KERN_WARNING "z8530drv: endless loop in scc_isr()?!\n"); break; } } } /* ******************************************************************** */ /* * Init Channel */ /* ******************************************************************** */ /* ----> set SCC channel speed <---- */ static inline void set_brg(struct scc_channel *scc, unsigned int tc) { cl(scc,R14,BRENABL); /* disable baudrate generator */ wr(scc,R12,tc & 255); /* brg rate LOW */ wr(scc,R13,tc >> 8); /* brg rate HIGH */ or(scc,R14,BRENABL); /* enable baudrate generator */ } static inline void set_speed(struct scc_channel *scc) { unsigned long flags; spin_lock_irqsave(&scc->spinlocks.hwaccess, flags); if (scc->modem.rx_speed > 0) /* paranoia... */ set_brg(scc, (unsigned) (scc->clock / (scc->modem.rx_speed * 64)) - 2); spin_unlock_irqrestore(&scc->spinlocks.hwaccess, flags); } /* Construct value for clock mode register (R11) Here are some common settings: ------------------------------ normal half duplex operation: tx_clock_source = CLOCK_SOURCE_DPLL; rx_clock_source = CLOCK_SOURCE_DPLL; trxc_pin_mode = TRXCP_MODE_DPLL_OUT; note: this seems bogus, we used to switch to tx_clock_source = CLOCK_SOURCE_BRG; rx_clock_source = CLOCK_SOURCE_DPLL; trxc_pin_mode = TRXCP_MODE_BRG_OUT; on transmit which appears to be correct for Rx as well. normal operation for modems w/ own clock (re)generation on BayCom cards tx_clock_source = CLOCK_SOURCE_RTxC rx_clock_source = CLOCK_SOURCE_TRxC trxc_pin_mode = TRXCP_MODE_IN normal operation for modems w/ own clock (re)generation on elswhere tx_clock_source = CLOCK_SOURCE_TRxC rx_clock_source = CLOCK_SOURCE_RTxC trxc_pin_mode = TRXCP_MODE_IN fullduplex mode for modems w/o own clock generator (aka "divider mode") - BayCom style: tx_clock_source = CLOCK_SOURCE_RTxC rx_clock_source = CLOCK_SOURCE_DPLL trxc_pin_mode = TRXCP_MODE_DPLL_OUT; (divider divides by 2) fullduplex mode for modems w/o own clock generator (aka "divider mode") - usual style: tx_clock_source = CLOCK_SOURCE_RTxC rx_clock_source = CLOCK_SOURCE_DPLL trxc_pin_mode = TRXCP_MODE_BRG_OUT (BRG clock = 32 * DPLL clock, divider divides by 16) Note that only TRxC can be programmed to output, RTxC is _always_ input */ static int scc_calc_r11(int rx_clock_source, int tx_clock_source, int trxc_pin_mode) { int clockmode = 0; switch(tx_clock_source) { case CLOCK_SOURCE_RTxC: break; case CLOCK_SOURCE_TRxC: clockmode = TCTRxCP; break; case CLOCK_SOURCE_BRG: clockmode = TCBR; break; case CLOCK_SOURCE_DPLL: clockmode = TCDPLL; } switch(rx_clock_source) { case CLOCK_SOURCE_RTxC: break; case CLOCK_SOURCE_TRxC: clockmode |= RCTRxCP; break; case CLOCK_SOURCE_BRG: clockmode |= RCBR; break; case CLOCK_SOURCE_DPLL: clockmode |= RCDPLL; } switch(trxc_pin_mode) { case TRXCP_MODE_IN: break; case TRXCP_MODE_TXC_OUT: clockmode |= TRxCTC|TRxCOI; break; case TRXCP_MODE_BRG_OUT: clockmode |= TRxCBR|TRxCOI; break; case TRXCP_MODE_DPLL_OUT: clockmode |= TRxCDP|TRxCOI; break; } return clockmode; } static void scc_init_brg_and_dpll(struct scc_channel *scc) { wr(scc, R14, BRSRC); /* BRG source = PCLK */ if (scc->modem.tx_clock_source == CLOCK_SOURCE_DPLL || scc->modem.rx_clock_source == CLOCK_SOURCE_DPLL) { OutReg(scc->ctrl, R14, SSBR|scc->wreg[R14]); /* DPLL source = BRG */ OutReg(scc->ctrl, R14, SNRZI|scc->wreg[R14]); /* DPLL NRZI mode */ } else { OutReg(scc->ctrl, R14, DISDPLL|scc->wreg[R14]); } } /* ----> initialize an SCC channel <---- */ /* * 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 0XX00X00 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 000X0XXX 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 000SSSS1 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 000SXSSS 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) { unsigned long flags; spin_lock_irqsave(&scc->spinlocks.hwaccess, flags); del_timer(&scc->tx_timer); wr(scc,R4,X1CLK|SDLC); /* *1 clock, SDLC mode */ wr(scc,R1,0); /* no W/REQ operation */ wr(scc,R3,Rx8|RxCRC_ENAB); /* RX 8 bits/char, CRC, disabled */ wr(scc,R5,Tx8|DTR|TxCRC_ENAB); /* TX 8 bits/char, disabled, DTR */ wr(scc,R6,0); /* SDLC address zero (not used) */ wr(scc,R7,FLAG); /* SDLC flag value */ wr(scc,R9,VIS); /* vector includes status */ wr(scc,R10,(scc->modem.nrz_mode? NRZI : NRZ)|CRCPS|ABUNDER); /* abort on underrun, preset CRC generator, NRZ(I) */ wr(scc,R14, 0); wr(scc, R11, scc_calc_r11(scc->modem.rx_clock_source, scc->modem.tx_clock_source, scc->modem.trxc_pin_mode)); scc_init_brg_and_dpll(scc); if(scc->enhanced) { or(scc,R15,SHDLCE|FIFOE); /* enable FIFO, SDLC/HDLC Enhancements (From now R7 is R7') */ wr(scc,R7,AUTOEOM); } if(scc->modem.softdcd || (InReg(scc->ctrl,R0) & DCD)) /* DCD is now ON */ { start_hunt(scc); } /* enable ABORT, DCD & SYNC/HUNT interrupts */ wr(scc,R15, BRKIE|TxUIE|(scc->modem.softdcd? SYNCIE:DCDIE)); Outb(scc->ctrl,RES_EXT_INT); /* reset ext/status interrupts */ Outb(scc->ctrl,RES_EXT_INT); /* must be done twice */ or(scc,R1,INT_ALL_Rx|TxINT_ENAB|EXT_INT_ENAB); /* enable interrupts */ scc->status = InReg(scc->ctrl,R0); /* read initial status */ or(scc,R9,MIE); /* master interrupt enable */ scc_init_timer(scc); spin_unlock_irqrestore(&scc->spinlocks.hwaccess, flags); set_speed(scc); /* set baudrate */ } /* ******************************************************************** */ /* * SCC timer functions * */ /* ******************************************************************** */ /* ----> scc_key_trx sets the time constant for the baudrate generator and keys the transmitter <---- */ static void scc_key_trx(struct scc_channel *scc, char tx) { unsigned long flags; unsigned int time_const; if (scc->brand & PRIMUS) Outb(scc->ctrl + 4, scc->special_option | (tx? 0x80 : 0)); if (tx) time_const = (unsigned) (scc->clock / (scc->modem.tx_speed * 2)) - 2; else time_const = (unsigned) (scc->clock / (scc->modem.rx_speed * 64)) - 2; spin_lock_irqsave(&scc->spinlocks.hwaccess, flags); if (tx) { or(scc, R1, TxINT_ENAB); /* t_maxkeyup may have reset these */ or(scc, R15, TxUIE); } if (scc->modem.rx_clock_source == CLOCK_SOURCE_DPLL) { /* force simplex operation */ if (tx) { #ifdef CONFIG_SCC_TRXECHO cl(scc, R3, RxENABLE|ENT_HM); /* switch off receiver */ cl(scc, R15, DCDIE|SYNCIE); /* No DCD changes, please */ #endif set_brg(scc, time_const); /* reprogram baudrate generator */ /* DPLL -> Rx clk, BRG -> Tx CLK, TRxC mode output, TRxC = BRG */ wr(scc, R11, RCDPLL|TCBR|TRxCOI|TRxCBR); /* By popular demand: tx_inhibit */ if (scc->modem.tx_inhibit) { or(scc,R5, TxENAB); scc->wreg[R5] |= RTS; } else { or(scc,R5,RTS|TxENAB); /* set the RTS line and enable TX */ } } else { cl(scc,R5,RTS|TxENAB); set_brg(scc, time_const); /* reprogram baudrate generator */ /* DPLL -> Rx clk, DPLL -> Tx CLK, TRxC mode output, TRxC = DPLL */ wr(scc, R11, RCDPLL|TCDPLL|TRxCOI|TRxCDP); #ifndef CONFIG_SCC_TRXECHO if (scc->modem.softdcd) #endif { or(scc,R15, scc->modem.softdcd? SYNCIE:DCDIE); start_hunt(scc); } } } else { if (tx) { #ifdef CONFIG_SCC_TRXECHO if (scc->modem.fullduplex == 0) { cl(scc, R3, RxENABLE); cl(scc, R15, DCDIE|SYNCIE); } #endif if (scc->modem.tx_inhibit) { or(scc,R5, TxENAB); scc->wreg[R5] |= RTS; } else { or(scc,R5,RTS|TxENAB); /* enable tx */ } } else { cl(scc,R5,RTS|TxENAB); /* disable tx */ if ((scc->modem.fullduplex == 0) && #ifndef CONFIG_SCC_TRXECHO scc->modem.softdcd) #else 1) #endif { or(scc, R15, scc->modem.softdcd? SYNCIE:DCDIE); start_hunt(scc); } } } spin_unlock_irqrestore(&scc->spinlocks.hwaccess, flags); } static void scc_kick_tx(struct scc_channel *scc) { struct sk_buff *skb; unsigned long flags; spin_lock_irqsave(&scc->spinlocks.kick_tx, flags); skb = scc->tx_new; scc->tx_new = NULL; netif_wake_queue(scc->dev); if (skb == NULL) goto nada; if (skb->len == 0) /* Paranoia... */ { dev_kfree_skb(skb); scc->tx_buff = NULL; Outb(scc->ctrl, RES_Tx_P); goto nada; } scc->tx_buff = skb; scc->stat.tx_state = TXS_ACTIVE; OutReg(scc->ctrl, R0, RES_Tx_CRC); /* reset CRC generator */ or(scc,R10,ABUNDER); /* re-install underrun protection */ Outb(scc->data,*skb->data); /* send byte */ skb_pull(skb, 1); if (!scc->enhanced) /* reset EOM latch */ Outb(scc->ctrl,RES_EOM_L); spin_unlock_irqrestore(&scc->spinlocks.kick_tx, flags); return; nada: scc_tx_done(scc); spin_unlock_irqrestore(&scc->spinlocks.kick_tx, flags); return; } /* ----> SCC timer interrupt handler and friends. <---- */ static void scc_start_tx_timer(struct scc_channel *scc, void (*handler)(struct scc_channel *), unsigned long when) { unsigned long flags; spin_lock_irqsave(&scc->spinlocks.timer, flags); del_timer(&scc->tx_timer); if (when != 0) { scc->tx_timer.data = (unsigned long) scc; scc->tx_timer.function = (void (*)(unsigned long)) handler; scc->tx_timer.expires = jiffies + (when*HZ)/1000; add_timer(&scc->tx_timer); } else { handler(scc); } spin_unlock_irqrestore(&scc->spinlocks.timer, flags); } /* * 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) { scc->stat.tx_state = TXS_TAIL; if (scc->modem.tx_tail != 0) scc_start_tx_timer(scc, scc_tail, scc->modem.tx_tail); else scc_tail(scc); } #ifndef SCC_SIMPLE_MAC static void scc_tx_forced(struct scc_channel *scc) { scc->stat.tx_state = TXS_TAIL; if (scc->tx_new) scc_kick_tx(scc); else // remain key-up'ed for the time of tx_delay... // what's the timeout in 6pack? scc_start_tx_timer(scc, scc_tail, scc->modem.tx_delay); } #endif static void scc_tx_start(struct scc_channel *scc, struct sk_buff *skb) { scc->tx_new = skb; /* * scc_set_rts may also start a tx delay wait time, if we * get a frame to transmit within this time RTS would be set, * shorten the tx delay time... */ if (scc->stat.tx_state != TXS_TXDELAY) { scc->stat.tx_state = TXS_TXDELAY; if ( !(scc->wreg[R5] & RTS) ) { scc_key_trx(scc, TX_ON); scc_start_tx_timer(scc, scc_kick_tx, scc->modem.tx_delay); } else { scc_start_tx_timer(scc, scc_kick_tx, 0); } } } #ifndef SCC_SIMPLE_MAC static void scc_set_rts(struct scc_channel *scc) { scc->stat.tx_state = TXS_TXDELAY; if ( !(scc->wreg[R5] & RTS) ) { scc_key_trx(scc, TX_ON); scc_start_tx_timer(scc, scc_tx_forced, scc->modem.tx_delay); } else { scc_start_tx_timer(scc, scc_tx_forced, 0); } } #endif /* * TAILTIME expired */ static void scc_tail(struct scc_channel *scc) { if (scc->tx_buff != NULL) return; if (scc->tx_new != NULL) { scc_kick_tx(scc); return; } scc_key_trx(scc, TX_OFF); scc->stat.tx_state = TXS_IDLE; } static void scc_init_timer(struct scc_channel *scc) { unsigned long flags; spin_lock_irqsave(&scc->spinlocks.timer, flags); scc->stat.tx_state = TXS_IDLE; // FIXME: this can't be all, can it...? spin_unlock_irqrestore(&scc->spinlocks.timer, flags); } /* ******************************************************************** */ /* * Set/get L1 parameters * */ /* ******************************************************************** */ /* * this will set the (some, anyway...) MODEM parameters */ static unsigned int scc_set_param(struct scc_channel *scc, struct scc_modem *modem) { scc->modem.tx_delay = modem->tx_delay; scc->modem.tx_tail = modem->tx_tail; scc->modem.fullduplex = modem->fullduplex; scc->modem.tx_inhibit = modem->tx_inhibit; scc->modem.softdcd = modem->softdcd; if (modem->softdcd) { or(scc, R15, SYNCIE); cl(scc, R15, DCDIE); start_hunt(scc); } else { or(scc, R15, DCDIE); cl(scc, R15, SYNCIE); } return 0; } static unsigned int scc_ddi_report_dcd(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; /* printk(KERN_INFO "dcd=%d\n", scc->dcd); */ return scc->dcd; } static unsigned int scc_ddi_report_ptt(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; /* printk(KERN_INFO "rts=%d\n", (scc->wreg[R5] & RTS)? 1:0); */ return (scc->wreg[R5] & RTS)? 1:0; } #ifndef SCC_SIMPLE_MAC static unsigned int scc_ddi_report_cts(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; int txs = scc->stat.tx_state; /* printk(KERN_INFO "cts=%d\n", ((txs == TXS_ACTIVE) || (txs == TXS_TAIL))? 1:0); */ return ((txs == TXS_ACTIVE) || (txs == TXS_TAIL))? 1:0; } static void scc_ddi_set_rts(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; /* printk(KERN_INFO "setrts\n"); */ scc_set_rts(scc); } #endif static void scc_ddi_set_bitrate(struct net_device *dev, unsigned int speed) { struct scc_channel *scc = (struct scc_channel *) dev->priv; scc->modem.rx_speed = speed; scc->modem.tx_speed = speed; if (scc->stat.tx_state != TXS_ACTIVE) set_speed(scc); } /* Update general parameters so that they reflect our internal settings */ static void scc_ddi_param_update(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; ax25_dev_set_value(dev, AX25_VALUES_MEDIA_DUPLEX, scc->modem.fullduplex); ax25_dev_set_value(dev, AX25_VALUES_MEDIA_RXBITRATE, scc->modem.rx_speed); ax25_dev_set_value(dev, AX25_VALUES_MEDIA_TXBITRATE, scc->modem.tx_speed); ax25_dev_set_value(dev, AX25_VALUES_MEDIA_TXDELAY, scc->modem.tx_delay); ax25_dev_set_value(dev, AX25_VALUES_MEDIA_TXTAIL, scc->modem.tx_tail); return; } /* Called from upper layers when parameter was changed */ static void scc_ddi_param_notify(struct net_device *dev, int valueno, int old, int new) { struct scc_channel *scc = (struct scc_channel *) dev->priv; switch (valueno) { case AX25_VALUES_MEDIA_DUPLEX: if (!netif_running(dev)) scc->modem.fullduplex = new; break; case AX25_VALUES_MEDIA_RXBITRATE: case AX25_VALUES_MEDIA_TXBITRATE: scc_ddi_set_bitrate(dev, new); break; case AX25_VALUES_MEDIA_TXDELAY: scc->modem.tx_delay = new; break; case AX25_VALUES_MEDIA_TXTAIL: scc->modem.tx_tail = new; break; default: break; } scc_ddi_param_update(dev); return; } /* ******************************************************************* */ /* * Init channel structures, special HW, etc... * */ /* ******************************************************************* */ /* * Allocate device structure, err, instance, and register driver */ static int scc_net_setup(struct scc_channel *scc) { int k = 0; struct net_device *dev; if ((scc->dev = (struct net_device *) kmalloc(sizeof(struct net_device), GFP_KERNEL)) == NULL) return -ENOMEM; dev = scc->dev; memset(dev, 0, sizeof(struct net_device)); do { sprintf(dev->name, "scc%d", k); if (++k > 256) goto bail_out; /* avoid endless loop */ } while (dev_get_by_name(dev->name) == NULL); dev->priv = (void *) scc; dev->init = scc_net_init; if (register_netdev(dev) != 0) goto bail_out; scc->proc_dev_name = dev->name; scc->tx_buff = NULL; scc->tx_new = NULL; scc->init = 1; scc_ddi_param_update(dev); return 0; bail_out: kfree(dev); scc->dev = NULL; return -EINVAL; } /* ******************************************************************** */ /* * Network driver methods * */ /* ******************************************************************** */ /* ----> Initialize device <----- */ static int scc_net_init(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; struct ax25_dev *ax25dev; dev_init_buffers(dev); dev->tx_queue_len = 16; /* should be enough... */ dev->open = scc_net_open; dev->stop = scc_net_close; dev->hard_start_xmit = scc_net_tx; dev->set_mac_address = scc_net_set_mac_address; dev->get_stats = scc_net_get_stats; dev->do_ioctl = scc_net_ioctl; dev->tx_timeout = scc_net_timeout; dev->watchdog_timeo = SCC_WATCHDOG_TIMEOUT; dev->type = ARPHRD_AX25; dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN; dev->mtu = AX25_DEF_PACLEN; dev->addr_len = AX25_ADDR_LEN; AX25_PTR(dev) = ax25dev = &scc->ax25dev; memset(ax25dev, 0, sizeof(struct ax25_dev)); ax25dev->hw.ptt = scc_ddi_report_ptt; ax25dev->hw.dcd = scc_ddi_report_dcd; #ifndef SCC_SIMPLE_MAC ax25dev->hw.cts = scc_ddi_report_cts; ax25dev->hw.rts = scc_ddi_set_rts; #endif ax25dev->hw.parameter_change_notify = scc_ddi_param_notify; ax25dev->hw.fast = 0; return 0; } /* ----> open network device <---- */ static int scc_net_open(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; if (!scc->init) return -EINVAL; MOD_INC_USE_COUNT; scc->tx_buff = NULL; init_channel(scc); scc_ddi_param_update(dev); netif_start_queue(dev); return 0; } /* ----> close network device <---- */ static int scc_net_close(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; unsigned long flags; netif_stop_queue(dev); spin_lock_irqsave(&scc->spinlocks.hwaccess, flags); Outb(scc->ctrl,0); /* Make sure pointer is written */ wr(scc,R1,0); /* disable interrupts */ wr(scc,R3,0); del_timer(&scc->tx_timer); spin_unlock_irqrestore(&scc->spinlocks.hwaccess, flags); if (scc->tx_buff) kfree_skb(scc->tx_buff); if (scc->tx_new) kfree_skb(scc->tx_new); MOD_DEC_USE_COUNT; 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) { kfree_skb(skb); return; } scc->dev_stat.rx_packets++; skb->dev = scc->dev; skb->protocol = htons(ETH_P_AX25); skb->mac.raw = skb->data; skb->pkt_type = PACKET_HOST; netif_rx(skb); return; } /* ----> transmit frame <---- */ static int scc_net_tx(struct sk_buff *skb, struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; if (skb->len > scc->stat.bufsize || skb->len < 2) { scc->dev_stat.tx_dropped++; /* bogus frame */ dev_kfree_skb(skb); return 0; } netif_stop_queue(dev); scc->dev_stat.tx_packets++; scc->stat.txframes++; #ifdef notdef /**** The following "fix" is bogus. Fix the protocol, dammit! ****/ /* avoid race condition when skb is a cloned broadcast */ skb_cp = skb_copy(skb, GFP_ATOMIC); dev_kfree_skb(skb); if (skb_cp == NULL) { scc->dev_stat.tx_dropped++; /* out of memory */ return 0; } #endif /* transmit frame */ dev->trans_start = jiffies; scc_tx_start(scc, skb); return 0; } /* -----> Watchdog <----- */ static void scc_net_timeout(struct net_device *dev) { struct scc_channel *scc = (struct scc_channel *) dev->priv; unsigned long flags; del_timer(&scc->tx_timer); spin_lock_irqsave(&scc->spinlocks.hwaccess, flags); cl(scc, R1, TxINT_ENAB); cl(scc, R15, TxUIE); OutReg(scc->ctrl, R0, RES_Tx_P); spin_unlock_irqrestore(&scc->spinlocks.hwaccess, flags); scc_start_tx_timer(scc, init_channel, 100); } /* ----> ioctl functions <---- */ static int scc_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) { return -ENOIOCTLCMD; } static int scc_check_and_init(struct scc_ctrl *ctrl) { ctl_table *t_port[2]; unsigned long flags; int found_a = 1; int found_b = 1; int port, entry; /* are we still missing vital information? */ if (ctrl->channel_a.ctrl <= 0 || ctrl->channel_a.data <= 0 || ctrl->channel_b.ctrl <= 0 || ctrl->channel_b.ctrl <= 0 || ctrl->channel_a.irq <= 0) return 1; check_region(ctrl->channel_a.ctrl, 1); check_region(ctrl->channel_b.ctrl, 1); spin_lock_irqsave(&ctrl->channel_a.spinlocks.hwaccess, flags); /* reset the chip */ Outb(ctrl->channel_a.ctrl, 0); OutReg(ctrl->channel_a.ctrl, R9, FHWRES); udelay(100); /* check if it's really there... */ #ifndef SCC_DONT_CHECK OutReg(ctrl->channel_a.ctrl, R13, 0x55); udelay(5); if (InReg(ctrl->channel_a.ctrl, R13) != 0x55) found_a = 0; OutReg(ctrl->channel_b.ctrl, R13, 0xaa); udelay(5); if (InReg(ctrl->channel_b.ctrl, R13) != 0xaa) found_b = 0; #endif spin_unlock_irqrestore(&ctrl->channel_a.spinlocks.hwaccess, flags); printk(KERN_INFO "z8530drv: chip %d, channel A (0x%3.3x/0x%3.3x) %sfound, " "channel B (0x%3.3x/0x%3.3x) %sfound, irq %d\n", Nchips, (int) ctrl->channel_a.data, (int) ctrl->channel_a.ctrl, found_a? "":"not ", (int) ctrl->channel_b.data, (int) ctrl->channel_b.ctrl, found_b? "":"not ", ctrl->channel_a.irq); /* at least one channel not properly specified */ if (!(found_a && found_b)) return -EINVAL; /* grab IRQ */ if (!scc_irq_used[ctrl->channel_a.irq]) { if (request_irq(ctrl->channel_a.irq, scc_isr, SA_INTERRUPT, "AX.25 SCC", NULL)) { printk(KERN_WARNING "z8530drv: cannot get IRQ %d\n", ctrl->channel_a.irq); return -EINVAL; } scc_irq_used[ctrl->channel_a.irq]++; } /* register IO ports */ request_region(ctrl->channel_a.ctrl, 1, "scc ctrl"); request_region(ctrl->channel_b.ctrl, 1, "scc ctrl"); request_region(ctrl->channel_a.data, 1, "scc data"); request_region(ctrl->channel_b.data, 1, "scc data"); /* register network devices */ scc_net_setup(&ctrl->channel_a); scc_net_setup(&ctrl->channel_b); /* initialize special hardware -- note that port & option need to be set at this point */ if (ctrl->channel_a.special_port > 0) { if (ctrl->channel_a.brand & EAGLE) /* enable interrupt on EAGLE card */ Outb(ctrl->channel_a.special_port, 0x08); if (ctrl->channel_a.brand & (PC100 | PRIMUS)) /* set MODEM mode on PC100 or PRIMUS cards */ Outb(ctrl->channel_a.special_port, ctrl->channel_a.special_option); } /* inhibit change of vital parameters after init; this probably isn't entirely race free * free, but we can live with this (at worst the new mode hasn't been propagated to the VFS * yet and we get an EINVAL though the file seems to be writable. *shrugs* */ for (entry=0; ctrl->proc_tables.chip[entry].ctl_name; entry++) { switch(ctrl->proc_tables.chip[entry].ctl_name) { case NET_DEV_Z8530DRV_IRQ: case NET_DEV_Z8530DRV_ESCC: case NET_DEV_Z8530DRV_SPECIAL_PORT: case NET_DEV_Z8530DRV_SPECIAL_OPT: ctrl->proc_tables.chip[entry].mode = 0444; break; } } t_port[0] = ctrl->channel_a.proc_tables.channel; t_port[1] = ctrl->channel_b.proc_tables.channel; for (port=0; port < 2; port++) { for (entry=0; t_port[port][entry].ctl_name; entry++) { switch(t_port[port][entry].ctl_name) { case NET_DEV_Z8530DRV_DATA_PORT: case NET_DEV_Z8530DRV_CTRL_PORT: t_port[port][entry].mode = 0444; break; } } } return 0; } /* ----> set interface callsign <---- */ static int scc_net_set_mac_address(struct net_device *dev, void *addr) { struct sockaddr *sa = (struct sockaddr *) addr; memcpy(dev->dev_addr, sa->sa_data, dev->addr_len); 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->priv; scc->dev_stat.rx_errors = scc->stat.rxerrs + scc->stat.rx_over; scc->dev_stat.tx_errors = scc->stat.txerrs + scc->stat.tx_under; scc->dev_stat.rx_fifo_errors = scc->stat.rx_over; scc->dev_stat.tx_fifo_errors = scc->stat.tx_under; return &scc->dev_stat; } /* ******************************************************************** */ /* * /proc/sys/ interface * */ /* ******************************************************************** */ /* * structure: * --------- * * /proc/sys/net/dev/z8530drv/ * nchips * delay * chip_0/ * vendor * clock * irq * delay * enhanced * special_port * special_opt * port_a/ * data_port * ctrl_port * ifname * modem/ * rx_speed * tx_speed * rx_clock_source * tx_clock_source * trx_pin_mode * fullduplex * trx_does_feedback * nrz_mode * tx_inhibit * softdcd * tx_delay * tx_tail * stats/ * rx_ints * tx_ints * ex_ints * sp_ints * tx_frames * rx_frames * tx_errors * rx_errors * tx_underruns * rx_overruns * no_space * tx_state * port_b/ * ... * chip_1/ * ... * * The idea is to be able to configure the driver through SNMP, store * the configuration in an LDAP directory or place it into an XML * document... The structure may look overly complex for the * purpose, but the old "initialize through a special ioctl()" was too * complex to maintain. */ /* parent node /proc/sys/net/dev */ static ctl_table scc_proc_root_table[] = { {NET_DEV, "dev", NULL, 0, 0555, scc_proc_parent_table}, {0} }; /* our directory */ static ctl_table scc_proc_parent_table[] = { {NET_DEV_Z8530DRV, "z8530drv", NULL, 0, 0555, scc_proc_nchips_table}, {0} }; /* number of chips, subdirectories get added or removed dynamically */ static ctl_table scc_proc_nchips_table[] = { {NET_DEV_Z8530DRV_NCHIPS, "nchips", &Nchips, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_nchips, NULL}, {NET_DEV_Z8530DRV_DELAY, "io_delay", &IO_Delay, sizeof(int), 0644, NULL, &proc_dointvec, &sysctl_intvec, NULL}, {0} }; static void scc_proc_setup_channel(struct scc_ctrl *ctrl, struct scc_channel *scc) { int entry; ctl_table *t_port = scc->proc_tables.channel; ctl_table *t_modem = scc->proc_tables.modem; ctl_table *t_stats = scc->proc_tables.stats; /* Set /.../chip_/channel_

/modem/ */ /* Praise the Lord! We can do this with GCC! */ entry=0; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_RX_SPEED, "rx_speed", &scc->modem.rx_speed, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_TX_SPEED, "tx_speed", &scc->modem.tx_speed, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_RX_CLOCK_SOURCE, "rx_clock_source", &scc->modem.rx_clock_source, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_TX_CLOCK_SOURCE, "tx_clock_source", &scc->modem.tx_clock_source, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_TRXC_PIN_MODE, "trxc_pin_mode", &scc->modem.trxc_pin_mode, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_FULLDUPLEX, "fullduplex", &scc->modem.fullduplex, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_TRX_FEEDBACK, "trx_feedback", &scc->modem.trx_feedback, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_NRZ_MODE, "nrz_mode", &scc->modem.nrz_mode, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_TX_INHIBIT, "tx_inhibit", &scc->modem.tx_inhibit, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_SOFTDCD, "softdcd", &scc->modem.softdcd, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_TX_DELAY, "tx_delay", &scc->modem.tx_delay, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry++] = (ctl_table) { NET_DEV_Z8530DRV_TX_TAIL, "tx_tail", &scc->modem.tx_tail, sizeof(int), 0644, NULL, proc_dointvec, scc_proc_intvec_modem, NULL, (void *) scc }; t_modem[entry] = (ctl_table) {0}; /* Set /.../chip_/channel_

/stats/ */ entry = 0; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_RX_INTS, "rx_ints", &scc->stat.rxints, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_TX_INTS, "tx_ints", &scc->stat.txints, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_EX_INTS, "ex_ints", &scc->stat.exints, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_TX_FRAMES, "tx_frames", &scc->stat.txframes, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_RX_FRAMES, "rx_frames", &scc->stat.rxframes, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_TX_ERRORS, "tx_errors", &scc->stat.txerrs, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_RX_ERRORS, "rx_errors", &scc->stat.rxerrs, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_TX_UNDERRUNS, "tx_underruns", &scc->stat.tx_under, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_RX_OVERRUNS, "rx_overruns", &scc->stat.rx_over, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_NO_SPACE, "no_space", &scc->stat.nospace, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT_TX_STATE, "tx_state", &scc->stat.tx_state, sizeof(int), 0444, NULL, &proc_dointvec, &scc_proc_intvec_modem, NULL }; t_stats[entry] = (ctl_table) {0}; /* Set /.../chip_/channel_

/ */ entry = 0; t_port[entry++] = (ctl_table) { NET_DEV_Z8530DRV_DATA_PORT, "data_port", &scc->data, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_port, NULL, (void *) ctrl, (void *) scc }; t_port[entry++] = (ctl_table) { NET_DEV_Z8530DRV_CTRL_PORT, "ctrl_port", &scc->ctrl, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_chip, NULL, (void *) ctrl, (void *) scc }; t_port[entry++] = (ctl_table) { NET_DEV_Z8530DRV_IFNAME, "ifname", &scc->proc_dev_name, IFNAMSIZ, 0444, NULL, &proc_dostring, &sysctl_string, NULL, (void *) ctrl, (void *) scc }; t_port[entry++] = (ctl_table) { NET_DEV_Z8530DRV_BUFSIZE, "bufsize", &scc->stat.bufsize, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_port, NULL, (void *) ctrl, (void *) scc }; t_port[entry++] = (ctl_table) { NET_DEV_Z8530DRV_MODEM, "modem", NULL, 0, 0555, t_modem }; t_port[entry++] = (ctl_table) { NET_DEV_Z8530DRV_STAT, "stats", NULL, 0, 0555, t_stats }; t_port[entry] = (ctl_table) {0}; memset(scc, 0, sizeof(struct scc_channel)); scc->clock = SCC_DEFAULT_CLOCK; scc->ctrl = -1; scc->data = -1; scc->special_port = -1; scc->irq = -1; scc->modem.rx_speed = 9600; scc->modem.tx_speed = 9600; scc->modem.tx_clock_source = CLOCK_SOURCE_RTxC; scc->modem.rx_clock_source = CLOCK_SOURCE_TRxC; scc->modem.trxc_pin_mode = TRXCP_MODE_IN; spin_lock_init(&scc->spinlocks.hwaccess); spin_lock_init(&scc->spinlocks.timer); spin_lock_init(&scc->spinlocks.kick_tx); } static void scc_proc_setup_chip(void) { int entry; ctl_table *t_chip = scc_ctrl[Nchips]->proc_tables.chip; struct scc_channel *channel_a = &scc_ctrl[Nchips]->channel_a; struct scc_channel *channel_b = &scc_ctrl[Nchips]->channel_b; /* Set /.../chip_/ */ entry=0; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_VENDOR, "vendor", &channel_a->brand, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_chip, NULL, (void *) &scc_ctrl[Nchips] }; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_CLOCK, "clock", &channel_a->clock, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_chip, NULL, (void *) &scc_ctrl[Nchips] }; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_IRQ, "irq", &channel_a->irq, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_chip, NULL, (void *) &scc_ctrl[Nchips] }; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_ESCC, "enhanced", &channel_a->enhanced, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_chip, NULL, (void *) &scc_ctrl[Nchips] }; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_SPECIAL_PORT, "special_port", &channel_a->special_port, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_chip, NULL, (void *) &scc_ctrl[Nchips] }; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_SPECIAL_OPT, "special_opt", &channel_a->special_option, sizeof(int), 0644, NULL, &proc_dointvec, &scc_proc_intvec_chip, NULL, (void *) &scc_ctrl[Nchips] }; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_CHANNEL_A, "channel_a", NULL, 0, 0555, channel_a->proc_tables.channel }; t_chip[entry++] = (ctl_table) { NET_DEV_Z8530DRV_CHANNEL_B, "channel_b", NULL, 0, 0555, channel_b->proc_tables.channel }; t_chip[entry] = (ctl_table) {0}; } static void scc_proc_remove_channel(struct scc_ctrl *ctrl, struct scc_channel *scc) { long flags; spin_lock_irqsave(&scc->spinlocks.hwaccess, flags); /* disable interrupts */ cl(scc, R9, MIE); udelay(50); /* free io ports */ release_region(scc->ctrl, 1); release_region(scc->data, 1); if (scc->dev) { unregister_netdev(scc->dev); kfree(scc->dev); } spin_unlock_irqrestore(&scc->spinlocks.hwaccess, flags); } static void scc_proc_remove_chip(struct scc_ctrl *ctrl) { long flags; int irq; spin_lock_irqsave(&ctrl->channel_a.spinlocks.hwaccess, flags); Outb(ctrl->channel_a.ctrl, 0); OutReg(ctrl->channel_a.ctrl, R9, FHWRES); irq = ctrl->channel_a.irq; if (--scc_irq_used[irq] <= 0) { free_irq(irq, NULL); scc_irq_used[irq] = 0; /* paranoia */ } spin_unlock_irqrestore(&ctrl->channel_a.spinlocks.hwaccess, flags); unregister_sysctl_table(scc_ctrl[Nchips]->proc_table_head); kfree(scc_ctrl[Nchips]->proc_tables.dir[0].procname); kfree(scc_ctrl[Nchips]); } static int scc_proc_intvec_modem(ctl_table *table, int *name, int nlen, void *oldval, size_t *oldlenp, void *newval, size_t newlen, void **context) { int retval = 0; struct scc_channel *scc = (struct scc_channel *) table->extra1; if (scc == NULL || !scc->init) return -EINVAL; switch(table->ctl_name) { case NET_DEV_Z8530DRV_RX_SPEED: case NET_DEV_Z8530DRV_TX_SPEED: if (scc->stat.tx_state != TXS_ACTIVE) set_speed(scc); break; case NET_DEV_Z8530DRV_RX_CLOCK_SOURCE: case NET_DEV_Z8530DRV_TX_CLOCK_SOURCE: case NET_DEV_Z8530DRV_TRXC_PIN_MODE: wr(scc, R11, scc_calc_r11(scc->modem.rx_clock_source, scc->modem.tx_clock_source, scc->modem.trxc_pin_mode)); scc_init_brg_and_dpll(scc); break; case NET_DEV_Z8530DRV_FULLDUPLEX: case NET_DEV_Z8530DRV_TRX_FEEDBACK: case NET_DEV_Z8530DRV_TX_INHIBIT: case NET_DEV_Z8530DRV_TX_DELAY: case NET_DEV_Z8530DRV_TX_TAIL: break; case NET_DEV_Z8530DRV_NRZ_MODE: case NET_DEV_Z8530DRV_SOFTDCD: break; default: retval = -EINVAL; } scc_ddi_param_update(scc->dev); return retval; } static int scc_proc_intvec_port(ctl_table *table, int *name, int nlen, void *oldval, size_t *oldlenp, void *newval, size_t newlen, void **context) { struct scc_ctrl *ctrl = (struct scc_ctrl *) table->extra1; struct scc_channel *scc = (struct scc_channel *) table->extra2; int val; val = *((int *) newval); if (scc == NULL) return -EINVAL; switch(table->ctl_name) { case NET_DEV_Z8530DRV_DATA_PORT: if (val > 0) { scc_check_and_init(ctrl); return 1; } break; case NET_DEV_Z8530DRV_CTRL_PORT: if (val > 0) { scc_check_and_init(ctrl); return 1; } break; case NET_DEV_Z8530DRV_BUFSIZE: break; } return 0; } static int scc_proc_intvec_chip(ctl_table *table, int *name, int nlen, void *oldval, size_t *oldlenp, void *newval, size_t newlen, void **context) { struct scc_ctrl *ctrl = (struct scc_ctrl *) table->extra1; int val; if (ctrl == NULL) return -EINVAL; if (ctrl->channel_a.init || ctrl->channel_b.init) return -EINVAL; val = *((int *) newval); switch(table->ctl_name) { case NET_DEV_Z8530DRV_VENDOR: case NET_DEV_Z8530DRV_CLOCK: case NET_DEV_Z8530DRV_ESCC: case NET_DEV_Z8530DRV_SPECIAL_PORT: case NET_DEV_Z8530DRV_SPECIAL_OPT: break; case NET_DEV_Z8530DRV_IRQ: if (val > 0) { ctrl->channel_a.irq = val; ctrl->channel_b.irq = val; scc_check_and_init(ctrl); return 1; } break; } return 0; } static int scc_proc_intvec_nchips(ctl_table *table, int *name, int nlen, void *oldval, size_t *oldlenp, void *newval, size_t newlen, void **context) { struct scc_ctrl_proc_tables *tables = NULL; struct scc_ctrl *ctrl = NULL; int chip; char *dirname; int new_nchips, old_nchips; new_nchips = *((int *) newval); old_nchips = *((int *) oldval); /* sanity checks...*/ if (new_nchips < 0 || new_nchips > maxchips) return -EINVAL; /* adding chips */ if (new_nchips > old_nchips) { for (chip=0; chip < new_nchips - old_nchips; chip++) { ctrl = (struct scc_ctrl *) kmalloc(sizeof(struct scc_ctrl), GFP_KERNEL); if (ctrl == NULL) return -ENOMEM; scc_ctrl[Nchips] = ctrl; memset(ctrl, 0, sizeof(struct scc_ctrl)); tables = &ctrl->proc_tables; scc_proc_setup_channel(ctrl, &ctrl->channel_a); scc_proc_setup_channel(ctrl, &ctrl->channel_b); scc_proc_setup_chip(); /* !!FIXME!! free memory when removing a chip */ dirname = kmalloc(sizeof(char)*IFNAMSIZ, GFP_KERNEL); if (dirname == NULL) return -ENOMEM; sprintf(dirname, "chip_%d", Nchips); tables->dir[0] = (ctl_table) { NET_DEV_Z8530DRV_CHIP_BASE+Nchips, dirname, NULL, 0, 0555, tables->chip }; tables->dir[1] = (ctl_table) {0}; tables->parent[0] = (ctl_table) { NET_DEV_Z8530DRV, "z8530drv", NULL, 0, 0555, tables->dir }; tables->parent[1] = (ctl_table) {0}; /* add return value to scc structure */ scc_ctrl[Nchips]->proc_table_head = register_sysctl_table(tables->parent, 1); Nchips++; } *((int *) newval) = Nchips; } else if (new_nchips < old_nchips) { for(chip=0; chip < old_nchips - new_nchips; chip++) { ctrl = scc_ctrl[Nchips-1]; /* !!FIXME!! possible race condition here */ if (netif_running(ctrl->channel_a.dev) || netif_running(ctrl->channel_b.dev)) break; scc_proc_remove_channel(ctrl, &ctrl->channel_a); scc_proc_remove_channel(ctrl, &ctrl->channel_b); scc_proc_remove_chip(ctrl); Nchips--; } *((int *) newval) = Nchips; } return 0; } /* ******************************************************************** */ /* * Init SCC driver * */ /* ******************************************************************** */ int __init scc_init_driver(void) { int k; size_t size; printk(KERN_INFO BANNER); size=sizeof(struct scc_ctrl)*(maxchips+1); scc_ctrl = kmalloc(size, GFP_KERNEL); if (scc_ctrl == NULL) return -ENOMEM; memset(scc_ctrl, 0, size); for (k = 0; k < 16; k++) scc_irq_used[k] = 0; #ifdef CONFIG_PROC_FS scc_proc_table_header = register_sysctl_table(scc_proc_root_table, 1); #endif return 0; } /* ******************************************************************** */ /* * Module support * */ /* ******************************************************************** */ void __exit scc_cleanup_driver(void) { int k; for (k = 0; k < Nchips; k++) { scc_proc_remove_channel(scc_ctrl[k], &scc_ctrl[k]->channel_a); scc_proc_remove_channel(scc_ctrl[k], &scc_ctrl[k]->channel_b); scc_proc_remove_chip(scc_ctrl[k]); } #ifdef CONFIG_PROC_FS unregister_sysctl_table(scc_proc_table_header); proc_net_remove("z8530drv"); #endif kfree(scc_ctrl); } MODULE_AUTHOR("Joerg Reuter "); MODULE_DESCRIPTION("Network Device Driver for Z8530 based HDLC cards for Amateur Packet Radio"); MODULE_SUPPORTED_DEVICE("Z8530 based SCC cards without DMA support"); MODULE_PARM(maxchips, "i"); module_init(scc_init_driver); module_exit(scc_cleanup_driver);