// SPDX-License-Identifier: GPL-2.0-or-later /* * smc91x . c * This is a driver for SMSC ' s 91 C9x / 91 C1xx single - chip Ethernet devices . * * Copyright ( C ) 1996 by Erik Stahlman * Copyright ( C ) 2001 Standard Microsystems Corporation * Developed by Simple Network Magic Corporation * Copyright ( C ) 2003 Monta Vista Software , Inc . * Unified SMC91x driver by Nicolas Pitre * * Arguments : * io = for the base address * irq = for the IRQ * nowait = 0 for normal wait states , 1 eliminates additional wait states * * original author : * Erik Stahlman < erik @ vt . edu > * * hardware multicast code : * Peter Cammaert < pc @ denkart . be > * * contributors : * Daris A Nevil < dnevil @ snmc . com > * Nicolas Pitre < nico @ fluxnic . net > * Russell King < rmk @ arm . linux . org . uk > * * History : * 08 / 20 / 00 Arnaldo Melo fix kfree ( skb ) in smc_hardware_send_packet * 12 / 15 / 00 Christian Jullien fix " Warning : kfree_skb on hard IRQ " * 03 / 16 / 01 Daris A Nevil modified smc9194 . c for use with LAN91C111 * 08 / 22 / 01 Scott Anderson merge changes from smc9194 to smc91111 * 08 / 21 / 01 Pramod B Bhardwaj added support for RevB of LAN91C111 * 12 / 20 / 01 Jeff Sutherland initial port to Xscale PXA with DMA support * 04 / 07 / 03 Nicolas Pitre unified SMC91x driver , killed irq races , * more bus abstraction , big cleanup , etc . * 29 / 09 / 03 Russell King - add driver model support * - ethtool support * - convert to use generic MII interface * - add link up / down notification * - don ' t try to handle full negotiation in * smc_phy_configure * - clean up ( and fix stack overrun ) in PHY * MII read / write functions * 22 / 09 / 04 Nicolas Pitre big update ( see commit log for details ) static const char version[] ="smc91x.c: v1.1, sep 22 2004 by Nicolas Pitre <nico@fluxnic.net>" ;/* Debugging level */ #ifndef SMC_DEBUG#define SMC_DEBUG 0 #endif #include <linux/module.h>#include <linux/kernel.h>#include <linux/sched.h>#include <linux/delay.h>#include <linux/gpio/consumer.h>#include <linux/interrupt.h>#include <linux/irq.h>#include <linux/errno.h>#include <linux/ioport.h>#include <linux/crc32.h>#include <linux/platform_device.h>#include <linux/spinlock.h>#include <linux/ethtool.h>#include <linux/mii.h>#include <linux/workqueue.h>#include <linux/of.h>#include <linux/of_device.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/skbuff.h>#include <asm /io.h>#include "smc91x.h" #if defined (CONFIG_ASSABET_NEPONSET)#include <mach/assabet.h>#include <mach/neponset.h>#endif #ifndef SMC_NOWAIT# define SMC_NOWAIT 0 #endif static int nowait = SMC_NOWAIT;int , 0400 );"set to 1 for no wait state" );/* * Transmit timeout , default 5 seconds . static int watchdog = 1000 ;int , 0400 );"transmit timeout in milliseconds" );"SMC 91C9x/91C1xxx Ethernet driver" );"GPL" );"platform:smc91x" );/* * The internal workings of the driver . If you are changing anything * here with the SMC stuff , you should have the datasheet and know * what you are doing . #define CARDNAME "smc91x" /* * Use power - down feature of the chip #define POWER_DOWN 1 /* * Wait time for memory to be free . This probably shouldn ' t be * tuned that much , as waiting for this means nothing else happens * in the system #define MEMORY_WAIT_TIME 16 /* * The maximum number of processing loops allowed for each call to the * IRQ handler . #define MAX_IRQ_LOOPS 8 /* * This selects whether TX packets are sent one by one to the SMC91x internal * memory and throttled until transmission completes . This may prevent * RX overruns a litle by keeping much of the memory free for RX packets * but to the expense of reduced TX throughput and increased IRQ overhead . * Note this is not a cure for a too slow data bus or too high IRQ latency . #define THROTTLE_TX_PKTS 0 /* * The MII clock high / low times . 2 x this number gives the MII clock period * in microseconds . ( was 50 , but this gives 6 . 4 ms for each MII transaction ! ) #define MII_DELAY 1 #define DBG(n, dev, fmt, ...) \do { \if (SMC_DEBUG >= (n)) \## __VA_ARGS__); \while (0 )#define PRINTK(dev, fmt, ...) \do { \if (SMC_DEBUG > 0 ) \## __VA_ARGS__); \else \## __VA_ARGS__); \while (0 )#if SMC_DEBUG > 3 static void PRINT_PKT(u_char *buf, int length)int i;int remainder;int lines;16 ;16 ;for (i = 0 ; i < lines ; i ++) {int cur;for (cur = 0 ; cur < 8 ; cur++) {"%02x%02x " , a, b);"\n" );for (i = 0 ; i < remainder/2 ; i++) {"%02x%02x " , a, b);"\n" );#else static inline void PRINT_PKT(u_char *buf, int length) { }#endif /* this enables an interrupt in the interrupt mask register */ #define SMC_ENABLE_INT(lp, x) do { \unsigned char mask; \unsigned long smc_enable_flags; \while (0 )/* this disables an interrupt from the interrupt mask register */ #define SMC_DISABLE_INT(lp, x) do { \unsigned char mask; \unsigned long smc_disable_flags; \while (0 )/* * Wait while MMU is busy . This is usually in the order of a few nanosecs * if at all , but let ' s avoid deadlocking the system if the hardware * decides to go south . #define SMC_WAIT_MMU_BUSY(lp) do { \if (unlikely(SMC_GET_MMU_CMD(lp) & MC_BUSY)) { \unsigned long timeout = jiffies + 2 ; \while (SMC_GET_MMU_CMD(lp) & MC_BUSY) { \if (time_after(jiffies, timeout)) { \"timeout %s line %d\n" , \break ; \while (0 )/* * this does a soft reset on the device static void smc_reset(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int ctl, cfg;struct sk_buff *pending_skb;2 , dev, "%s\n" , __func__);/* Disable all interrupts, block TX tasklet */ 2 );0 );/* free any pending tx skb */ if (pending_skb) {/* * This resets the registers mostly to defaults , but doesn ' t * affect EEPROM . That seems unnecessary 0 );/* * Setup the Configuration Register * This is necessary because the CONFIG_REG is not affected * by a soft reset 1 );/* * Setup for fast accesses if requested . If the card / system * can ' t handle it then there will be no recovery except for * a hard reset or power cycle if (lp->cfg.flags & SMC91X_NOWAIT)/* * Release from possible power - down state * Configuration register is not affected by Soft Reset /* this should pause enough for the chip to be happy */ /* * elaborate ? What does the chip _ need_ ? - - jgarzik * * This seems to be undocumented , but something the original * driver ( s ) have always done . Suspect undocumented timing * info / determined empirically . - - rmk 1 );/* Disable transmit and receive functionality */ 0 );1 );/* * Set the control register to automatically release successfully * transmitted packets , to make the best use out of our limited * memory if (!THROTTLE_TX_PKTS)else /* Reset the MMU */ 2 );/* * Enable Interrupts , Receive , and Transmit static void smc_enable(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;int mask;2 , dev, "%s\n" , __func__);/* see the header file for options in TCR/RCR DEFAULT */ 0 );1 );/* now, enable interrupts */ if (lp->version >= (CHIP_91100 << 4 ))2 );/* * From this point the register bank must _ NOT_ be switched away * to something else than bank 2 without proper locking against * races with any tasklet or interrupt handlers until smc_shutdown ( ) * or smc_reset ( ) is called . /* * this puts the device in an inactive state static void smc_shutdown(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;struct sk_buff *pending_skb;2 , dev, "%s: %s\n" , CARDNAME, __func__);/* no more interrupts for me */ 2 );0 );/* and tell the card to stay away from that nasty outside world */ 0 );#ifdef POWER_DOWN/* finally, shut the chip down */ 1 );#endif /* * This is the procedure to handle the receipt of a packet . static inline void smc_rcv(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int packet_number, status, packet_len;3 , dev, "%s\n" , __func__);if (unlikely(packet_number & RXFIFO_REMPTY)) {"smc_rcv with nothing on FIFO.\n" );return ;/* read from start of packet */ /* First two words are status and packet length */ 0 x07ff; /* mask off top bits */ 2 , dev, "RX PNR 0x%x STATUS 0x%04x LENGTH 0x%04x (%d)\n" ,if (unlikely(packet_len < 6 || status & RS_ERRORS)) {if (status & RS_TOOLONG && packet_len <= (1514 + 4 + 6 )) {/* accept VLAN packets */ goto back;if (packet_len < 6 ) {/* bloody hardware */ "fubar (rxlen %u status %x\n" ,if (status & RS_ALGNERR)if (status & (RS_TOOSHORT | RS_TOOLONG))if (status & RS_BADCRC)else {struct sk_buff *skb;unsigned char *data;unsigned int data_len;/* set multicast stats */ if (status & RS_MULTICAST)/* * Actual payload is packet_len - 6 ( or 5 if odd byte ) . * We want skb_reserve ( 2 ) and the final ctrl word * ( 2 bytes , possibly containing the payload odd byte ) . * Furthermore , we add 2 bytes to allow rounding up to * multiple of 4 bytes on 32 bit buses . * Hence packet_len - 6 + 2 + 2 + 2 . if (unlikely(skb == NULL)) {return ;/* Align IP header to 32 bits */ 2 );/* BUG: the LAN91C111 rev A never sets this bit. Force it. */ if (lp->version == 0 x90)/* * If odd length : packet_len - 5 , * otherwise packet_len - 6 . * With the trailing ctrl byte it ' s packet_len - 4 . 5 : 6 );4 );4 );#ifdef CONFIG_SMP/* * On SMP we have the following problem : * * A = smc_hardware_send_pkt ( ) * B = smc_hard_start_xmit ( ) * C = smc_interrupt ( ) * * A and B can never be executed simultaneously . However , at least on UP , * it is possible ( and even desirable ) for C to interrupt execution of * A or B in order to have better RX reliability and avoid overruns . * C , just like A and B , must have exclusive access to the chip and * each of them must lock against any other concurrent access . * Unfortunately this is not possible to have C suspend execution of A or * B taking place on another CPU . On UP this is no an issue since A and B * are run from softirq context and C from hard IRQ context , and there is * no other CPU where concurrent access can happen . * If ever there is a way to force at least B and C to always be executed * on the same CPU then we could use read / write locks to protect against * any other concurrent access and C would always interrupt B . But life * isn ' t that easy in a SMP world . . . #define smc_special_trylock(lock, flags) \int __ret; \if (!__ret) \#define smc_special_lock(lock, flags) spin_lock_irqsave(lock, flags)#define smc_special_unlock(lock, flags) spin_unlock_irqrestore(lock, flags)#else #define smc_special_trylock(lock, flags) ((void )flags, true )#define smc_special_lock(lock, flags) do { flags = 0 ; } while (0 )#define smc_special_unlock(lock, flags) do { flags = 0 ; } while (0 )#endif /* * This is called to actually send a packet to the chip . static void smc_hardware_send_pkt(struct tasklet_struct *t)struct smc_local *lp = from_tasklet(lp, t, tx_task);struct net_device *dev = lp->dev;void __iomem *ioaddr = lp->base;struct sk_buff *skb;unsigned int packet_no, len;unsigned char *buf;unsigned long flags;3 , dev, "%s\n" , __func__);if (!smc_special_trylock(&lp->lock, flags)) {return ;if (unlikely(!skb)) {return ;if (unlikely(packet_no & AR_FAILED)) {"Memory allocation failed.\n" );goto done;/* point to the beginning of the packet */ 2 , dev, "TX PNR 0x%x LENGTH 0x%04x (%d) BUF 0x%p\n" ,/* * Send the packet length ( + 6 for status words , length , and ctl . * The card will pad to 64 bytes with zeroes if packet is too small . 0 , len + 6 );/* send the actual data */ 1 );/* Send final ctl word with the last byte if there is one */ 1 ) ? (0 x2000 | buf[len - 1 ]) : 0 ), ioaddr,/* * If THROTTLE_TX_PKTS is set , we stop the queue here . This will * have the effect of having at most one packet queued for TX * in the chip ' s memory at all time . * * If THROTTLE_TX_PKTS is not set then the queue is stopped only * when memory allocation ( MC_ALLOC ) does not succeed right away . if (THROTTLE_TX_PKTS)/* queue the packet for TX */ if (!THROTTLE_TX_PKTS)/* * Since I am not sure if I will have enough room in the chip ' s ram * to store the packet , I call this routine which either sends it * now , or set the card to generates an interrupt when ready * for the packet . static netdev_tx_tstruct sk_buff *skb, struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int numPages, poll_count, status;unsigned long flags;3 , dev, "%s\n" , __func__);/* * The MMU wants the number of pages to be the number of 256 bytes * ' pages ' , minus 1 ( since a packet can ' t ever have 0 pages : ) ) * * The 91 C111 ignores the size bits , but earlier models don ' t . * * Pkt size for allocating is data length + 6 ( for additional status * words , length and ctl ) * * If odd size then last byte is included in ctl word . 1 ) + (6 - 1 )) >> 8 ;if (unlikely(numPages > 7 )) {"Far too big packet error.\n" );return NETDEV_TX_OK;/* now, try to allocate the memory */ /* * Poll the chip for a short amount of time in case the * allocation succeeds quickly . do {if (status & IM_ALLOC_INT) {break ;while (--poll_count);if (!poll_count) {/* oh well, wait until the chip finds memory later */ 2 , dev, "TX memory allocation deferred.\n" );else {/* * Allocation succeeded : push packet to the chip ' s own memory * immediately . return NETDEV_TX_OK;/* * This handles a TX interrupt , which is only called when : * - a TX error occurred , or * - CTL_AUTO_RELEASE is not set and TX of a packet completed . static void smc_tx(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int saved_packet, packet_no, tx_status;unsigned int pkt_len __always_unused;3 , dev, "%s\n" , __func__);/* If the TX FIFO is empty then nothing to do */ if (unlikely(packet_no & TXFIFO_TEMPTY)) {"smc_tx with nothing on FIFO.\n" );return ;/* select packet to read from */ /* read the first word (status word) from this packet */ 2 , dev, "TX STATUS 0x%04x PNR 0x%02x\n" ,if (!(tx_status & ES_TX_SUC))if (tx_status & ES_LOSTCARR)if (tx_status & (ES_LATCOL | ES_16COL)) {"%s occurred on last xmit\n" ,"late collision" : "too many collisions" );if (!(dev->stats.tx_window_errors & 63 ) && net_ratelimit()) {"unexpectedly large number of bad collisions. Please check duplex setting.\n" );/* kill the packet */ /* Don't restore Packet Number Reg until busy bit is cleared */ /* re-enable transmit */ 0 );2 );/*---PHY CONTROL AND CONFIGURATION-----------------------------------------*/ static void smc_mii_out(struct net_device *dev, unsigned int val, int bits)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int mii_reg, mask;for (mask = 1 << (bits - 1 ); mask; mask >>= 1 ) {if (val & mask)else static unsigned int smc_mii_in(struct net_device *dev, int bits)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int mii_reg, mask, val;for (mask = 1 << (bits - 1 ), val = 0 ; mask; mask >>= 1 ) {if (SMC_GET_MII(lp) & MII_MDI)return val;/* * Reads a register from the MII Management serial interface static int smc_phy_read(struct net_device *dev, int phyaddr, int phyreg)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int phydata;3 );/* Idle - 32 ones */ 0 xffffffff, 32 );/* Start code (01) + read (10) + phyaddr + phyreg */ 6 << 10 | phyaddr << 5 | phyreg, 14 );/* Turnaround (2bits) + phydata */ 18 );/* Return to idle state */ 3 , dev, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n" ,2 );return phydata;/* * Writes a register to the MII Management serial interface static void smc_phy_write(struct net_device *dev, int phyaddr, int phyreg,int phydata)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;3 );/* Idle - 32 ones */ 0 xffffffff, 32 );/* Start code (01) + write (01) + phyaddr + phyreg + turnaround + phydata */ 5 << 28 | phyaddr << 23 | phyreg << 18 | 2 << 16 | phydata, 32 );/* Return to idle state */ 3 , dev, "%s: phyaddr=0x%x, phyreg=0x%x, phydata=0x%x\n" ,2 );/* * Finds and reports the PHY address static void smc_phy_detect(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);int phyaddr;2 , dev, "%s\n" , __func__);0 ;/* * Scan all 32 PHY addresses if necessary , starting at * PHY # 1 to PHY # 31 , and then PHY # 0 last . for (phyaddr = 1 ; phyaddr < 33 ; ++phyaddr) {unsigned int id1, id2;/* Read the PHY identifiers */ 31 , MII_PHYSID1);31 , MII_PHYSID2);3 , dev, "phy_id1=0x%x, phy_id2=0x%x\n" ,/* Make sure it is a valid identifier */ if (id1 != 0 x0000 && id1 != 0 xffff && id1 != 0 x8000 &&0 x0000 && id2 != 0 xffff && id2 != 0 x8000) {/* Save the PHY's address */ 31 ;16 | id2;break ;/* * Sets the PHY to a configuration as determined by the user static int smc_phy_fixed(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;int phyaddr = lp->mii.phy_id;int bmcr, cfg1;3 , dev, "%s\n" , __func__);/* Enter Link Disable state */ /* * Set our fixed capabilities * Disable auto - negotiation 0 ;if (lp->ctl_rfduplx)if (lp->ctl_rspeed == 100 )/* Write our capabilities to the phy control register */ /* Re-Configure the Receive/Phy Control register */ 0 );2 );return 1 ;/** * smc_phy_reset - reset the phy * @ dev : net device * @ phy : phy address * * Issue a software reset for the specified PHY and * wait up to 100 ms for the reset to complete . We should * not access the PHY for 50 ms after issuing the reset . * * The time to wait appears to be dependent on the PHY . * * Must be called with lp - > lock locked . static int smc_phy_reset(struct net_device *dev, int phy)struct smc_local *lp = netdev_priv(dev);unsigned int bmcr;int timeout;for (timeout = 2 ; timeout; timeout--) {50 );if (!(bmcr & BMCR_RESET))break ;return bmcr & BMCR_RESET;/** * smc_phy_powerdown - powerdown phy * @ dev : net device * * Power down the specified PHY static void smc_phy_powerdown(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);unsigned int bmcr;int phy = lp->mii.phy_id;if (lp->phy_type == 0 )return ;/* We need to ensure that no calls to smc_phy_configure are pending . /** * smc_phy_check_media - check the media status and adjust TCR * @ dev : net device * @ init : set true for initialisation * * Select duplex mode depending on negotiation state . This * also updates our carrier state . static void smc_phy_check_media(struct net_device *dev, int init)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;if (mii_check_media(&lp->mii, netif_msg_link(lp), init)) {/* duplex state has changed */ if (lp->mii.full_duplex) {else {0 );/* * Configures the specified PHY through the MII management interface * using Autonegotiation . * Calls smc_phy_fixed ( ) if the user has requested a certain config . * If RPC ANEG bit is set , the media selection is dependent purely on * the selection by the MII ( either in the MII BMCR reg or the result * of autonegotiation . ) If the RPC ANEG bit is cleared , the selection * is controlled by the RPC SPEED and RPC DPLX bits . static void smc_phy_configure(struct work_struct *work)struct smc_local *lp =struct smc_local, phy_configure);struct net_device *dev = lp->dev;void __iomem *ioaddr = lp->base;int phyaddr = lp->mii.phy_id;int my_phy_caps; /* My PHY capabilities */ int my_ad_caps; /* My Advertised capabilities */ 3 , dev, "smc_program_phy()\n" );/* * We should not be called if phy_type is zero . if (lp->phy_type == 0 )goto smc_phy_configure_exit;if (smc_phy_reset(dev, phyaddr)) {"PHY reset timed out\n" );goto smc_phy_configure_exit;/* * Enable PHY Interrupts ( for register 18 ) * Interrupts listed here are disabled /* Configure the Receive/Phy Control register */ 0 );/* If the user requested no auto neg, then go set his request */ if (lp->mii.force_media) {goto smc_phy_configure_exit;/* Copy our capabilities from MII_BMSR to MII_ADVERTISE */ if (!(my_phy_caps & BMSR_ANEGCAPABLE)) {"Auto negotiation NOT supported\n" );goto smc_phy_configure_exit;/* I am CSMA capable */ if (my_phy_caps & BMSR_100BASE4)if (my_phy_caps & BMSR_100FULL)if (my_phy_caps & BMSR_100HALF)if (my_phy_caps & BMSR_10FULL)if (my_phy_caps & BMSR_10HALF)/* Disable capabilities not selected by our user */ if (lp->ctl_rspeed != 100 )if (!lp->ctl_rfduplx)/* Update our Auto-Neg Advertisement Register */ /* * Read the register back . Without this , it appears that when * auto - negotiation is restarted , sometimes it isn ' t ready and * the link does not come up . 2 , dev, "phy caps=%x\n" , my_phy_caps);2 , dev, "phy advertised caps=%x\n" , my_ad_caps);/* Restart auto-negotiation process in order to advertise my caps */ 1 );2 );/* * smc_phy_interrupt * * Purpose : Handle interrupts relating to PHY register 18 . This is * called from the " hard " interrupt handler under our private spinlock . static void smc_phy_interrupt(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);int phyaddr = lp->mii.phy_id;int phy18;2 , dev, "%s\n" , __func__);if (lp->phy_type == 0 )return ;for (;;) {0 );/* Read PHY Register 18, Status Output */ if ((phy18 & PHY_INT_INT) == 0 )break ;/*--- END PHY CONTROL AND CONFIGURATION-------------------------------------*/ static void smc_10bt_check_media(struct net_device *dev, int init)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int old_carrier, new_carrier;1 : 0 ;0 );1 : 0 ;2 );if (init || (old_carrier != new_carrier)) {if (!new_carrier) {else {if (netif_msg_link(lp))"link %s\n" ,"up" : "down" );static void smc_eph_interrupt(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned int ctl;0 );1 );2 );/* * This is the main routine of the driver , to handle the device when * it needs some attention . static irqreturn_t smc_interrupt(int irq, void *dev_id)struct net_device *dev = dev_id;struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;int status, mask, timeout, card_stats;int saved_pointer;3 , dev, "%s\n" , __func__);/* A preamble may be used when there is a potential race * between the interruptible transmit functions and this 0 );/* set a timeout value, so I don't stay here forever */ do {2 , dev, "INT 0x%02x MASK 0x%02x MEM 0x%04x FIFO 0x%04x\n" ,int meminfo; SMC_SELECT_BANK(lp, 0 );2 ); meminfo; }),if (!status)break ;if (status & IM_TX_INT) {/* do this before RX as it will free memory quickly */ 3 , dev, "TX int\n" );if (THROTTLE_TX_PKTS)else if (status & IM_RCV_INT) {3 , dev, "RX irq\n" );else if (status & IM_ALLOC_INT) {3 , dev, "Allocation irq\n" );else if (status & IM_TX_EMPTY_INT) {3 , dev, "TX empty\n" );/* update stats */ 0 );2 );/* single collisions */ 0 xF;4 ;/* multiple collisions */ 0 xF;else if (status & IM_RX_OVRN_INT) {1 , dev, "RX overrun (EPH_ST 0x%04x)\n" ,int eph_st; SMC_SELECT_BANK(lp, 0 );2 ); eph_st; }));else if (status & IM_EPH_INT) {else if (status & IM_MDINT) {else if (status & IM_ERCV_INT) {"UNSUPPORTED: ERCV INTERRUPT\n" );while (--timeout);/* restore register states */ #ifndef CONFIG_NET_POLL_CONTROLLERif (timeout == MAX_IRQ_LOOPS)"spurious interrupt (mask = 0x%02x)\n" ,#endif 3 , dev, "Interrupt done (%d loops)\n" ,/* * We return IRQ_HANDLED unconditionally here even if there was * nothing to do . There is a possibility that a packet might * get enqueued into the chip right after TX_EMPTY_INT is raised * but just before the CPU acknowledges the IRQ . * Better take an unneeded IRQ in some occasions than complexifying * the code for all cases . return IRQ_HANDLED;#ifdef CONFIG_NET_POLL_CONTROLLER/* * Polling receive - used by netconsole and other diagnostic tools * to allow network i / o with interrupts disabled . static void smc_poll_controller(struct net_device *dev)#endif /* Our watchdog timed out. Called by the networking layer */ static void smc_timeout(struct net_device *dev, unsigned int txqueue)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;int status, mask, eph_st, meminfo, fifo;2 , dev, "%s\n" , __func__);0 );2 );"TX timeout (INT 0x%02x INTMASK 0x%02x MEM 0x%04x FIFO 0x%04x EPH_ST 0x%04x)\n" ,/* * Reconfiguring the PHY doesn ' t seem like a bad idea here , but * smc_phy_configure ( ) calls msleep ( ) which calls schedule_timeout ( ) * which calls schedule ( ) . Hence we use a work queue . if (lp->phy_type != 0 )/* We can accept TX packets again */ /* prevent tx timeout */ /* * This routine will , depending on the values passed to it , * either make it accept multicast packets , go into * promiscuous mode ( for TCPDUMP and cousins ) or accept * a select set of multicast packets static void smc_set_multicast_list(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;unsigned char multicast_table[8 ];int update_multicast = 0 ;2 , dev, "%s\n" , __func__);if (dev->flags & IFF_PROMISC) {2 , dev, "RCR_PRMS\n" );/* BUG? I never disable promiscuous mode if multicasting was turned on. Now , I turn off promiscuous mode , but I don ' t do anything to multicasting when promiscuous mode is turned on . /* * Here , I am setting this to accept all multicast packets . * I don ' t need to zero the multicast table , because the flag is * checked before the table is else if (dev->flags & IFF_ALLMULTI || netdev_mc_count(dev) > 16 ) {2 , dev, "RCR_ALMUL\n" );/* * This sets the internal hardware table to filter out unwanted * multicast packets before they take up memory . * * The SMC chip uses a hash table where the high 6 bits of the CRC of * address are the offset into the table . If that bit is 1 , then the * multicast packet is accepted . Otherwise , it ' s dropped silently . * * To use the 6 bits as an offset into the table , the high 3 bits are * the number of the 8 bit register , while the low 3 bits are the bit * within that register . else if (!netdev_mc_empty(dev)) {struct netdev_hw_addr *ha;/* table for flipping the order of 3 bits */ static const unsigned char invert3[] = {0 , 4 , 2 , 6 , 1 , 5 , 3 , 7 };/* start with a table of all zeros: reject all */ 0 , sizeof (multicast_table));int position;/* only use the low order bits */ 0 , ha->addr, 6 ) & 0 x3f;/* do some messy swapping to put the bit in the right spot */ 7 ]] |=1 <<invert3[(position>>3 )&7 ]);/* be sure I get rid of flags I might have set */ /* now, the table can be loaded into the chipset */ 1 ;else {2 , dev, "~(RCR_PRMS|RCR_ALMUL)\n" );/* * since I ' m disabling all multicast entirely , I need to * clear the multicast list 0 , sizeof (multicast_table));1 ;0 );if (update_multicast) {3 );2 );/* * Open and Initialize the board * * Set up everything , reset the card , etc . . static int struct net_device *dev)struct smc_local *lp = netdev_priv(dev);2 , dev, "%s\n" , __func__);/* Setup the default Register Modes */ /* * If we are not using a MII interface , we need to * monitor our own carrier signal to detect faults . if (lp->phy_type == 0 )/* reset the hardware */ /* Configure the PHY, initialize the link state */ if (lp->phy_type != 0 )else {1 );return 0 ;/* * smc_close * * this makes the board clean up everything that it can * and not talk to the outside world . Caused by * an ' ifconfig ethX down ' static int smc_close(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);2 , dev, "%s\n" , __func__);/* clear everything */ return 0 ;/* * Ethtool support static int struct net_device *dev,struct ethtool_link_ksettings *cmd)struct smc_local *lp = netdev_priv(dev);if (lp->phy_type != 0 ) {else {if (lp->ctl_rspeed == 10 )else if (lp->ctl_rspeed == 100 )0 ;return 0 ;static int struct net_device *dev,const struct ethtool_link_ksettings *cmd)struct smc_local *lp = netdev_priv(dev);int ret;if (lp->phy_type != 0 ) {else {if (cmd->base.autoneg != AUTONEG_DISABLE ||return -EINVAL;0 ;return ret;static void struct net_device *dev, struct ethtool_drvinfo *info)sizeof (info->driver));sizeof (info->version));sizeof (info->bus_info));static int smc_ethtool_nwayreset(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);int ret = -EINVAL;if (lp->phy_type != 0 ) {return ret;static u32 smc_ethtool_getmsglevel(struct net_device *dev)struct smc_local *lp = netdev_priv(dev);return lp->msg_enable;static void smc_ethtool_setmsglevel(struct net_device *dev, u32 level)struct smc_local *lp = netdev_priv(dev);static int smc_write_eeprom_word(struct net_device *dev, u16 addr, u16 word)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;/* load word into GP register */ 1 );/* set the address to put the data in EEPROM */ 2 );/* tell it to write */ 1 );/* wait for it to finish */ do {1 );while (SMC_GET_CTL(lp) & CTL_STORE);/* clean up */ 2 );return 0 ;static int smc_read_eeprom_word(struct net_device *dev, u16 addr, u16 *word)struct smc_local *lp = netdev_priv(dev);void __iomem *ioaddr = lp->base;/* set the EEPROM address to get the data from */ 2 );/* tell it to load */ 1 );0 xffff); /* init to known */ /* wait for it to finish */ do {1 );while (SMC_GET_CTL(lp) & CTL_RELOAD);/* read word from GP register */ /* clean up */ 2 );return 0 ;static int smc_ethtool_geteeprom_len(struct net_device *dev)return 0 x23 * 2 ;static int smc_ethtool_geteeprom(struct net_device *dev,struct ethtool_eeprom *eeprom, u8 *data)int i;int imax;1 , dev, "Reading %d bytes at %d(0x%x)\n" ,for (i = 0 ; i < eeprom->len; i += 2 ) {int ret;int offset = i + eeprom->offset;if (offset > imax)break ;1 , &wbuf);if (ret != 0 )return ret;2 , dev, "Read 0x%x from 0x%x\n" , wbuf, offset >> 1 );8 ) & 0 xff;1 ] = wbuf & 0 xff;return 0 ;static int smc_ethtool_seteeprom(struct net_device *dev,struct ethtool_eeprom *eeprom, u8 *data)int i;int imax;1 , dev, "Writing %d bytes to %d(0x%x)\n" ,for (i = 0 ; i < eeprom->len; i += 2 ) {int ret;int offset = i + eeprom->offset;if (offset > imax)break ;8 ) | data[i + 1 ];2 , dev, "Writing 0x%x to 0x%x\n" , wbuf, offset >> 1 );1 , wbuf);if (ret != 0 )return ret;return 0 ;static const struct ethtool_ops smc_ethtool_ops = {static const struct net_device_ops smc_netdev_ops = {#ifdef CONFIG_NET_POLL_CONTROLLER#endif /* * smc_findirq * * This routine has a simple purpose - - make the SMC chip generate an * interrupt , so an auto - detect routine can detect it , and find the IRQ , /* * does this still work ? * * I just deleted auto_irq . c , since it was never built . . . * - - jgarzik static int smc_findirq(struct smc_local *lp)void __iomem *ioaddr = lp->base;int timeout = 20 ;unsigned long cookie;2 , lp->dev, "%s: %s\n" , CARDNAME, __func__);/* * What I try to do here is trigger an ALLOC_INT . This is done * by allocating a small chunk of memory , which will give an interrupt * when done . /* enable ALLOCation interrupts ONLY */ 2 );/* * Allocate 512 bytes of memory . Note that the chip was just * reset so all the memory is available 1 );/* * Wait until positive that the interrupt has been generated do {int int_status;10 );if (int_status & IM_ALLOC_INT)break ; /* got the interrupt */ while (--timeout);/* * there is really nothing that I can do here if timeout fails , * as autoirq_report will return a 0 anyway , which is what I * want in this case . Plus , the clean up is needed in both * cases . /* and disable all interrupts again */ 0 );/* and return what I found */ return probe_irq_off(cookie);/* * Function : smc_probe ( unsigned long ioaddr ) * * Purpose : * Tests to see if a given ioaddr points to an SMC91x chip . * Returns a 0 on success * * Algorithm : * ( 1 ) see if the high byte of BANK_SELECT is 0 x33 * ( 2 ) compare the ioaddr with the base register ' s address * ( 3 ) see if I recognize the chip ID in the appropriate register * * Here I do typical initialization tasks . * * o Initialize the structure if needed * o print out my vanity message if not done so already * o print out what type of hardware is detected * o print out the ethernet address * o find the IRQ * o set up my private data * o configure the dev structure with my subroutines * o actually GRAB the irq . * o GRAB the region static int smc_probe(struct net_device *dev, void __iomem *ioaddr,unsigned long irq_flags)struct smc_local *lp = netdev_priv(dev);int retval;unsigned int val, revision_register;const char *version_string;2 , dev, "%s: %s\n" , CARDNAME, __func__);/* First, see if the high byte is 0x33 */ 2 , dev, "%s: bank signature probe returned 0x%04x\n" ,if ((val & 0 xFF00) != 0 x3300) {if ((val & 0 xFF) == 0 x33) {"%s: Detected possible byte-swapped interface at IOADDR %p\n" ,goto err_out;/* * The above MIGHT indicate a device , but I need to write to * further test this . 0 );if ((val & 0 xFF00) != 0 x3300) {goto err_out;/* * well , we ' ve already written once , so hopefully another * time won ' t hurt . This time , I need to switch the bank * register to bank 1 , so I can access the base address * register 1 );0 x1F00) >> 3 ) << SMC_IO_SHIFT;if (((unsigned long )ioaddr & (0 x3e0 << SMC_IO_SHIFT)) != val) {"%s: IOADDR %p doesn't match configuration (%x).\n" ,/* * check if the revision register is something that I * recognize . These might need to be added to later , * as future revisions could be added . 3 );2 , dev, "%s: revision = 0x%04x\n" , CARDNAME, revision_register);4 ) & 0 xF];if (!version_string || (revision_register & 0 xff00) != 0 x3300) {/* I don't recognize this chip, so... */ "%s: IO %p: Unrecognized revision register 0x%04x, Contact author.\n" ,goto err_out;/* At this point I'll assume that the chip is an SMC91x. */ "%s\n" , version);/* fill in some of the fields */ unsigned long )ioaddr;0 xff;/* Get the MAC address */ 1 );/* now, reset the chip, and put it into a known state */ /* * If dev - > irq is 0 , then the device has to be banged on to see * what the IRQ is . * * This banging doesn ' t always detect the IRQ , for unknown reasons . * a workaround is to reset the chip and try again . * * Interestingly , the DOS packet driver * SETS * the IRQ on the card to * be what is requested on the command line . I don ' t do that , mostly * because the card that I have uses a non - standard method of accessing * the IRQs , and because this _ should_ work in most configurations . * * Specifying an IRQ is done with the assumption that the user knows * what ( s ) he is doing . No checking is done ! ! ! ! if (dev->irq < 1 ) {int trials;3 ;while (trials--) {if (dev->irq)break ;/* kick the card and try again */ if (dev->irq == 0 ) {"Couldn't autodetect your IRQ. Use irq=xx.\n" );goto err_out;0 x1f;0 x1f;0 ;0 ;/* * Locate the phy , if any . if (lp->version >= (CHIP_91100 << 4 ))/* then shut everything down to save power */ /* Set default parameters */ 0 ;10 ;if (lp->version >= (CHIP_91100 << 4 )) {1 ;100 ;/* Grab the IRQ */ if (retval)goto err_out;#ifdef CONFIG_ARCH_PXA# ifdef SMC_USE_PXA_DMA# endifif (lp->cfg.flags & SMC91X_USE_DMA) {#endif if (retval == 0 ) {/* now, print out the card info, in a short format.. */ "%s (rev %d) at %p IRQ %d" ,0 x0f,if (lp->dma_chan)" DMA %p" , lp->dma_chan);"%s%s\n" ," [nowait]" : "" ," [throttle_tx]" : "" );if (!is_valid_ether_addr(dev->dev_addr)) {"Invalid ethernet MAC address. Please set using ifconfig\n" );else {/* Print the Ethernet address */ "Ethernet addr: %pM\n" ,if (lp->phy_type == 0 ) {"No PHY found\n" );else if ((lp->phy_type & 0 xfffffff0) == 0 x0016f840) {"PHY LAN83C183 (LAN91C111 Internal)\n" );else if ((lp->phy_type & 0 xfffffff0) == 0 x02821c50) {"PHY LAN83C180\n" );#ifdef CONFIG_ARCH_PXAif (retval && lp->dma_chan)#endif return retval;static int smc_enable_device(struct platform_device *pdev)struct net_device *ndev = platform_get_drvdata(pdev);struct smc_local *lp = netdev_priv(ndev);unsigned long flags;unsigned char ecor, ecsr;void __iomem *addr;struct resource * res;"smc91x-attrib" );if (!res)return 0 ;/* * Map the attribute space . This is overkill , but clean . if (!addr)return -ENOMEM;/* * Reset the device . We must disable IRQs around this * since a reset causes the IRQ line become active . /* * Wait 100 us for the chip to reset . 100 );/* * The device will ignore all writes to the enable bit while * reset is asserted , even if the reset bit is cleared in the * same write . Must clear reset first , then enable the device . /* * Set the appropriate byte / word mode . if (!SMC_16BIT(lp))/* * Wait for the chip to wake up . We could poll the control * register in the main register space , but that isn ' t mapped * yet . We know this is going to take 750 us . 1 );return 0 ;static int smc_request_attrib(struct platform_device *pdev,struct net_device *ndev)struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-attrib" );struct smc_local *lp __maybe_unused = netdev_priv(ndev);if (!res)return 0 ;if (!request_mem_region(res->start, ATTRIB_SIZE, CARDNAME))return -EBUSY;return 0 ;static void smc_release_attrib(struct platform_device *pdev,struct net_device *ndev)struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-attrib" );struct smc_local *lp __maybe_unused = netdev_priv(ndev);if (res)static inline void smc_request_datacs(struct platform_device *pdev, struct net_device *ndev)if (SMC_CAN_USE_DATACS) {struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-data32" );struct smc_local *lp = netdev_priv(ndev);if (!res)return ;if (!request_mem_region(res->start, SMC_DATA_EXTENT, CARDNAME)) {"%s: failed to request datacs memory region.\n" ,return ;static void smc_release_datacs(struct platform_device *pdev, struct net_device *ndev)if (SMC_CAN_USE_DATACS) {struct smc_local *lp = netdev_priv(ndev);struct resource * res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smc91x-data32" );if (lp->datacs)if (res)static const struct acpi_device_id smc91x_acpi_match[] = {"LNRO0003" , 0 },#if IS_BUILTIN(CONFIG_OF)static const struct of_device_id smc91x_match[] = {"smsc,lan91c94" , },"smsc,lan91c111" , },/** * try_toggle_control_gpio - configure a gpio if it exists * @ dev : net device * @ desc : where to store the GPIO descriptor , if it exists * @ name : name of the GPIO in DT * @ index : index of the GPIO in DT * @ value : set the GPIO to this value * @ nsdelay : delay before setting the GPIO static int try_toggle_control_gpio(struct device *dev,struct gpio_desc **desc,const char *name, int index,int value, unsigned int nsdelay)struct gpio_desc *gpio;enum gpiod_flags flags = value ? GPIOD_OUT_LOW : GPIOD_OUT_HIGH;if (IS_ERR(gpio))return PTR_ERR(gpio);if (gpio) {if (nsdelay)2 * nsdelay);return 0 ;#endif /* * smc_init ( void ) * Input parameters : * dev - > base_addr = = 0 , try to find all possible locations * dev - > base_addr > 0 x1ff , this is the address to check * dev - > base_addr = = < anything else > , return failure code * * Output : * 0 - - > there is a device * anything else , error static int smc_drv_probe(struct platform_device *pdev)struct smc91x_platdata *pd = dev_get_platdata(&pdev->dev);const struct of_device_id *match = NULL;struct smc_local *lp;struct net_device *ndev;struct resource *res;unsigned int __iomem *addr;unsigned long irq_flags = SMC_IRQ_FLAGS;unsigned long irq_resflags;int ret;sizeof (struct smc_local));if (!ndev) {goto out;/* get configuration from platform data, only allow use of * bus width if both SMC_CAN_USE_xxx and SMC91X_USE_xxx are set . 0 ;if (pd) {sizeof (lp->cfg));if (!SMC_8BIT(lp) && !SMC_16BIT(lp)) {"at least one of 8-bit or 16-bit access support is required.\n" );goto out_free_netdev;#if IS_BUILTIN(CONFIG_OF)if (match) {/* Optional pwrdwn GPIO configured? */ "power" , 0 , 0 , 100 );if (ret)goto out_free_netdev;/* * Optional reset GPIO configured ? Minimum 100 ns reset needed * according to LAN91C96 datasheet page 14 . "reset" , 0 , 0 , 100 );if (ret)goto out_free_netdev;/* * Need to wait for optional EEPROM to load , max 750 us according * to LAN91C96 datasheet page 55 . if (lp->reset_gpio)750 , 1000 );/* Combination of IO widths supported, default to 16-bit */ if (!device_property_read_u32(&pdev->dev, "reg-io-width" ,if (val & 1 )if ((val == 0 ) || (val & 2 ))if (val & 4 )else {if (!device_property_read_u32(&pdev->dev, "reg-shift" ,"pxa-u16-align4" );#endif if (!pd && !match) {0 ;0 ;0 ;0 ;if (!lp->cfg.leda && !lp->cfg.ledb) {unsigned char )-1 ;"smc91x-regs" );if (!res)0 );if (!res) {goto out_free_netdev;if (!request_mem_region(res->start, SMC_IO_EXTENT, CARDNAME)) {goto out_free_netdev;0 );if (ndev->irq < 0 ) {goto out_release_io;/* * If this platform does not specify any special irqflags , or if * the resource supplies a trigger , override the irqflags with * the trigger flags from the resource . if (irq_flags == -1 || irq_resflags & IRQF_TRIGGER_MASK)if (ret)goto out_release_io;#if defined (CONFIG_ASSABET_NEPONSET)if (machine_is_assabet() && machine_has_neponset())#endif if (ret)goto out_release_attrib;if (!addr) {goto out_release_attrib;#ifdef CONFIG_ARCH_PXAstruct smc_local *lp = netdev_priv(ndev);#endif if (ret != 0 )goto out_iounmap;return 0 ;"%s: not found (%d).\n" , CARDNAME, ret);return ret;static void smc_drv_remove(struct platform_device *pdev)struct net_device *ndev = platform_get_drvdata(pdev);struct smc_local *lp = netdev_priv(ndev);struct resource *res;#ifdef CONFIG_ARCH_PXAif (lp->dma_chan)#endif "smc91x-regs" );if (!res)0 );static int smc_drv_suspend(struct device *dev)struct net_device *ndev = dev_get_drvdata(dev);if (ndev) {if (netif_running(ndev)) {return 0 ;static int smc_drv_resume(struct device *dev)struct platform_device *pdev = to_platform_device(dev);struct net_device *ndev = platform_get_drvdata(pdev);if (ndev) {struct smc_local *lp = netdev_priv(ndev);if (netif_running(ndev)) {if (lp->phy_type != 0 )return 0 ;static const struct dev_pm_ops smc_drv_pm_ops = {static struct platform_driver smc_driver = {
Messung V0.5 in Prozent C=94 H=84 G=88
¤ Dauer der Verarbeitung: 0.91 Sekunden
(vorverarbeitet am 2026-09-28)
¤ *© Formatika GbR, Deutschland
