/******************************************************************************* * * Linux ThunderLAN Driver * * tlan . c * by James Banks * * ( C ) 1997 - 1998 Caldera , Inc . * ( C ) 1998 James Banks * ( C ) 1999 - 2001 Torben Mathiasen * ( C ) 2002 Samuel Chessman * * This software may be used and distributed according to the terms * of the GNU General Public License , incorporated herein by reference . * * * Useful ( if not required ) reading : * * Texas Instruments , ThunderLAN Programmer ' s Guide , * TI Literature Number SPWU013A * available in PDF format from www . ti . com * Level One , LXT901 and LXT970 Data Sheets * available in PDF format from www . level1 . com * National Semiconductor , DP83840A Data Sheet * available in PDF format from www . national . com * Microchip Technology , 24 C01A / 02 A / 04 A Data Sheet * available in PDF format from www . microchip . com * #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt#include <linux/hardirq.h>#include <linux/module.h>#include <linux/init.h>#include <linux/interrupt.h>#include <linux/ioport.h>#include <linux/eisa.h>#include <linux/pci.h>#include <linux/dma-mapping.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/delay.h>#include <linux/spinlock.h>#include <linux/workqueue.h>#include <linux/mii.h>#include "tlan.h" /* For removing EISA devices */ static struct net_device *tlan_eisa_devices;static int tlan_devices_installed;/* Set speed, duplex and aui settings */ static int aui[MAX_TLAN_BOARDS];static int duplex[MAX_TLAN_BOARDS];static int speed[MAX_TLAN_BOARDS];static int boards_found;int , NULL, 0 );int , NULL, 0 );int , NULL, 0 );"ThunderLAN use AUI port(s) (0-1)" );"ThunderLAN duplex setting(s) (0-default, 1-half, 2-full)" );"ThunderLAN port speed setting(s) (0,10,100)" );"Maintainer: Samuel Chessman <chessman@tux.org>" );"Driver for TI ThunderLAN based ethernet PCI adapters" );"GPL" );/* Turn on debugging. * See Documentation / networking / device_drivers / ethernet / ti / tlan . rst for details static int debug;int , 0 );"ThunderLAN debug mask" );static const char tlan_signature[] = "TLAN" ;static const char tlan_banner[] = "ThunderLAN driver v1.17\n" ;static int tlan_have_pci;static int tlan_have_eisa;static const char * const media[] = {"10BaseT-HD" , "10BaseT-FD" , "100baseTx-HD" ,"100BaseTx-FD" , "100BaseT4" , NULLstatic struct board {const char *device_label;"Compaq Netelligent 10 T PCI UTP" , TLAN_ADAPTER_ACTIVITY_LED, 0 x83 },"Compaq Netelligent 10/100 TX PCI UTP" ,0 x83 },"Compaq Integrated NetFlex-3/P" , TLAN_ADAPTER_NONE, 0 x83 },"Compaq NetFlex-3/P" ,0 x83 },"Compaq NetFlex-3/P" , TLAN_ADAPTER_NONE, 0 x83 },"Compaq Netelligent Integrated 10/100 TX UTP" ,0 x83 },"Compaq Netelligent Dual 10/100 TX PCI UTP" ,0 x83 },"Compaq Netelligent 10/100 TX Embedded UTP" ,0 x83 },"Olicom OC-2183/2185" , TLAN_ADAPTER_USE_INTERN_10, 0 x83 },"Olicom OC-2325" , TLAN_ADAPTER_ACTIVITY_LED |0 xf8 },"Olicom OC-2326" , TLAN_ADAPTER_ACTIVITY_LED |0 xf8 },"Compaq Netelligent 10/100 TX UTP" , TLAN_ADAPTER_ACTIVITY_LED, 0 x83 },"Compaq Netelligent 10 T/2 PCI UTP/coax" , TLAN_ADAPTER_NONE, 0 x83 },"Compaq NetFlex-3/E" ,/* EISA card */ 0 x83 },"Compaq NetFlex-3/E" ,0 x83 }, /* EISA card */ static const struct pci_device_id tlan_pci_tbl[] = {0 , 0 , 0 },0 , 0 , 1 },0 , 0 , 2 },0 , 0 , 3 },0 , 0 , 4 },0 , 0 , 5 },0 , 0 , 6 },0 , 0 , 7 },0 , 0 , 8 },0 , 0 , 9 },0 , 0 , 10 },0 , 0 , 11 },0 , 0 , 12 },0 ,}static void tlan_eisa_probe(void );static void tlan_eisa_cleanup(void );static int tlan_init(struct net_device *);static int tlan_open(struct net_device *dev);static netdev_tx_t tlan_start_tx(struct sk_buff *, struct net_device *);static irqreturn_t tlan_handle_interrupt(int , void *);static int tlan_close(struct net_device *);static struct net_device_stats *tlan_get_stats(struct net_device *);static void tlan_set_multicast_list(struct net_device *);static int tlan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);static int tlan_probe1(struct pci_dev *pdev, long ioaddr,int irq, int rev, const struct pci_device_id *ent);static void tlan_tx_timeout(struct net_device *dev, unsigned int txqueue);static void tlan_tx_timeout_work(struct work_struct *work);static int tlan_init_one(struct pci_dev *pdev,const struct pci_device_id *ent);static u32 tlan_handle_tx_eof(struct net_device *, u16);static u32 tlan_handle_stat_overflow(struct net_device *, u16);static u32 tlan_handle_rx_eof(struct net_device *, u16);static u32 tlan_handle_dummy(struct net_device *, u16);static u32 tlan_handle_tx_eoc(struct net_device *, u16);static u32 tlan_handle_status_check(struct net_device *, u16);static u32 tlan_handle_rx_eoc(struct net_device *, u16);static void tlan_timer(struct timer_list *t);static void tlan_phy_monitor(struct timer_list *t);static void tlan_reset_lists(struct net_device *);static void tlan_free_lists(struct net_device *);static void tlan_print_dio(u16);static void tlan_print_list(struct tlan_list *, char *, int );static void tlan_read_and_clear_stats(struct net_device *, int );static void tlan_reset_adapter(struct net_device *);static void tlan_finish_reset(struct net_device *);static void tlan_set_mac(struct net_device *, int areg, const char *mac);static void __tlan_phy_print(struct net_device *);static void tlan_phy_print(struct net_device *);static void tlan_phy_detect(struct net_device *);static void tlan_phy_power_down(struct net_device *);static void tlan_phy_power_up(struct net_device *);static void tlan_phy_reset(struct net_device *);static void tlan_phy_start_link(struct net_device *);static void tlan_phy_finish_auto_neg(struct net_device *);/* static int tlan_phy_nop ( struct net_device * ) ; static int tlan_phy_internal_check ( struct net_device * ) ; static int tlan_phy_internal_service ( struct net_device * ) ; static int tlan_phy_dp83840a_check ( struct net_device * ) ; static bool __tlan_mii_read_reg(struct net_device *, u16, u16, u16 *);static void tlan_mii_read_reg(struct net_device *, u16, u16, u16 *);static void tlan_mii_send_data(u16, u32, unsigned );static void tlan_mii_sync(u16);static void __tlan_mii_write_reg(struct net_device *, u16, u16, u16);static void tlan_mii_write_reg(struct net_device *, u16, u16, u16);static void tlan_ee_send_start(u16);static int tlan_ee_send_byte(u16, u8, int );static void tlan_ee_receive_byte(u16, u8 *, int );static int tlan_ee_read_byte(struct net_device *, u8, u8 *);static inline void struct tlan_list *tag, struct sk_buff *skb)unsigned long addr = (unsigned long )skb;9 ].address = addr;8 ].address = upper_32_bits(addr);static inline struct sk_buff *const struct tlan_list *tag)unsigned long addr;9 ].address;unsigned long ) tag->buffer[8 ].address << 16 ) << 16 ;return (struct sk_buff *) addr;static u32struct net_device *, u16) = {static void struct net_device *dev, u32 ticks, u32 type)struct tlan_priv *priv = netdev_priv(dev);unsigned long flags = 0 ;if (priv->timer.function != NULL &&return ;/****************************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ThunderLAN driver primary functions these functions are more or less common to all linux network drivers . * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /*************************************************************** * tlan_remove_one * * Returns : * Nothing * Parms : * None * * Goes through the TLanDevices list and frees the device * structs and memory associated with each device ( lists * and buffers ) . It also ureserves the IO port regions * associated with this device . * static void tlan_remove_one(struct pci_dev *pdev)struct net_device *dev = pci_get_drvdata(pdev);struct tlan_priv *priv = netdev_priv(dev);if (priv->dma_storage) {#ifdef CONFIG_PCI#endif static void tlan_start(struct net_device *dev)/* NOTE: It might not be necessary to read the stats before a reset if you don ' t care what the values are . static void tlan_stop(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);/* Reset and power down phy */ if (priv->timer.function != NULL) {static int __maybe_unused tlan_suspend(struct device *dev_d)struct net_device *dev = dev_get_drvdata(dev_d);if (netif_running(dev))return 0 ;static int __maybe_unused tlan_resume(struct device *dev_d)struct net_device *dev = dev_get_drvdata(dev_d);if (netif_running(dev))return 0 ;static SIMPLE_DEV_PM_OPS(tlan_pm_ops, tlan_suspend, tlan_resume);static struct pci_driver tlan_driver = {"tlan" ,static int __init tlan_probe(void )int rc = -ENODEV;"%s" , tlan_banner);"Starting PCI Probe....\n" );/* Use new style PCI probing. Now the kernel will if (rc != 0 ) {"Could not register pci driver\n" );goto err_out_pci_free;"Starting EISA Probe....\n" );"%d device%s installed, PCI: %d EISA: %d\n" ,1 ? "" : "s" ,if (tlan_devices_installed == 0 ) {goto err_out_pci_unreg;return 0 ;return rc;static int tlan_init_one(struct pci_dev *pdev,const struct pci_device_id *ent)return tlan_probe1(pdev, -1 , -1 , 0 , ent);/** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * tlan_probe1 * * Returns : * 0 on success , error code on error * Parms : * none * * The name is lower case to fit in with all the rest of * the netcard_probe names . This function looks for * another TLan based adapter , setting it up with the * allocated device struct if one is found . * tlan_probe has been ported to the new net API and * now allocates its own device structure . This function * is also used by modules . * static int tlan_probe1(struct pci_dev *pdev, long ioaddr, int irq, int rev,const struct pci_device_id *ent)struct net_device *dev;struct tlan_priv *priv;int reg, rc = -ENODEV;#ifdef CONFIG_PCIif (pdev) {if (rc)return rc;if (rc) {"Could not reserve IO regions\n" );goto err_out;#endif /* CONFIG_PCI */ sizeof (struct tlan_priv));if (dev == NULL) {goto err_out_regions;/* Is this a PCI device? */ if (pdev) {0 ;32 ));if (rc) {"No suitable PCI mapping available\n" );goto err_out_free_dev;for (reg = 0 ; reg <= 5 ; reg++) {if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {"IO mapping is available at %x.\n" ,break ;if (!pci_io_base) {"No IO mappings available\n" );goto err_out_free_dev;else { /* EISA card */ /* This is a hack. We need to know which board structure if (device_id == 0 x20F1) {13 ]; /* NetFlex-3/E */ 23 ; /* TLAN 2.3 */ else {14 ];10 ; /* TLAN 1.0 */ /* Kernel parameters */ if (dev->mem_start) {0 x01;0 x06) == 0 x06) ? 0 0 x06) >> 1 ;0 x18) == 0 x18) ? 0 0 x18) >> 3 ;if (priv->speed == 0 x1)else if (priv->speed == 0 x2)else {/* This will be used when we get an adapter error from if (rc) {"Could not set up device\n" );goto err_out_free_dev;if (rc) {"Could not register device\n" );goto err_out_uninit;/* pdev is NULL if this is an EISA device */ if (pdev)else {"irq=%2d, io=%04x, %s, Rev. %d\n" ,int )dev->irq,int )dev->base_addr,return 0 ;#ifdef CONFIG_PCIif (pdev)#endif if (pdev)return rc;static void tlan_eisa_cleanup(void )struct net_device *dev;struct tlan_priv *priv;while (tlan_have_eisa) {if (priv->dma_storage) {0 x10);static void __exit tlan_exit(void )if (tlan_have_eisa)/* Module loading/unloading */ /************************************************************** * tlan_eisa_probe * * Returns : 0 on success , 1 otherwise * * Parms : None * * * This functions probes for EISA devices and calls * TLan_probe1 when one is found . * static void __init tlan_eisa_probe(void )long ioaddr;int irq;if (!EISA_bus) {"No EISA bus present\n" );return ;/* Loop through all slots of the EISA bus */ for (ioaddr = 0 x1000; ioaddr < 0 x9000; ioaddr += 0 x1000) {"EISA_ID 0x%4x: 0x%4x\n" ,int ) ioaddr + 0 xc80, inw(ioaddr + EISA_ID));"EISA_ID 0x%4x: 0x%4x\n" ,int ) ioaddr + 0 xc82, inw(ioaddr + EISA_ID2));"Probing for EISA adapter at IO: 0x%4x : " ,int ) ioaddr);if (request_region(ioaddr, 0 x10, tlan_signature) == NULL)goto out;if (inw(ioaddr + EISA_ID) != 0 x110E) {0 x10);goto out;if (device_id != 0 x20F1 && device_id != 0 x40F1) {0 x10);goto out;/* check if adapter is enabled */ if (inb(ioaddr + EISA_CR) != 0 x1) {0 x10);goto out2;if (debug == 0 x10)"Found one\n" );/* Get irq from board */ switch (inb(ioaddr + 0 xcc0)) {case (0 x10):5 ;break ;case (0 x20):9 ;break ;case (0 x40):10 ;break ;case (0 x80):11 ;break ;default :goto out;/* Setup the newly found eisa adapter */ 12 , NULL);continue ;if (debug == 0 x10)"None found\n" );continue ;if (debug == 0 x10)"Card found but it is not enabled, skipping\n" );continue ;#ifdef CONFIG_NET_POLL_CONTROLLERstatic void tlan_poll(struct net_device *dev)#endif static const struct net_device_ops tlan_netdev_ops = {#ifdef CONFIG_NET_POLL_CONTROLLER#endif static void tlan_get_drvinfo(struct net_device *dev,struct ethtool_drvinfo *info)struct tlan_priv *priv = netdev_priv(dev);sizeof (info->driver));if (priv->pci_dev)sizeof (info->bus_info));else "EISA" , sizeof (info->bus_info));static int tlan_get_eeprom_len(struct net_device *dev)return TLAN_EEPROM_SIZE;static int tlan_get_eeprom(struct net_device *dev,struct ethtool_eeprom *eeprom, u8 *data)int i;for (i = 0 ; i < TLAN_EEPROM_SIZE; i++)if (tlan_ee_read_byte(dev, i, &data[i]))return -EIO;return 0 ;static const struct ethtool_ops tlan_ethtool_ops = {/*************************************************************** * tlan_init * * Returns : * 0 on success , error code otherwise . * Parms : * dev The structure of the device to be * init ' ed . * * This function completes the initialization of the * device structure and driver . It reserves the IO * addresses , allocates memory for the lists and bounce * buffers , retrieves the MAC address from the eeprom * and assignes the device ' s methods . * static int tlan_init(struct net_device *dev)int dma_size;int err;int i;struct tlan_priv *priv;sizeof (struct tlan_list));if (priv->dma_storage == NULL) {"Could not allocate lists and buffers for %s\n" ,return -ENOMEM;struct tlan_list *)unsigned long )priv->dma_storage, 8 );8 );sizeof (struct tlan_list)*TLAN_NUM_RX_LISTS;0 ;for (i = 0 ; i < ETH_ALEN; i++)if (err) {"%s: Error reading MAC from eeprom: %d\n" ,/* Olicom OC-2325/OC-2326 have the address byte-swapped */ if (priv->adapter->addr_ofs == 0 xf8) {for (i = 0 ; i < ETH_ALEN; i += 2 ) {char tmp = addr[i];1 ];1 ] = tmp;/* Device methods */ return 0 ;/*************************************************************** * tlan_open * * Returns : * 0 on success , error code otherwise . * Parms : * dev Structure of device to be opened . * * This routine puts the driver and TLAN adapter in a * state where it is ready to send and receive packets . * It allocates the IRQ , resets and brings the adapter * out of reset , and allows interrupts . It also delays * the startup for autonegotiation or sends a Rx GO * command to the adapter , as appropriate . * static int tlan_open(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);int err;if (err) {"Cannot open because IRQ %d is already in use\n" ,return err;0 );0 );"%s: Opened. TLAN Chip Rev: %x\n" ,return 0 ;/************************************************************** * tlan_ioctl * * Returns : * 0 on success , error code otherwise * Params : * dev structure of device to receive ioctl . * * rq ifreq structure to hold userspace data . * * cmd ioctl command . * * static int tlan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)struct tlan_priv *priv = netdev_priv(dev);struct mii_ioctl_data *data = if_mii(rq);if (!priv->phy_online)return -EAGAIN;switch (cmd) {case SIOCGMIIPHY: /* get address of MII PHY in use. */ case SIOCGMIIREG: /* read MII PHY register. */ 0 x1f,0 x1f, &data->val_out);return 0 ;case SIOCSMIIREG: /* write MII PHY register. */ 0 x1f,0 x1f, data->val_in);return 0 ;default :return -EOPNOTSUPP;/*************************************************************** * tlan_tx_timeout * * Returns : nothing * * Params : * dev structure of device which timed out * during transmit . * static void tlan_tx_timeout(struct net_device *dev, unsigned int txqueue)"%s: Transmit timed out.\n" , dev->name);/* Ok so we timed out, lets see what we can do about it...*/ /* prevent tx timeout */ /*************************************************************** * tlan_tx_timeout_work * * Returns : nothing * * Params : * work work item of device which timed out * static void tlan_tx_timeout_work(struct work_struct *work)struct tlan_priv *priv =struct tlan_priv, tlan_tqueue);/*************************************************************** * tlan_start_tx * * Returns : * 0 on success , non - zero on failure . * Parms : * skb A pointer to the sk_buff containing the * frame to be sent . * dev The device to send the data on . * * This function adds a frame to the Tx list to be sent * ASAP . First it verifies that the adapter is ready and * there is room in the queue . Then it sets up the next * available list , copies the frame to the corresponding * buffer . If the adapter Tx channel is idle , it gives * the adapter a Tx Go command on the list , otherwise it * sets the forward address of the previous list to point * to this one . Then it frees the sk_buff . * static netdev_tx_t tlan_start_tx(struct sk_buff *skb, struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);struct tlan_list *tail_list;unsigned long flags;unsigned int txlen;if (!priv->phy_online) {"TRANSMIT: %s PHY is not ready\n" ,return NETDEV_TX_OK;if (skb_padto(skb, TLAN_MIN_FRAME_SIZE))return NETDEV_TX_OK;unsigned int )TLAN_MIN_FRAME_SIZE);sizeof (struct tlan_list)*priv->tx_tail;if (tail_list->c_stat != TLAN_CSTAT_UNUSED) {"TRANSMIT: %s is busy (Head=%d Tail=%d)\n" ,return NETDEV_TX_BUSY;0 ;0 ].address = dma_map_single(&priv->pci_dev->dev,0 ].count = TLAN_LAST_BUFFER | (u32) txlen;1 ].count = 0 ;1 ].address = 0 ;if (!priv->tx_in_progress) {1 ;"TRANSMIT: Starting TX on buffer %d\n" ,else {"TRANSMIT: Adding buffer %d to TX channel\n" ,if (priv->tx_tail == 0 ) {1 ))->forwardelse {1 ))->forwardreturn NETDEV_TX_OK;/*************************************************************** * tlan_handle_interrupt * * Returns : * Nothing * Parms : * irq The line on which the interrupt * occurred . * dev_id A pointer to the device assigned to * this irq line . * * This function handles an interrupt generated by its * assigned TLAN adapter . The function deactivates * interrupts on its adapter , records the type of * interrupt , executes the appropriate subhandler , and * acknowdges the interrupt to the adapter ( thus * re - enabling adapter interrupts . * static irqreturn_t tlan_handle_interrupt(int irq, void *dev_id)struct net_device *dev = dev_id;struct tlan_priv *priv = netdev_priv(dev);2 ;if (type) {if (ack) {18 );return IRQ_RETVAL(type);/*************************************************************** * tlan_close * * Returns : * An error code . * Parms : * dev The device structure of the device to * close . * * This function shuts down the adapter . It records any * stats , puts the adapter into reset state , deactivates * its time as needed , and frees the irq it is using . * static int tlan_close(struct net_device *dev)"Device %s closed.\n" , dev->name);return 0 ;/*************************************************************** * tlan_get_stats * * Returns : * A pointer to the device ' s statistics structure . * Parms : * dev The device structure to return the * stats for . * * This function updates the devices statistics by reading * the TLAN chip ' s onboard registers . Then it returns the * address of the statistics structure . * static struct net_device_stats *tlan_get_stats(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);int i;/* Should only read stats if open ? */ "RECEIVE: %s EOC count = %d\n" , dev->name,"TRANSMIT: %s Busy count = %d\n" , dev->name,if (debug & TLAN_DEBUG_GNRL) {if (debug & TLAN_DEBUG_LIST) {for (i = 0 ; i < TLAN_NUM_RX_LISTS; i++)"RX" , i);for (i = 0 ; i < TLAN_NUM_TX_LISTS; i++)"TX" , i);return &dev->stats;/*************************************************************** * tlan_set_multicast_list * * Returns : * Nothing * Parms : * dev The device structure to set the * multicast list for . * * This function sets the TLAN adaptor to various receive * modes . If the IFF_PROMISC flag is set , promiscuous * mode is acitviated . Otherwise , promiscuous mode is * turned off . If the IFF_ALLMULTI flag is set , then * the hash table is set to receive all group addresses . * Otherwise , the first three multicast addresses are * stored in AREG_1 - 3 , and the rest are selected via the * hash table , as necessary . * static void tlan_set_multicast_list(struct net_device *dev)struct netdev_hw_addr *ha;0 ;0 ;int i;if (dev->flags & IFF_PROMISC) {else {if (dev->flags & IFF_ALLMULTI) {for (i = 0 ; i < 3 ; i++)1 , NULL);0 xffffffff);0 xffffffff);else {0 ;if (i < 3 ) {1 ,char *) &ha->addr);else {if (offset < 32 )1 << offset);else 1 << (offset - 32 ));for ( ; i < 3 ; i++)1 , NULL);/****************************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ThunderLAN driver interrupt vectors and table please see chap . 4 , " Interrupt Handling " of the " ThunderLAN Programmer ' s Guide " for more informations on handling interrupts generated by TLAN based adapters . * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /*************************************************************** * tlan_handle_tx_eof * * Returns : * 1 * Parms : * dev Device assigned the IRQ that was * raised . * host_int The contents of the HOST_INT * port . * * This function handles Tx EOF interrupts which are raised * by the adapter when it has completed sending the * contents of a buffer . If detemines which list / buffer * was completed and resets it . If the buffer was the last * in the channel ( EOC ) , then the function checks to see if * another buffer is ready to send , and if so , sends a Tx * Go command . Finally , the driver activates / continues the * activity LED . * static u32 tlan_handle_tx_eof(struct net_device *dev, u16 host_int)struct tlan_priv *priv = netdev_priv(dev);int eoc = 0 ;struct tlan_list *head_list;0 ;"TRANSMIT: Handling TX EOF (Head=%d Tail=%d)\n" ,while (((tmp_c_stat = head_list->c_stat) & TLAN_CSTAT_FRM_CMP)255 )) {struct sk_buff *skb = tlan_get_skb(head_list);0 ].address,unsigned int )TLAN_MIN_FRAME_SIZE),8 ].address = 0 ;9 ].address = 0 ;if (tmp_c_stat & TLAN_CSTAT_EOC)1 ;if (!ack)"Received interrupt for uncompleted TX frame\n" );if (eoc) {"TRANSMIT: handling TX EOC (Head=%d Tail=%d)\n" ,sizeof (struct tlan_list)*priv->tx_head;if ((head_list->c_stat & TLAN_CSTAT_READY)else {0 ;if (priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED) {if (priv->timer.function == NULL) {else if (priv->timer_type == TLAN_TIMER_ACTIVITY) {return ack;/*************************************************************** * TLan_HandleStatOverflow * * Returns : * 1 * Parms : * dev Device assigned the IRQ that was * raised . * host_int The contents of the HOST_INT * port . * * This function handles the Statistics Overflow interrupt * which means that one or more of the TLAN statistics * registers has reached 1 / 2 capacity and needs to be read . * static u32 tlan_handle_stat_overflow(struct net_device *dev, u16 host_int)return 1 ;/*************************************************************** * TLan_HandleRxEOF * * Returns : * 1 * Parms : * dev Device assigned the IRQ that was * raised . * host_int The contents of the HOST_INT * port . * * This function handles the Rx EOF interrupt which * indicates a frame has been received by the adapter from * the net and the frame has been transferred to memory . * The function determines the bounce buffer the frame has * been loaded into , creates a new sk_buff big enough to * hold the frame , and sends it to protocol stack . It * then resets the used buffer and appends it to the end * of the list . If the frame was the last in the Rx * channel ( EOC ) , the function restarts the receive channel * by sending an Rx Go command to the adapter . Then it * activates / continues the activity LED . * static u32 tlan_handle_rx_eof(struct net_device *dev, u16 host_int)struct tlan_priv *priv = netdev_priv(dev);0 ;int eoc = 0 ;struct tlan_list *head_list;struct sk_buff *skb;struct tlan_list *tail_list;"RECEIVE: handling RX EOF (Head=%d Tail=%d)\n" ,sizeof (struct tlan_list)*priv->rx_head;while (((tmp_c_stat = head_list->c_stat) & TLAN_CSTAT_FRM_CMP)255 )) {0 ].address;struct sk_buff *new_skb;if (tmp_c_stat & TLAN_CSTAT_EOC)1 ;5 );if (!new_skb)goto drop_and_reuse;0 ].address =0 ;0 ;sizeof (struct tlan_list)*priv->rx_head;if (!ack)"Received interrupt for uncompleted RX frame\n" );if (eoc) {"RECEIVE: handling RX EOC (Head=%d Tail=%d)\n" ,sizeof (struct tlan_list)*priv->rx_head;if (priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED) {if (priv->timer.function == NULL) {else if (priv->timer_type == TLAN_TIMER_ACTIVITY) {return ack;/*************************************************************** * tlan_handle_dummy * * Returns : * 1 * Parms : * dev Device assigned the IRQ that was * raised . * host_int The contents of the HOST_INT * port . * * This function handles the Dummy interrupt , which is * raised whenever a test interrupt is generated by setting * the Req_Int bit of HOST_CMD to 1 . * static u32 tlan_handle_dummy(struct net_device *dev, u16 host_int)"Test interrupt\n" );return 1 ;/*************************************************************** * tlan_handle_tx_eoc * * Returns : * 1 * Parms : * dev Device assigned the IRQ that was * raised . * host_int The contents of the HOST_INT * port . * * This driver is structured to determine EOC occurrences by * reading the CSTAT member of the list structure . Tx EOC * interrupts are disabled via the DIO INTDIS register . * However , TLAN chips before revision 3 . 0 didn ' t have this * functionality , so process EOC events if this is the * case . * static u32 tlan_handle_tx_eoc(struct net_device *dev, u16 host_int)struct tlan_priv *priv = netdev_priv(dev);struct tlan_list *head_list;1 ;if (priv->tlan_rev < 0 x30) {"TRANSMIT: handling TX EOC (Head=%d Tail=%d) -- IRQ\n" ,sizeof (struct tlan_list)*priv->tx_head;if ((head_list->c_stat & TLAN_CSTAT_READY)else {0 ;return ack;/*************************************************************** * tlan_handle_status_check * * Returns : * 0 if Adapter check , 1 if Network Status check . * Parms : * dev Device assigned the IRQ that was * raised . * host_int The contents of the HOST_INT * port . * * This function handles Adapter Check / Network Status * interrupts generated by the adapter . It checks the * vector in the HOST_INT register to determine if it is * an Adapter Check interrupt . If so , it resets the * adapter . Otherwise it clears the status registers * and services the PHY . * static u32 tlan_handle_status_check(struct net_device *dev, u16 host_int)struct tlan_priv *priv = netdev_priv(dev);1 ;if (host_int & TLAN_HI_IV_MASK) {"Adaptor Error = 0x%x\n" , error);0 ;else {"%s: Status Check\n" , dev->name);if (net_sts) {"%s: Net_Sts = %x\n" ,unsigned ) net_sts);if ((net_sts & TLAN_NET_STS_MIRQ) && (priv->phy_num == 0 )) {if (!(tlphy_sts & TLAN_TS_POLOK) &&else if ((tlphy_sts & TLAN_TS_POLOK) &&if (debug)return ack;/*************************************************************** * tlan_handle_rx_eoc * * Returns : * 1 * Parms : * dev Device assigned the IRQ that was * raised . * host_int The contents of the HOST_INT * port . * * This driver is structured to determine EOC occurrences by * reading the CSTAT member of the list structure . Rx EOC * interrupts are disabled via the DIO INTDIS register . * However , TLAN chips before revision 3 . 0 didn ' t have this * CSTAT member or a INTDIS register , so if this chip is * pre - 3 . 0 , process EOC interrupts normally . * static u32 tlan_handle_rx_eoc(struct net_device *dev, u16 host_int)struct tlan_priv *priv = netdev_priv(dev);1 ;if (priv->tlan_rev < 0 x30) {"RECEIVE: Handling RX EOC (head=%d tail=%d) -- IRQ\n" ,sizeof (struct tlan_list)*priv->rx_head;return ack;/****************************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ThunderLAN driver timer function * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /*************************************************************** * tlan_timer * * Returns : * Nothing * Parms : * data A value given to add timer when * add_timer was called . * * This function handles timed functionality for the * TLAN driver . The two current timer uses are for * delaying for autonegotionation and driving the ACT LED . * - Autonegotiation requires being allowed about * 2 1 / 2 seconds before attempting to transmit a * packet . It would be a very bad thing to hang * the kernel this long , so the driver doesn ' t * allow transmission ' til after this time , for * certain PHYs . It would be much nicer if all * PHYs were interrupt - capable like the internal * PHY . * - The ACT LED , which shows adapter activity , is * driven by the driver , and so must be left on * for a short period to power up the LED so it * can be seen . This delay can be changed by * changing the TLAN_TIMER_ACT_DELAY in tlan . h , * if desired . 100 ms produces a slightly * sluggish response . * static void tlan_timer(struct timer_list *t)struct tlan_priv *priv = timer_container_of(priv, t, timer);struct net_device *dev = priv->dev;unsigned long flags = 0 ;switch (priv->timer_type) {case TLAN_TIMER_PHY_PDOWN:break ;case TLAN_TIMER_PHY_PUP:break ;case TLAN_TIMER_PHY_RESET:break ;case TLAN_TIMER_PHY_START_LINK:break ;case TLAN_TIMER_PHY_FINISH_AN:break ;case TLAN_TIMER_FINISH_RESET:break ;case TLAN_TIMER_ACTIVITY:if (priv->timer.function == NULL) {if (elapsed >= TLAN_TIMER_ACT_DELAY) {else {break ;break ;default :break ;/****************************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ThunderLAN driver adapter related routines * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /*************************************************************** * tlan_reset_lists * * Returns : * Nothing * Parms : * dev The device structure with the list * structures to be reset . * * This routine sets the variables associated with managing * the TLAN lists to their initial values . * static void tlan_reset_lists(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);int i;struct tlan_list *list;struct sk_buff *skb;0 ;0 ;for (i = 0 ; i < TLAN_NUM_TX_LISTS; i++) {0 ].address = 0 ;2 ].count = 0 ;2 ].address = 0 ;8 ].address = 0 ;9 ].address = 0 ;0 ;1 ;for (i = 0 ; i < TLAN_NUM_RX_LISTS; i++) {sizeof (struct tlan_list)*i;0 ].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;5 );if (!skb)break ;0 ].address = dma_map_single(&priv->pci_dev->dev,1 ].count = 0 ;1 ].address = 0 ;sizeof (struct tlan_list);/* in case ran out of memory early, clear bits */ while (i < TLAN_NUM_RX_LISTS) {0 ;static void tlan_free_lists(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);int i;struct tlan_list *list;struct sk_buff *skb;for (i = 0 ; i < TLAN_NUM_TX_LISTS; i++) {if (skb) {0 ].address,unsigned int )TLAN_MIN_FRAME_SIZE),8 ].address = 0 ;9 ].address = 0 ;for (i = 0 ; i < TLAN_NUM_RX_LISTS; i++) {if (skb) {0 ].address,8 ].address = 0 ;9 ].address = 0 ;/*************************************************************** * tlan_print_dio * * Returns : * Nothing * Parms : * io_base Base IO port of the device of * which to print DIO registers . * * This function prints out all the internal ( DIO ) * registers of a TLAN chip . * static void tlan_print_dio(u16 io_base)int i;"Contents of internal registers for io base 0x%04hx\n" ,"Off. +0 +4\n" );for (i = 0 ; i < 0 x4C; i += 8 ) {0 x4);"0x%02x 0x%08x 0x%08x\n" , i, data0, data1);/*************************************************************** * TLan_PrintList * * Returns : * Nothing * Parms : * list A pointer to the struct tlan_list structure to * be printed . * type A string to designate type of list , * " Rx " or " Tx " . * num The index of the list . * * This function prints out the contents of the list * pointed to by the list parameter . * static void tlan_print_list(struct tlan_list *list, char *type, int num)int i;"%s List %d at %p\n" , type, num, list);" Forward = 0x%08x\n" , list->forward);" CSTAT = 0x%04hx\n" , list->c_stat);" Frame Size = 0x%04hx\n" , list->frame_size);/* for (i = 0; i < 10; i++) { */ for (i = 0 ; i < 2 ; i++) {" Buffer[%d].count, addr = 0x%08x, 0x%08x\n" ,/*************************************************************** * tlan_read_and_clear_stats * * Returns : * Nothing * Parms : * dev Pointer to device structure of adapter * to which to read stats . * record Flag indicating whether to add * * This functions reads all the internal status registers * of the TLAN chip , which clears them as a side effect . * It then either adds the values to the device ' s status * struct , or discards them , depending on whether record * is TLAN_RECORD ( ! = 0 ) or TLAN_IGNORE ( = = 0 ) . * static void tlan_read_and_clear_stats(struct net_device *dev, int record)1 ) << 8 ;2 ) << 16 ;3 );1 ) << 8 ;2 ) << 16 ;3 );1 ) << 8 ;2 );3 );1 ) << 8 ;2 );3 ) << 8 ;1 );2 );if (record) {/*************************************************************** * TLan_Reset * * Returns : * 0 * Parms : * dev Pointer to device structure of adapter * to be reset . * * This function resets the adapter and it ' s physical * device . See Chap . 3 , pp . 9 - 10 of the " ThunderLAN * Programmer ' s Guide " for details . The routine tries to * implement what is detailed there , though adjustments * have been made . * static void struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);int i;false ;0 ;/* 1. Assert reset bit. */ 1000 );/* 2. Turn off interrupts. (Probably isn't necessary) */ /* 3. Clear AREGs and HASHs. */ for (i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 )0 );/* 4. Setup NetConfig register. */ /* 5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */ 0 x3f, dev->base_addr + TLAN_HOST_CMD);0 x9, dev->base_addr + TLAN_HOST_CMD);/* 6. Unreset the MII by setting NMRST (in NetSio) to 1. */ /* 7. Setup the remaining registers. */ if (priv->tlan_rev >= 0 x30) {if (priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY) {if (priv->aui == 1 ) {0 x0a);else if (priv->duplex == TLAN_DUPLEX_FULL) {0 x00);true ;else {0 x08);/* don't power down internal PHY if we're going to use it */ if (priv->phy_num == 0 ||if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY)else static void struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);int i;if (priv->tlan_full_duplex)if (priv->phy_num == 0 )1536 )+7 )&~7 );if ((priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) ||"Link forced\n" );else {1000 );if (status & MII_GS_LINK) {/* We only support link info on Nat.Sem. PHY's */ if ((tlphy_id1 == NAT_SEM_ID1) &&"Link active, %s %uMbps %s-Duplex\n" ,"forced" : "Autonegotiation enabled," ,100 : 10 ,"Full" : "Half" );if (tlphy_par & TLAN_PHY_AN_EN_STAT) {"Partner capability:" );for (i = 5 ; i < 10 ; i++)if (partner & (1 << i))" %s" ,5 ]);"\n" );else "Link active\n" );/* Enabling link beat monitoring */ if (priv->phy_num == 0 ) {if (status & MII_GS_LINK) {0 , dev->dev_addr);1 ;8 ), dev->base_addr + TLAN_HOST_CMD + 1 );if (debug >= 1 && debug != TLAN_DEBUG_PROBE)8 ),1 );else {"Link inactive, will retry in 10 secs...\n" );10 *HZ), TLAN_TIMER_FINISH_RESET);return ;/*************************************************************** * tlan_set_mac * * Returns : * Nothing * Parms : * dev Pointer to device structure of adapter * on which to change the AREG . * areg The AREG to set the address in ( 0 - 3 ) . * mac A pointer to an array of chars . Each * element stores one byte of the address . * IE , it isn ' t in ascii . * * This function transfers a MAC address to one of the * TLAN AREGs ( address registers ) . The TLAN chip locks * the register on writing to offset 0 and unlocks the * register after writing to offset 5 . If NULL is passed * in mac , then the AREG is filled with 0 ' s . * static void tlan_set_mac(struct net_device *dev, int areg, const char *mac)int i;6 ;if (mac != NULL) {for (i = 0 ; i < 6 ; i++)else {for (i = 0 ; i < 6 ; i++)0 );/****************************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ThunderLAN driver PHY layer routines * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /********************************************************************* * _ _ tlan_phy_print * * Returns : * Nothing * Parms : * dev A pointer to the device structure of the * TLAN device having the PHYs to be detailed . * * This function prints the registers a PHY ( aka transceiver ) . * static void __tlan_phy_print(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {"Unmanaged PHY\n" );else if (phy <= TLAN_PHY_MAX_ADDR) {"PHY 0x%02x\n" , phy);" Off. +0 +1 +2 +3\n" );for (i = 0 ; i < 0 x20; i += 4 ) {1 , &data1);2 , &data2);3 , &data3);" 0x%02x 0x%04hx 0x%04hx 0x%04hx 0x%04hx\n" ,else {"Invalid PHY\n" );static void tlan_phy_print(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);unsigned long flags;/********************************************************************* * tlan_phy_detect * * Returns : * Nothing * Parms : * dev A pointer to the device structure of the adapter * for which the PHY needs determined . * * So far I ' ve found that adapters which have external PHYs * may also use the internal PHY for part of the functionality . * ( eg , AUI / Thinnet ) . This function finds out if this TLAN * chip has an internal PHY , and then finds the first external * PHY ( starting from address 0 ) if it exists ) . * static void tlan_phy_detect(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {0 xffff;return ;if (hi != 0 xffff)0 ] = TLAN_PHY_MAX_ADDR;else 0 ] = TLAN_PHY_NONE;1 ] = TLAN_PHY_NONE;for (phy = 0 ; phy <= TLAN_PHY_MAX_ADDR; phy++) {if ((control != 0 xffff) ||0 xffff) || (lo != 0 xffff)) {"PHY found at %02x %04x %04x %04x\n" ,if ((priv->phy[1 ] == TLAN_PHY_NONE) &&1 ] = phy;if (priv->phy[1 ] != TLAN_PHY_NONE)1 ;else if (priv->phy[0 ] != TLAN_PHY_NONE)0 ;else "Cannot initialize device, no PHY was found!\n" );static void tlan_phy_power_down(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);"%s: Powering down PHY(s).\n" , dev->name);if ((priv->phy_num == 0 ) && (priv->phy[1 ] != TLAN_PHY_NONE)) {/* if using internal PHY, the external PHY must be powered on */ if (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10)/* just isolate it from MII */ 1 ], MII_GEN_CTL, value);/* Wait for 50 ms and powerup * This is arbitrary . It is intended to make sure the * transceiver settles . 50 ), TLAN_TIMER_PHY_PUP);static void tlan_phy_power_up(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);"%s: Powering up PHY.\n" , dev->name);/* Wait for 500 ms and reset the * transceiver . The TLAN docs say both 50 ms and * 500 ms , so do the longer , just in case . 500 ), TLAN_TIMER_PHY_RESET);static void tlan_phy_reset(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);unsigned long timeout = jiffies + HZ;"%s: Resetting PHY.\n" , dev->name);do {if (time_after(jiffies, timeout)) {"PHY reset timeout\n" );return ;while (value & MII_GC_RESET);/* Wait for 500 ms and initialize. * I don ' t remember why I wait this long . * I ' ve changed this to 50 ms , as it seems long enough . 50 ), TLAN_TIMER_PHY_START_LINK);static void tlan_phy_start_link(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);"%s: Trying to activate link.\n" , dev->name);if ((status & MII_GS_AUTONEG) &&11 ;if (priv->speed == TLAN_SPEED_10 &&0 x0000);else if (priv->speed == TLAN_SPEED_10 &&true ;0 x0100);else if (priv->speed == TLAN_SPEED_100 &&0 x2000);else if (priv->speed == TLAN_SPEED_100 &&true ;0 x2100);else {/* Set Auto-Neg advertisement */ 5 ) | 1 );/* Enablee Auto-Neg */ 0 x1000);/* Restart Auto-Neg */ 0 x1200);/* Wait for 4 sec for autonegotiation * to complete . The max spec time is less than this * but the card need additional time to start AN . * . 5 sec should be plenty extra . "Starting autonegotiation\n" );2 *HZ), TLAN_TIMER_PHY_FINISH_AN);return ;if ((priv->aui) && (priv->phy_num != 0 )) {0 ;40 ), TLAN_TIMER_PHY_PDOWN);return ;else if (priv->phy_num == 0 ) {0 ;if (priv->aui) {else {if (priv->duplex == TLAN_DUPLEX_FULL) {true ;if (priv->speed == TLAN_SPEED_100)/* Wait for 2 sec to give the transceiver time * to establish link . 4 *HZ), TLAN_TIMER_FINISH_RESET);static void tlan_phy_finish_auto_neg(struct net_device *dev)struct tlan_priv *priv = netdev_priv(dev);1000 );if (!(status & MII_GS_AUTOCMPLT)) {/* Wait for 8 sec to give the process * more time . Perhaps we should fail after a while . 2 * HZ, TLAN_TIMER_PHY_FINISH_AN);return ;"Autonegotiation complete\n" );0 x03E0;if (mode & 0 x0100)true ;else if (!(mode & 0 x0080) && (mode & 0 x0040))true ;/* switch to internal PHY for 10 Mbps */ if ((!(mode & 0 x0180)) &&0 )) {0 ;400 ), TLAN_TIMER_PHY_PDOWN);return ;if (priv->phy_num == 0 ) {if ((priv->duplex == TLAN_DUPLEX_FULL) ||0 x0040)) {"Starting internal PHY with FULL-DUPLEX\n" );else {"Starting internal PHY with HALF-DUPLEX\n" );/* Wait for 100 ms. No reason in partiticular. 100 ), TLAN_TIMER_FINISH_RESET);/********************************************************************* * * tlan_phy_monitor * * Returns : * None * * Params : * data The device structure of this device . * * * This function monitors PHY condition by reading the status * register via the MII bus , controls LINK LED and notifies the * kernel about link state . * static void tlan_phy_monitor(struct timer_list *t)struct tlan_priv *priv = timer_container_of(priv, t, media_timer);struct net_device *dev = priv->dev;/* Get PHY status register */ /* Check if link has been lost */ if (!(phy_status & MII_GS_LINK)) {if (netif_carrier_ok(dev)) {"TLAN: %s has lost link\n" ,0 );if (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10) {/* power down internal PHY */ 0 ],/* set to external PHY */ 1 ;/* restart autonegotiation */ 400 ),return ;/* Link restablished? */ if ((phy_status & MII_GS_LINK) && !netif_carrier_ok(dev)) {"TLAN: %s has reestablished link\n" ,/****************************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ThunderLAN driver MII routines these routines are based on the information in chap . 2 of the " ThunderLAN Programmer ' s Guide " , pp . 15 - 24 . * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /*************************************************************** * _ _ tlan_mii_read_reg * * Returns : * false if ack received ok * true if no ack received or other error * * Parms : * dev The device structure containing * The io address and interrupt count * for this device . * phy The address of the PHY to be queried . * reg The register whose contents are to be * retrieved . * val A pointer to a variable to store the * retrieved value . * * This function uses the TLAN ' s MII bus to retrieve the contents * of a given register on a PHY . It sends the appropriate info * and then reads the 16 - bit register value from the MII bus via * the TLAN SIO register . * static bool struct net_device *dev, u16 phy, u16 reg, u16 *val)bool err;int minten;struct tlan_priv *priv = netdev_priv(dev);false ;if (minten)0 x1, 2 ); /* start (01b) */ 0 x2, 2 ); /* read (10b) */ 5 ); /* device # */ 5 ); /* register # */ /* change direction */ /* clock idle bit */ /* wait 300ns */ /* check for ACK */ /* finish ACK */ if (nack) { /* no ACK, so fake it */ for (i = 0 ; i < 16 ; i++) {0 xffff;true ;else { /* ACK, so read data */ for (tmp = 0 , i = 0 x8000; i; i >>= 1 ) {if (tlan_get_bit(TLAN_NET_SIO_MDATA, sio))/* idle cycle */ if (minten)return err;static void tlan_mii_read_reg(struct net_device *dev, u16 phy, u16 reg,struct tlan_priv *priv = netdev_priv(dev);unsigned long flags;/*************************************************************** * tlan_mii_send_data * * Returns : * Nothing * Parms : * base_port The base IO port of the adapter in * question . * dev The address of the PHY to be queried . * data The value to be placed on the MII bus . * num_bits The number of bits in data that are to * be placed on the MII bus . * * This function sends on sequence of bits on the MII * configuration bus . * static void tlan_mii_send_data(u16 base_port, u32 data, unsigned num_bits)if (num_bits == 0 )return ;for (i = (0 x1 << (num_bits - 1 )); i; i >>= 1 ) {void ) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);if (data & i)else void ) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);/*************************************************************** * TLan_MiiSync * * Returns : * Nothing * Parms : * base_port The base IO port of the adapter in * question . * * This functions syncs all PHYs in terms of the MII configuration * bus . * static void tlan_mii_sync(u16 base_port)int i;for (i = 0 ; i < 32 ; i++) {/*************************************************************** * _ _ tlan_mii_write_reg * * Returns : * Nothing * Parms : * dev The device structure for the device * to write to . * phy The address of the PHY to be written to . * reg The register whose contents are to be * written . * val The value to be written to the register . * * This function uses the TLAN ' s MII bus to write the contents of a * given register on a PHY . It sends the appropriate info and then * writes the 16 - bit register value from the MII configuration bus * via the TLAN SIO register . * static void struct net_device *dev, u16 phy, u16 reg, u16 val)int minten;struct tlan_priv *priv = netdev_priv(dev);if (minten)0 x1, 2 ); /* start (01b) */ 0 x1, 2 ); /* write (01b) */ 5 ); /* device # */ 5 ); /* register # */ 0 x2, 2 ); /* send ACK */ 16 ); /* send data */ /* idle cycle */ if (minten)static void struct net_device *dev, u16 phy, u16 reg, u16 val)struct tlan_priv *priv = netdev_priv(dev);unsigned long flags;/****************************************************************************** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ThunderLAN driver eeprom routines the Compaq netelligent 10 and 10 / 100 cards use a microchip 24 C02A EEPROM . these functions are based on information in microchip ' s data sheet . I don ' t know how well this functions will work with other Eeproms . * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /*************************************************************** * tlan_ee_send_start * * Returns : * Nothing * Parms : * io_base The IO port base address for the * TLAN device with the EEPROM to * use . * * This function sends a start cycle to an EEPROM attached * to a TLAN chip . * static void tlan_ee_send_start(u16 io_base)/*************************************************************** * tlan_ee_send_byte * * Returns : * If the correct ack was received , 0 , otherwise 1 * Parms : io_base The IO port base address for the * TLAN device with the EEPROM to * use . * data The 8 bits of information to * send to the EEPROM . * stop If TLAN_EEPROM_STOP is passed , a * stop cycle is sent after the * byte is sent after the ack is * read . * * This function sends a byte on the serial EEPROM line , * driving the clock to send each bit . The function then * reverses transmission direction and reads an acknowledge * bit . * static int tlan_ee_send_byte(u16 io_base, u8 data, int stop)int err;/* Assume clock is low, tx is enabled; */ for (place = 0 x80; place != 0 ; place >>= 1 ) {if (place & data)else if ((!err) && stop) {/* STOP, raise data while clock is high */ return err;/*************************************************************** * tlan_ee_receive_byte * * Returns : * Nothing * Parms : * io_base The IO port base address for the * TLAN device with the EEPROM to * use . * data An address to a char to hold the * data sent from the EEPROM . * stop If TLAN_EEPROM_STOP is passed , a * stop cycle is sent after the * byte is received , and no ack is * sent . * * This function receives 8 bits of data from the EEPROM * over the serial link . It then sends and ack bit , or no * ack and a stop bit . This function is used to retrieve * data after the address of a byte in the EEPROM has been * sent . * static void tlan_ee_receive_byte(u16 io_base, u8 *data, int stop)0 ;/* Assume clock is low, tx is enabled; */ for (place = 0 x80; place; place >>= 1 ) {if (tlan_get_bit(TLAN_NET_SIO_EDATA, sio))if (!stop) {/* ack = 0 */ else {/* no ack = 1 (?) */ /* STOP, raise data while clock is high */ /*************************************************************** * tlan_ee_read_byte * * Returns : * No error = 0 , else , the stage at which the error * occurred . * Parms : * io_base The IO port base address for the * TLAN device with the EEPROM to * use . * ee_addr The address of the byte in the * EEPROM whose contents are to be * retrieved . * data An address to a char to hold the * data obtained from the EEPROM . * * This function reads a byte of information from an byte * cell in the EEPROM . * static int tlan_ee_read_byte(struct net_device *dev, u8 ee_addr, u8 *data)int err;struct tlan_priv *priv = netdev_priv(dev);unsigned long flags = 0 ;int ret = 0 ;0 xa0, TLAN_EEPROM_ACK);if (err) {1 ;goto fail;if (err) {2 ;goto fail;0 xa1, TLAN_EEPROM_ACK);if (err) {3 ;goto fail;return ret;
Messung V0.5 in Prozent C=97 H=90 G=93
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.90Bemerkung:
(vorverarbeitet am 2026-09-28)
¤ *Bot Zugriff
