开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
lmc_main.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：70k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

lmc_main.c：源码内容
  1.  /*
  2.   * Copyright (c) 1997-2000 LAN Media Corporation (LMC)
  3.   * All rights reserved.  www.lanmedia.com
  4.   *
  5.   * This code is written by:
  6.   * Andrew Stanley-Jones (asj@cban.com)
  7.   * Rob Braun (bbraun@vix.com),
  8.   * Michael Graff (explorer@vix.com) and
  9.   * Matt Thomas (matt@3am-software.com).
  10.   *
  11.   * With Help By:
  12.   * David Boggs
  13.   * Ron Crane
  14.   * Allan Cox
  15.   *
  16.   * This software may be used and distributed according to the terms
  17.   * of the GNU General Public License version 2, incorporated herein by reference.
  18.   *
  19.   * Driver for the LanMedia LMC5200, LMC5245, LMC1000, LMC1200 cards.
  20.   *
  21.   * To control link specific options lmcctl is required.
  22.   * It can be obtained from ftp.lanmedia.com.
  23.   *
  24.   * Linux driver notes:
  25.   * Linux uses the device struct lmc_private to pass private information
  26.   * arround.
  27.   *
  28.   * The initialization portion of this driver (the lmc_reset() and the
  29.   * lmc_dec_reset() functions, as well as the led controls and the
  30.   * lmc_initcsrs() functions.
  31.   *
  32.   * The watchdog function runs every second and checks to see if
  33.   * we still have link, and that the timing source is what we expected
  34.   * it to be.  If link is lost, the interface is marked down, and
  35.   * we no longer can transmit.
  36.   *
  37.   */
  39. /* $Id: lmc_main.c,v 1.36 2000/04/11 05:25:25 asj Exp $ */
  41. #include <linux/version.h>
  42. #include <linux/kernel.h>
  43. #include <linux/sched.h>
  44. #include <linux/string.h>
  45. #include <linux/timer.h>
  46. #include <linux/ptrace.h>
  47. #include <linux/errno.h>
  48. #include <linux/ioport.h>
  49. #include <linux/slab.h>
  50. #include <linux/interrupt.h>
  51. #include <linux/pci.h>
  52. #include <linux/delay.h>
  53. #include <asm/segment.h>
  54. #include <linux/init.h>
  56. #if LINUX_VERSION_CODE < 0x20155
  57. #include <linux/bios32.h>
  58. #endif
  60. #include <linux/in.h>
  61. #include <linux/if_arp.h>
  62. #include <asm/processor.h>             /* Processor type for cache alignment. */
  63. #include <asm/bitops.h>
  64. #include <asm/io.h>
  65. #include <asm/dma.h>
  67. #include <linux/netdevice.h>
  68. #include <linux/etherdevice.h>
  69. #include <linux/skbuff.h>
  70. #include <net/syncppp.h>
  71. #include <linux/inet.h>
  73. #if LINUX_VERSION_CODE >= 0x20200
  74. #include <asm/uaccess.h>
  75. //#include <asm/spinlock.h>
  76. #else /* 2.0 kernel */
  77. #define ARPHRD_HDLC 513
  78. #endif
  80. #include <linux/module.h>
  82. #define DRIVER_MAJOR_VERSION     1
  83. #define DRIVER_MINOR_VERSION    34
  84. #define DRIVER_SUB_VERSION       0
  86. #define DRIVER_VERSION  ((DRIVER_MAJOR_VERSION << 8) + DRIVER_MINOR_VERSION)
  88. #include "lmc_ver.h"
  89. #include "lmc.h"
  90. #include "lmc_var.h"
  91. #include "lmc_ioctl.h"
  92. #include "lmc_debug.h"
  93. #include "lmc_proto.h"
  96. static int Lmc_Count = 0;
  97. static struct net_device *Lmc_root_dev = NULL;
  98. static u8 cards_found = 0;
  100. static int lmc_first_load = 0;
  102. int LMC_PKT_BUF_SZ = 1542;
  104. #ifdef MODULE
  105. static struct pci_device_id lmc_pci_tbl[] __devinitdata = {
  106.     { 0x1011, 0x009, 0x1379, PCI_ANY_ID, 0, 0, 0},
  107.     { 0, }
  108. };
  110. MODULE_DEVICE_TABLE(pci, lmc_pci_tbl);
  112. MODULE_LICENSE("GPL");
  113. #endif
  116. int lmc_probe_fake(struct net_device *dev);
  117. static struct net_device *lmc_probe1(struct net_device *dev, unsigned long ioaddr, unsigned int irq,
  118.  int chip_id, int subdevice, int board_idx);
  119. static int lmc_start_xmit(struct sk_buff *skb, struct net_device *dev);
  120. static int lmc_start_xmit(struct sk_buff *skb, struct net_device *dev);
  121. static int lmc_rx (struct net_device *dev);
  122. static int lmc_open(struct net_device *dev);
  123. static int lmc_close(struct net_device *dev);
  124. static struct net_device_stats *lmc_get_stats(struct net_device *dev);
  125. static void lmc_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
  126. static int lmc_set_config(struct net_device *dev, struct ifmap *map);
  127. static void lmc_initcsrs(lmc_softc_t * const sc, lmc_csrptr_t csr_base, size_t csr_size);
  128. static void lmc_softreset(lmc_softc_t * const);
  129. static void lmc_running_reset(struct net_device *dev);
  130. static int lmc_ifdown(struct net_device * const);
  131. static void lmc_watchdog(unsigned long data);
  132. static int lmc_init(struct net_device * const);
  133. static void lmc_reset(lmc_softc_t * const sc);
  134. static void lmc_dec_reset(lmc_softc_t * const sc);
  135. #if LINUX_VERSION_CODE >= 0x20363
  136. static void lmc_driver_timeout(struct net_device *dev);
  137. int lmc_setup(void);
  138. #endif
  141. /*
  142.  * linux reserves 16 device specific IOCTLs.  We call them
  143.  * LMCIOC* to control various bits of our world.
  144.  */
  145. int lmc_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd) /*fold00*/
  146. {
  147.     lmc_softc_t *sc;
  148.     lmc_ctl_t ctl;
  149.     int ret;
  150.     u_int16_t regVal;
  151.     unsigned long flags;
  153.     struct sppp *sp;
  155.     ret = -EOPNOTSUPP;
  157.     sc = dev->priv;
  159.     lmc_trace(dev, "lmc_ioctl in");
  161.     /*
  162.      * Most functions mess with the structure
  163.      * Disable interrupts while we do the polling
  164.      */
  165.     spin_lock_irqsave(&sc->lmc_lock, flags);
  167.     switch (cmd) {
  168.         /*
  169.          * Return current driver state.  Since we keep this up
  170.          * To date internally, just copy this out to the user.
  171.          */
  172.     case LMCIOCGINFO: /*fold01*/
  173.         LMC_COPY_TO_USER(ifr->ifr_data, &sc->ictl, sizeof (lmc_ctl_t));
  174.         ret = 0;
  175.         break;
  177.     case LMCIOCSINFO: /*fold01*/
  178.         sp = &((struct ppp_device *) dev)->sppp;
  179.         if (!suser ()) {
  180.             ret = -EPERM;
  181.             break;
  182.         }
  184.         if(dev->flags & IFF_UP){
  185.             ret = -EBUSY;
  186.             break;
  187.         }
  189.         LMC_COPY_FROM_USER(&ctl, ifr->ifr_data, sizeof (lmc_ctl_t));
  191.         sc->lmc_media->set_status (sc, &ctl);
  193.         if(ctl.crc_length != sc->ictl.crc_length) {
  194.             sc->lmc_media->set_crc_length(sc, ctl.crc_length);
  195.     if (sc->ictl.crc_length == LMC_CTL_CRC_LENGTH_16)
  196. sc->TxDescriptControlInit |=  LMC_TDES_ADD_CRC_DISABLE;
  197.     else
  198. sc->TxDescriptControlInit &= ~LMC_TDES_ADD_CRC_DISABLE;
  199.         }
  201.         if (ctl.keepalive_onoff == LMC_CTL_OFF)
  202.             sp->pp_flags &= ~PP_KEEPALIVE; /* Turn off */
  203.         else
  204.             sp->pp_flags |= PP_KEEPALIVE; /* Turn on */
  206.         ret = 0;
  207.         break;
  209.     case LMCIOCIFTYPE: /*fold01*/
  210.         {
  211.             u_int16_t old_type = sc->if_type;
  212.             u_int16_t new_type;
  214.     if (!suser ()) {
  215. ret = -EPERM;
  216. break;
  217.     }
  219.     LMC_COPY_FROM_USER(&new_type, ifr->ifr_data, sizeof(u_int16_t));
  221.             
  222.     if (new_type == old_type)
  223.     {
  224. ret = 0 ;
  225. break; /* no change */
  226.             }
  227.             
  228.             lmc_proto_close(sc);
  229.             lmc_proto_detach(sc);
  231.             sc->if_type = new_type;
  232. //            lmc_proto_init(sc);
  233.             lmc_proto_attach(sc);
  234.             lmc_proto_open(sc);
  236.     ret = 0 ;
  237.     break ;
  238. }
  240.     case LMCIOCGETXINFO: /*fold01*/
  241.         sc->lmc_xinfo.Magic0 = 0xBEEFCAFE;
  243.         sc->lmc_xinfo.PciCardType = sc->lmc_cardtype;
  244.         sc->lmc_xinfo.PciSlotNumber = 0;
  245.         sc->lmc_xinfo.DriverMajorVersion = DRIVER_MAJOR_VERSION;
  246.         sc->lmc_xinfo.DriverMinorVersion = DRIVER_MINOR_VERSION;
  247.         sc->lmc_xinfo.DriverSubVersion = DRIVER_SUB_VERSION;
  248.         sc->lmc_xinfo.XilinxRevisionNumber =
  249.             lmc_mii_readreg (sc, 0, 3) & 0xf;
  250.         sc->lmc_xinfo.MaxFrameSize = LMC_PKT_BUF_SZ;
  251.         sc->lmc_xinfo.link_status = sc->lmc_media->get_link_status (sc);
  252.         sc->lmc_xinfo.mii_reg16 = lmc_mii_readreg (sc, 0, 16);
  254.         sc->lmc_xinfo.Magic1 = 0xDEADBEEF;
  256.         LMC_COPY_TO_USER(ifr->ifr_data, &sc->lmc_xinfo,
  257.                          sizeof (struct lmc_xinfo));
  258.         ret = 0;
  260.         break;
  262.     case LMCIOCGETLMCSTATS: /*fold01*/
  263.         if (sc->lmc_cardtype == LMC_CARDTYPE_T1){
  264.             lmc_mii_writereg (sc, 0, 17, T1FRAMER_FERR_LSB);
  265.             sc->stats.framingBitErrorCount +=
  266.                 lmc_mii_readreg (sc, 0, 18) & 0xff;
  267.             lmc_mii_writereg (sc, 0, 17, T1FRAMER_FERR_MSB);
  268.             sc->stats.framingBitErrorCount +=
  269.                 (lmc_mii_readreg (sc, 0, 18) & 0xff) << 8;
  270.             lmc_mii_writereg (sc, 0, 17, T1FRAMER_LCV_LSB);
  271.             sc->stats.lineCodeViolationCount +=
  272.                 lmc_mii_readreg (sc, 0, 18) & 0xff;
  273.             lmc_mii_writereg (sc, 0, 17, T1FRAMER_LCV_MSB);
  274.             sc->stats.lineCodeViolationCount +=
  275.                 (lmc_mii_readreg (sc, 0, 18) & 0xff) << 8;
  276.             lmc_mii_writereg (sc, 0, 17, T1FRAMER_AERR);
  277.             regVal = lmc_mii_readreg (sc, 0, 18) & 0xff;
  279.             sc->stats.lossOfFrameCount +=
  280.                 (regVal & T1FRAMER_LOF_MASK) >> 4;
  281.             sc->stats.changeOfFrameAlignmentCount +=
  282.                 (regVal & T1FRAMER_COFA_MASK) >> 2;
  283.             sc->stats.severelyErroredFrameCount +=
  284.                 regVal & T1FRAMER_SEF_MASK;
  285.         }
  287.         LMC_COPY_TO_USER(ifr->ifr_data, &sc->stats,
  288.                          sizeof (struct lmc_statistics));
  290.         ret = 0;
  291.         break;
  293.     case LMCIOCCLEARLMCSTATS: /*fold01*/
  294.         if (!suser ()){
  295.             ret = -EPERM;
  296.             break;
  297.         }
  299.         memset (&sc->stats, 0, sizeof (struct lmc_statistics));
  300.         sc->stats.check = STATCHECK;
  301.         sc->stats.version_size = (DRIVER_VERSION << 16) +
  302.             sizeof (struct lmc_statistics);
  303.         sc->stats.lmc_cardtype = sc->lmc_cardtype;
  304.         ret = 0;
  305.         break;
  307.     case LMCIOCSETCIRCUIT: /*fold01*/
  308.         if (!suser ()){
  309.             ret = -EPERM;
  310.             break;
  311.         }
  313.         if(dev->flags & IFF_UP){
  314.             ret = -EBUSY;
  315.             break;
  316.         }
  318.         LMC_COPY_FROM_USER(&ctl, ifr->ifr_data, sizeof (lmc_ctl_t));
  319.         sc->lmc_media->set_circuit_type(sc, ctl.circuit_type);
  320.         sc->ictl.circuit_type = ctl.circuit_type;
  321.         ret = 0;
  323.         break;
  325.     case LMCIOCRESET: /*fold01*/
  326.         if (!suser ()){
  327.             ret = -EPERM;
  328.             break;
  329.         }
  331.         /* Reset driver and bring back to current state */
  332.         printk (" REG16 before reset +%04xn", lmc_mii_readreg (sc, 0, 16));
  333.         lmc_running_reset (dev);
  334.         printk (" REG16 after reset +%04xn", lmc_mii_readreg (sc, 0, 16));
  336.         LMC_EVENT_LOG(LMC_EVENT_FORCEDRESET, LMC_CSR_READ (sc, csr_status), lmc_mii_readreg (sc, 0, 16));
  338.         ret = 0;
  339.         break;
  341. #ifdef DEBUG
  342.     case LMCIOCDUMPEVENTLOG:
  343.         LMC_COPY_TO_USER(ifr->ifr_data, &lmcEventLogIndex, sizeof (u32));
  344.         LMC_COPY_TO_USER(ifr->ifr_data + sizeof (u32), lmcEventLogBuf, sizeof (lmcEventLogBuf));
  346.         ret = 0;
  347.         break;
  348. #endif /* end ifdef _DBG_EVENTLOG */
  349.     case LMCIOCT1CONTROL: /*fold01*/
  350.         if (sc->lmc_cardtype != LMC_CARDTYPE_T1){
  351.             ret = -EOPNOTSUPP;
  352.             break;
  353.         }
  354.         break;
  355.     case LMCIOCXILINX: /*fold01*/
  356.         {
  357.             struct lmc_xilinx_control xc; /*fold02*/
  359.             if (!suser ()){
  360.                 ret = -EPERM;
  361.                 break;
  362.             }
  364.             /*
  365.              * Stop the xwitter whlie we restart the hardware
  366.              */
  367.             LMC_XMITTER_BUSY(dev);
  369.             LMC_COPY_FROM_USER(&xc, ifr->ifr_data, sizeof (struct lmc_xilinx_control));
  370.             switch(xc.command){
  371.             case lmc_xilinx_reset: /*fold02*/
  372.                 {
  373.                     u16 mii;
  374.                     mii = lmc_mii_readreg (sc, 0, 16);
  376.                     /*
  377.                      * Make all of them 0 and make input
  378.                      */
  379.                     lmc_gpio_mkinput(sc, 0xff);
  381.                     /*
  382.                      * make the reset output
  383.                      */
  384.                     lmc_gpio_mkoutput(sc, LMC_GEP_RESET);
  386.                     /*
  387.                      * RESET low to force configuration.  This also forces
  388.                      * the transmitter clock to be internal, but we expect to reset
  389.                      * that later anyway.
  390.                      */
  392.                     sc->lmc_gpio &= ~LMC_GEP_RESET;
  393.                     LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  396.                     /*
  397.                      * hold for more than 10 microseconds
  398.                      */
  399.                     udelay(50);
  401.                     sc->lmc_gpio |= LMC_GEP_RESET;
  402.                     LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  405.                     /*
  406.                      * stop driving Xilinx-related signals
  407.                      */
  408.                     lmc_gpio_mkinput(sc, 0xff);
  410.                     /* Reset the frammer hardware */
  411.                     sc->lmc_media->set_link_status (sc, 1);
  412.                     sc->lmc_media->set_status (sc, NULL);
  413. //                    lmc_softreset(sc);
  415.                     {
  416.                         int i;
  417.                         for(i = 0; i < 5; i++){
  418.                             lmc_led_on(sc, LMC_DS3_LED0);
  419.                             mdelay(100);
  420.                             lmc_led_off(sc, LMC_DS3_LED0);
  421.                             lmc_led_on(sc, LMC_DS3_LED1);
  422.                             mdelay(100);
  423.                             lmc_led_off(sc, LMC_DS3_LED1);
  424.                             lmc_led_on(sc, LMC_DS3_LED3);
  425.                             mdelay(100);
  426.                             lmc_led_off(sc, LMC_DS3_LED3);
  427.                             lmc_led_on(sc, LMC_DS3_LED2);
  428.                             mdelay(100);
  429.                             lmc_led_off(sc, LMC_DS3_LED2);
  430.                         }
  431.                     }
  432.                     
  433.                     
  435.                     ret = 0x0;
  437.                 }
  439.                 break;
  440.             case lmc_xilinx_load_prom: /*fold02*/
  441.                 {
  442.                     u16 mii;
  443.                     int timeout = 500000;
  444.                     mii = lmc_mii_readreg (sc, 0, 16);
  446.                     /*
  447.                      * Make all of them 0 and make input
  448.                      */
  449.                     lmc_gpio_mkinput(sc, 0xff);
  451.                     /*
  452.                      * make the reset output
  453.                      */
  454.                     lmc_gpio_mkoutput(sc,  LMC_GEP_DP | LMC_GEP_RESET);
  456.                     /*
  457.                      * RESET low to force configuration.  This also forces
  458.                      * the transmitter clock to be internal, but we expect to reset
  459.                      * that later anyway.
  460.                      */
  462.                     sc->lmc_gpio &= ~(LMC_GEP_RESET | LMC_GEP_DP);
  463.                     LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  466.                     /*
  467.                      * hold for more than 10 microseconds
  468.                      */
  469.                     udelay(50);
  471.                     sc->lmc_gpio |= LMC_GEP_DP | LMC_GEP_RESET;
  472.                     LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  474.                     /*
  475.                      * busy wait for the chip to reset
  476.                      */
  477.                     while( (LMC_CSR_READ(sc, csr_gp) & LMC_GEP_INIT) == 0 &&
  478.                            (timeout-- > 0))
  479.                         ;
  482.                     /*
  483.                      * stop driving Xilinx-related signals
  484.                      */
  485.                     lmc_gpio_mkinput(sc, 0xff);
  487.                     ret = 0x0;
  488.                     
  490.                     break;
  492.                 }
  494.             case lmc_xilinx_load: /*fold02*/
  495.                 {
  496.                     char *data;
  497.                     int pos;
  498.                     int timeout = 500000;
  500.                     if(xc.data == 0x0){
  501.                             ret = -EINVAL;
  502.                             break;
  503.                     }
  505.                     data = kmalloc(xc.len, GFP_KERNEL);
  506.                     if(data == 0x0){
  507.                             printk(KERN_WARNING "%s: Failed to allocate memory for copyn", dev->name);
  508.                             ret = -ENOMEM;
  509.                             break;
  510.                     }
  511.                     
  512.                     if(copy_from_user(data, xc.data, xc.len))
  513.                     {
  514.                      kfree(data);
  515.                      ret = -ENOMEM;
  516.                      break;
  517.                     }
  519.                     printk("%s: Starting load of data Len: %d at 0x%p == 0x%pn", dev->name, xc.len, xc.data, data);
  521.                     lmc_gpio_mkinput(sc, 0xff);
  523.                     /*
  524.                      * Clear the Xilinx and start prgramming from the DEC
  525.                      */
  527.                     /*
  528.                      * Set ouput as:
  529.                      * Reset: 0 (active)
  530.                      * DP:    0 (active)
  531.                      * Mode:  1
  532.                      *
  533.                      */
  534.                     sc->lmc_gpio = 0x00;
  535.                     sc->lmc_gpio &= ~LMC_GEP_DP;
  536.                     sc->lmc_gpio &= ~LMC_GEP_RESET;
  537.                     sc->lmc_gpio |=  LMC_GEP_MODE;
  538.                     LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  540.                     lmc_gpio_mkoutput(sc, LMC_GEP_MODE | LMC_GEP_DP | LMC_GEP_RESET);
  542.                     /*
  543.                      * Wait at least 10 us 20 to be safe
  544.                      */
  545.                     udelay(50);
  547.                     /*
  548.                      * Clear reset and activate programming lines
  549.                      * Reset: Input
  550.                      * DP:    Input
  551.                      * Clock: Output
  552.                      * Data:  Output
  553.                      * Mode:  Output
  554.                      */
  555.                     lmc_gpio_mkinput(sc, LMC_GEP_DP | LMC_GEP_RESET);
  557.                     /*
  558.                      * Set LOAD, DATA, Clock to 1
  559.                      */
  560.                     sc->lmc_gpio = 0x00;
  561.                     sc->lmc_gpio |= LMC_GEP_MODE;
  562.                     sc->lmc_gpio |= LMC_GEP_DATA;
  563.                     sc->lmc_gpio |= LMC_GEP_CLK;
  564.                     LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  565.                     
  566.                     lmc_gpio_mkoutput(sc, LMC_GEP_DATA | LMC_GEP_CLK | LMC_GEP_MODE );
  568.                     /*
  569.                      * busy wait for the chip to reset
  570.                      */
  571.                     while( (LMC_CSR_READ(sc, csr_gp) & LMC_GEP_INIT) == 0 &&
  572.                            (timeout-- > 0))
  573.                         ;
  575.                     printk(KERN_DEBUG "%s: Waited %d for the Xilinx to clear it's memoryn", dev->name, 500000-timeout);
  577.                     for(pos = 0; pos < xc.len; pos++){
  578.                         switch(data[pos]){
  579.                         case 0:
  580.                             sc->lmc_gpio &= ~LMC_GEP_DATA; /* Data is 0 */
  581.                             break;
  582.                         case 1:
  583.                             sc->lmc_gpio |= LMC_GEP_DATA; /* Data is 1 */
  584.                             break;
  585.                         default:
  586.                             printk(KERN_WARNING "%s Bad data in xilinx programming data at %d, got %d wanted 0 or 1n", dev->name, pos, data[pos]);
  587.                             sc->lmc_gpio |= LMC_GEP_DATA; /* Assume it's 1 */
  588.                         }
  589.                         sc->lmc_gpio &= ~LMC_GEP_CLK; /* Clock to zero */
  590.                         sc->lmc_gpio |= LMC_GEP_MODE;
  591.                         LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  592.                         udelay(1);
  593.                         
  594.                         sc->lmc_gpio |= LMC_GEP_CLK; /* Put the clack back to one */
  595.                         sc->lmc_gpio |= LMC_GEP_MODE;
  596.                         LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  597.                         udelay(1);
  598.                     }
  599.                     if((LMC_CSR_READ(sc, csr_gp) & LMC_GEP_INIT) == 0){
  600.                         printk(KERN_WARNING "%s: Reprogramming FAILED. Needs to be reprogrammed. (corrupted data)n", dev->name);
  601.                     }
  602.                     else if((LMC_CSR_READ(sc, csr_gp) & LMC_GEP_DP) == 0){
  603.                         printk(KERN_WARNING "%s: Reprogramming FAILED. Needs to be reprogrammed. (done)n", dev->name);
  604.                     }
  605.                     else {
  606.                         printk(KERN_DEBUG "%s: Done reprogramming Xilinx, %d bits, good luck!n", dev->name, pos);
  607.                     }
  609.                     lmc_gpio_mkinput(sc, 0xff);
  610.                     
  611.                     sc->lmc_miireg16 |= LMC_MII16_FIFO_RESET;
  612.                     lmc_mii_writereg(sc, 0, 16, sc->lmc_miireg16);
  614.                     sc->lmc_miireg16 &= ~LMC_MII16_FIFO_RESET;
  615.                     lmc_mii_writereg(sc, 0, 16, sc->lmc_miireg16);
  617.                     kfree(data);
  618.                     
  619.                     ret = 0;
  620.                     
  621.                     break;
  622.                 }
  623.             default: /*fold02*/
  624.                 ret = -EBADE;
  625.                 break;
  626.             }
  628.             LMC_XMITTER_FREE(dev);
  629.             sc->lmc_txfull = 0;
  631.         }
  632.         break;
  633.     default: /*fold01*/
  634.         /* If we don't know what to do, give the protocol a shot. */
  635.         ret = lmc_proto_ioctl (sc, ifr, cmd);
  636.         break;
  637.     }
  639.     spin_unlock_irqrestore(&sc->lmc_lock, flags); /*fold01*/
  641.     lmc_trace(dev, "lmc_ioctl out");
  643.     return ret;
  644. }
  647. /* the watchdog process that cruises around */
  648. static void lmc_watchdog (unsigned long data) /*fold00*/
  649. {
  650.     struct net_device *dev = (struct net_device *) data;
  651.     lmc_softc_t *sc;
  652.     int link_status;
  653.     u_int32_t ticks;
  654.     LMC_SPIN_FLAGS;
  656.     sc = dev->priv;
  658.     lmc_trace(dev, "lmc_watchdog in");
  660.     spin_lock_irqsave(&sc->lmc_lock, flags);
  662.     if(sc->check != 0xBEAFCAFE){
  663.         printk("LMC: Corrupt net_device stuct, breaking outn");
  664. spin_unlock_irqrestore(&sc->lmc_lock, flags);
  665.         return;
  666.     }
  669.     /* Make sure the tx jabber and rx watchdog are off,
  670.      * and the transmit and receive processes are running.
  671.      */
  673.     LMC_CSR_WRITE (sc, csr_15, 0x00000011);
  674.     sc->lmc_cmdmode |= TULIP_CMD_TXRUN | TULIP_CMD_RXRUN;
  675.     LMC_CSR_WRITE (sc, csr_command, sc->lmc_cmdmode);
  677.     if (sc->lmc_ok == 0)
  678.         goto kick_timer;
  680.     LMC_EVENT_LOG(LMC_EVENT_WATCHDOG, LMC_CSR_READ (sc, csr_status), lmc_mii_readreg (sc, 0, 16));
  682.     /* --- begin time out check -----------------------------------
  683.      * check for a transmit interrupt timeout
  684.      * Has the packet xmt vs xmt serviced threshold been exceeded */
  685.     if (sc->lmc_taint_tx == sc->lastlmc_taint_tx &&
  686.         sc->stats.tx_packets > sc->lasttx_packets &&
  687.         sc->tx_TimeoutInd == 0)
  688.     {
  690.         /* wait for the watchdog to come around again */
  691.         sc->tx_TimeoutInd = 1;
  692.     }
  693.     else if (sc->lmc_taint_tx == sc->lastlmc_taint_tx &&
  694.              sc->stats.tx_packets > sc->lasttx_packets &&
  695.              sc->tx_TimeoutInd)
  696.     {
  698.         LMC_EVENT_LOG(LMC_EVENT_XMTINTTMO, LMC_CSR_READ (sc, csr_status), 0);
  700.         sc->tx_TimeoutDisplay = 1;
  701.         sc->stats.tx_TimeoutCnt++;
  703.         /* DEC chip is stuck, hit it with a RESET!!!! */
  704.         lmc_running_reset (dev);
  707.         /* look at receive & transmit process state to make sure they are running */
  708.         LMC_EVENT_LOG(LMC_EVENT_RESET1, LMC_CSR_READ (sc, csr_status), 0);
  710.         /* look at: DSR - 02  for Reg 16
  711.          *                  CTS - 08
  712.          *                  DCD - 10
  713.          *                  RI  - 20
  714.          * for Reg 17
  715.          */
  716.         LMC_EVENT_LOG(LMC_EVENT_RESET2, lmc_mii_readreg (sc, 0, 16), lmc_mii_readreg (sc, 0, 17));
  718.         /* reset the transmit timeout detection flag */
  719.         sc->tx_TimeoutInd = 0;
  720.         sc->lastlmc_taint_tx = sc->lmc_taint_tx;
  721.         sc->lasttx_packets = sc->stats.tx_packets;
  722.     }
  723.     else
  724.     {
  725.         sc->tx_TimeoutInd = 0;
  726.         sc->lastlmc_taint_tx = sc->lmc_taint_tx;
  727.         sc->lasttx_packets = sc->stats.tx_packets;
  728.     }
  730.     /* --- end time out check ----------------------------------- */
  733.     link_status = sc->lmc_media->get_link_status (sc);
  735.     /*
  736.      * hardware level link lost, but the interface is marked as up.
  737.      * Mark it as down.
  738.      */
  739.     if ((link_status == 0) && (sc->last_link_status != 0)) {
  740.         printk(KERN_WARNING "%s: hardware/physical link downn", dev->name);
  741.         sc->last_link_status = 0;
  742.         /* lmc_reset (sc); Why reset??? The link can go down ok */
  744.         /* Inform the world that link has been lost */
  745.         dev->flags &= ~IFF_RUNNING;
  746.     }
  748.     /*
  749.      * hardware link is up, but the interface is marked as down.
  750.      * Bring it back up again.
  751.      */
  752.      if (link_status != 0 && sc->last_link_status == 0) {
  753.          printk(KERN_WARNING "%s: hardware/physical link upn", dev->name);
  754.          sc->last_link_status = 1;
  755.          /* lmc_reset (sc); Again why reset??? */
  757.          /* Inform the world that link protocol is back up. */
  758.          dev->flags |= IFF_RUNNING;
  760.          /* Now we have to tell the syncppp that we had an outage
  761.           * and that it should deal.  Calling sppp_reopen here
  762.           * should do the trick, but we may have to call sppp_close
  763.           * when the link goes down, and call sppp_open here.
  764.           * Subject to more testing.
  765.           * --bbraun
  766.           */
  768.          lmc_proto_reopen(sc);
  770.      }
  772.     /* Call media specific watchdog functions */
  773.     sc->lmc_media->watchdog(sc);
  775.     /*
  776.      * Poke the transmitter to make sure it
  777.      * never stops, even if we run out of mem
  778.      */
  779.     LMC_CSR_WRITE(sc, csr_rxpoll, 0);
  781.     /*
  782.      * Check for code that failed
  783.      * and try and fix it as appropriate
  784.      */
  785.     if(sc->failed_ring == 1){
  786.         /*
  787.          * Failed to setup the recv/xmit rin
  788.          * Try again
  789.          */
  790.         sc->failed_ring = 0;
  791.         lmc_softreset(sc);
  792.     }
  793.     if(sc->failed_recv_alloc == 1){
  794.         /*
  795.          * We failed to alloc mem in the
  796.          * interrupt handler, go through the rings
  797.          * and rebuild them
  798.          */
  799.         sc->failed_recv_alloc = 0;
  800.         lmc_softreset(sc);
  801.     }
  804.     /*
  805.      * remember the timer value
  806.      */
  807. kick_timer:
  809.     ticks = LMC_CSR_READ (sc, csr_gp_timer);
  810.     LMC_CSR_WRITE (sc, csr_gp_timer, 0xffffffffUL);
  811.     sc->ictl.ticks = 0x0000ffff - (ticks & 0x0000ffff);
  813.     /*
  814.      * restart this timer.
  815.      */
  816.     sc->timer.expires = jiffies + (HZ);
  817.     add_timer (&sc->timer);
  819.     spin_unlock_irqrestore(&sc->lmc_lock, flags);
  821.     lmc_trace(dev, "lmc_watchdog out");
  823. }
  825. static int lmc_init(struct net_device * const dev) /*fold00*/
  826. {
  827.     lmc_trace(dev, "lmc_init in");
  828.     lmc_trace(dev, "lmc_init out");
  830.     return 0;
  831. }
  833. /* This initializes each card from lmc_probe() */
  834. static struct net_device *lmc_probe1 (struct net_device *dev, unsigned long ioaddr, unsigned int irq, /*fold00*/
  835.                                   int chip_id, int subdevice, int board_idx)
  836. {
  837.     lmc_softc_t *sc = NULL;
  838.     u_int16_t AdapModelNum;
  840.     /*
  841.      * Allocate our own device structure
  842.      */
  844. #if LINUX_VERSION_CODE < 0x20363
  845.     dev = kmalloc (sizeof (struct ppp_device)+8, GFP_KERNEL);
  846. #else
  847.     dev = kmalloc (sizeof (struct net_device)+8, GFP_KERNEL);
  848. #endif
  849.     if (dev == NULL){
  850.         printk (KERN_ERR "lmc: kmalloc for device failedn");
  851.         return NULL;
  852.     }
  853.     memset (dev, 0, sizeof (struct net_device));
  855. #ifndef GCOM
  856.     /*
  857.      * Switch to common hdlc%d naming. We name by type not by vendor
  858.      */
  859.     
  860.     dev_alloc_name(dev, "hdlc%d");
  861. #else
  862.     /*
  863.      * GCOM uses LMC vendor name so that clients can know which card
  864.      * to attach to.
  865.      */
  866.     dev_alloc_name(dev, "lmc%d");
  867. #endif
  869.     lmc_trace(dev, "lmc_probe1 in");
  870.     
  871.     Lmc_Count++;
  873.     if(lmc_first_load == 0){
  874.         printk(KERN_INFO "Lan Media Corporation WAN Driver Version %d.%d.%dn",DRIVER_MAJOR_VERSION, DRIVER_MINOR_VERSION,DRIVER_SUB_VERSION);
  875.         lmc_first_load = 1;
  876.     }
  877.     
  878.     /*
  879.      * Allocate space for the private data structure
  880.      */
  882.     sc = kmalloc (sizeof (lmc_softc_t), GFP_KERNEL);
  883.     if (sc == NULL) {
  884.         printk (KERN_WARNING "%s: Cannot allocate memory for device staten",
  885.                 dev->name);
  886.         return (NULL);
  887.     }
  888.     memset (sc, 0, sizeof (lmc_softc_t));
  889.     dev->priv = sc;
  890.     sc->lmc_device = dev;
  891.     sc->name = dev->name;
  893.     /* Initialize the sppp layer */
  894.     /* An ioctl can cause a subsequent detach for raw frame interface */
  895.     sc->if_type = LMC_PPP;
  896.     sc->check = 0xBEAFCAFE;
  897.     dev->base_addr = ioaddr;
  898.     dev->irq = irq;
  899.     /*
  900.      * This will get the protocol layer ready and do any 1 time init's
  901.      * Must have a valid sc and dev structure
  902.      */
  903.     lmc_proto_init(sc);
  905.     lmc_proto_attach(sc);
  907.     /* Just fill in the entries for the device */
  909.     dev->init = lmc_init;
  910.     dev->type = ARPHRD_HDLC;
  911.     dev->hard_start_xmit = lmc_start_xmit;
  912.     dev->open = lmc_open;
  913.     dev->stop = lmc_close;
  914.     dev->get_stats = lmc_get_stats;
  915.     dev->do_ioctl = lmc_ioctl;
  916.     dev->set_config = lmc_set_config;
  917. #if LINUX_VERSION_CODE >= 0x20363
  918.     dev->tx_timeout = lmc_driver_timeout;
  919.     dev->watchdog_timeo = (HZ); /* 1 second */
  920. #endif
  921.     
  922.     /*
  923.      * Why were we changing this???
  924.      dev->tx_queue_len = 100;
  925.      */
  927.     /* Init the spin lock so can call it latter */
  929.     spin_lock_init(&sc->lmc_lock);
  931.     LMC_SETUP_20_DEV;
  933.     printk ("%s: detected at %lx, irq %dn", dev->name, ioaddr, dev->irq);
  935.     if (register_netdev (dev) != 0) {
  936.         printk (KERN_ERR "%s: register_netdev failed.n", dev->name);
  937.         lmc_proto_detach(sc);
  938.         kfree (dev->priv);
  939.         kfree (dev);
  940.         return NULL;
  941.     }
  943.     /*
  944.      * Request the region of registers we need, so that
  945.      * later on, no one else will take our card away from
  946.      * us.
  947.      */
  948.     request_region (ioaddr, LMC_REG_RANGE, dev->name);
  950.     sc->lmc_cardtype = LMC_CARDTYPE_UNKNOWN;
  951.     sc->lmc_timing = LMC_CTL_CLOCK_SOURCE_EXT;
  953.     switch (subdevice) {
  954.     case PCI_PRODUCT_LMC_HSSI:
  955.         printk ("%s: LMC HSSIn", dev->name);
  956.         sc->lmc_cardtype = LMC_CARDTYPE_HSSI;
  957.         sc->lmc_media = &lmc_hssi_media;
  958.         break;
  959.     case PCI_PRODUCT_LMC_DS3:
  960.         printk ("%s: LMC DS3n", dev->name);
  961.         sc->lmc_cardtype = LMC_CARDTYPE_DS3;
  962.         sc->lmc_media = &lmc_ds3_media;
  963.         break;
  964.     case PCI_PRODUCT_LMC_SSI:
  965.         printk ("%s: LMC SSIn", dev->name);
  966.         sc->lmc_cardtype = LMC_CARDTYPE_SSI;
  967.         sc->lmc_media = &lmc_ssi_media;
  968.         break;
  969.     case PCI_PRODUCT_LMC_T1:
  970.         printk ("%s: LMC T1n", dev->name);
  971.         sc->lmc_cardtype = LMC_CARDTYPE_T1;
  972.         sc->lmc_media = &lmc_t1_media;
  973.         break;
  974.     default:
  975.         printk (KERN_WARNING "%s: LMC UNKOWN CARD!n", dev->name);
  976.         break;
  977.     }
  979.     lmc_initcsrs (sc, dev->base_addr, 8);
  981.     lmc_gpio_mkinput (sc, 0xff);
  982.     sc->lmc_gpio = 0; /* drive no signals yet */
  984.     sc->lmc_media->defaults (sc);
  986.     sc->lmc_media->set_link_status (sc, LMC_LINK_UP);
  988.     /* verify that the PCI Sub System ID matches the Adapter Model number
  989.      * from the MII register
  990.      */
  991.     AdapModelNum = (lmc_mii_readreg (sc, 0, 3) & 0x3f0) >> 4;
  993.     if ((AdapModelNum == LMC_ADAP_T1
  994.          && subdevice == PCI_PRODUCT_LMC_T1) || /* detect LMC1200 */
  995.         (AdapModelNum == LMC_ADAP_SSI
  996.          && subdevice == PCI_PRODUCT_LMC_SSI) || /* detect LMC1000 */
  997.         (AdapModelNum == LMC_ADAP_DS3
  998.          && subdevice == PCI_PRODUCT_LMC_DS3) || /* detect LMC5245 */
  999.         (AdapModelNum == LMC_ADAP_HSSI
  1000.          && subdevice == PCI_PRODUCT_LMC_HSSI))
  1001.     { /* detect LMC5200 */
  1003.     }
  1004.     else {
  1005.         printk ("%s: Model number (%d) miscompare for PCI Subsystem ID = 0x%04xn",
  1006.                 dev->name, AdapModelNum, subdevice);
  1007. //        return (NULL);
  1008.     }
  1009.     /*
  1010.      * reset clock
  1011.      */
  1012.     LMC_CSR_WRITE (sc, csr_gp_timer, 0xFFFFFFFFUL);
  1014.     sc->board_idx = board_idx;
  1016.     memset (&sc->stats, 0, sizeof (struct lmc_statistics));
  1018.     sc->stats.check = STATCHECK;
  1019.     sc->stats.version_size = (DRIVER_VERSION << 16) +
  1020.         sizeof (struct lmc_statistics);
  1021.     sc->stats.lmc_cardtype = sc->lmc_cardtype;
  1023.     sc->lmc_ok = 0;
  1024.     sc->last_link_status = 0;
  1026.     lmc_trace(dev, "lmc_probe1 out");
  1028.     return dev;
  1029. }
  1032. /* This is the entry point.  This is what is called immediatly. */
  1033. /* This goes out and finds the card */
  1035. int lmc_probe_fake(struct net_device *dev) /*fold00*/
  1036. {
  1037.     lmc_probe(NULL);
  1038.     /* Return 1 to unloaded bogus device */
  1039.     return 1;
  1040. }
  1042. int lmc_probe (struct net_device *dev) /*fold00*/
  1043. {
  1044.     int pci_index = 0;
  1045.     unsigned long pci_ioaddr;
  1046.     unsigned int pci_irq_line;
  1047.     u16 vendor, subvendor, device, subdevice;
  1048.     u32 foundaddr = 0;
  1049.     unsigned char pci_bus, pci_device_fn;
  1050.     u8 intcf = 0;
  1052.     /* The card is only available on PCI, so if we don't have a
  1053.      * PCI bus, we are in trouble.
  1054.      */
  1056.     if (!LMC_PCI_PRESENT()) {
  1057. /*        printk ("%s: We really want a pci bios!n", dev->name);*/
  1058.         return -1;
  1059.     }
  1060.     /* Loop basically until we don't find anymore. */
  1061.     while (pci_index < 0xff){
  1062.      struct pci_dev *pdev;
  1063.         /* The tulip is considered an ethernet class of card... */
  1064.         if (pcibios_find_class (PCI_CLASS_NETWORK_ETHERNET << 8,
  1065.                                 pci_index, &pci_bus,
  1066.                                 &pci_device_fn) != PCIBIOS_SUCCESSFUL) {
  1067.             /* No card found on this pass */
  1068.             break;
  1069.         }
  1070.         /* Read the info we need to determine if this is
  1071.          * our card or not
  1072.          */
  1073. pdev = pci_find_slot (pci_bus, pci_device_fn);
  1074. if (!pdev) break;
  1076. if (pci_enable_device(pdev))
  1077. break;
  1079.         vendor = pdev->vendor;
  1080.         device = pdev->device;
  1081.         pci_irq_line = pdev->irq;
  1082.         pci_ioaddr = pci_resource_start (pdev, 0);
  1083. subvendor = pdev->subsystem_vendor;
  1084. subdevice = pdev->subsystem_device;
  1086. pci_set_master (pdev);
  1088.         /*
  1089.          * Make sure it's the correct card.  CHECK SUBVENDOR ID!
  1090.          * There are lots of tulip's out there.
  1091.          * Also check the region of registers we will soon be
  1092.          * poking, to make sure no one else has reserved them.
  1093.          * This prevents taking someone else's device.
  1094.          *
  1095.          * Check either the subvendor or the subdevice, some systems reverse
  1096.          * the setting in the bois, seems to be version and arch dependant?
  1097.          * Fix the two variables
  1098.          *
  1099.          */
  1100.         if (!(check_region (pci_ioaddr, LMC_REG_RANGE)) &&
  1101.             (vendor == CORRECT_VENDOR_ID) &&
  1102.             (device == CORRECT_DEV_ID) &&
  1103.             ((subvendor == PCI_VENDOR_LMC)  || (subdevice == PCI_VENDOR_LMC))){
  1104.             struct net_device *cur, *prev = NULL;
  1106.             /* Fix the error, exchange the two values */
  1107.             if(subdevice == PCI_VENDOR_LMC){
  1108.                 subdevice = subvendor;
  1109.                 subvendor = PCI_VENDOR_LMC ;
  1110.             }
  1112.             /* Make the call to actually setup this card */
  1113.             dev = lmc_probe1 (dev, pci_ioaddr, pci_irq_line,
  1114.                               device, subdevice, cards_found);
  1115.             if (dev == NULL) {
  1116.                 printk ("lmc_probe: lmc_probe1 failedn");
  1117.                 goto lmc_probe_next_card;
  1118.             }
  1119.             /* insert the device into the chain of lmc devices */
  1120.             for (cur = Lmc_root_dev;
  1121.                  cur != NULL;
  1122.                  cur = ((lmc_softc_t *) cur->priv)->next_module) {
  1123.                 prev = cur;
  1124.             }
  1126.             if (prev == NULL)
  1127.                 Lmc_root_dev = dev;
  1128.             else
  1129.                 ((lmc_softc_t *) prev->priv)->next_module = dev;
  1131.             ((lmc_softc_t *) dev->priv)->next_module = NULL;
  1132.             /* end insert */
  1134.             foundaddr = dev->base_addr;
  1136.             cards_found++;
  1137.             intcf++;
  1138.         }
  1139.     lmc_probe_next_card:
  1140.         pci_index++;
  1141.     }
  1143.     if (cards_found < 1)
  1144.         return -1;
  1146. #if LINUX_VERSION_CODE >= 0x20200
  1147.     return foundaddr;
  1148. #else
  1149.     return 0;
  1150. #endif
  1151. }
  1153. /* After this is called, packets can be sent.
  1154.  * Does not initialize the addresses
  1155.  */
  1156. static int lmc_open (struct net_device *dev) /*fold00*/
  1157. {
  1158.     lmc_softc_t *sc = dev->priv;
  1160.     lmc_trace(dev, "lmc_open in");
  1162.     lmc_led_on(sc, LMC_DS3_LED0);
  1164.     lmc_dec_reset (sc);
  1165.     lmc_reset (sc);
  1167.     LMC_EVENT_LOG(LMC_EVENT_RESET1, LMC_CSR_READ (sc, csr_status), 0);
  1168.     LMC_EVENT_LOG(LMC_EVENT_RESET2,
  1169.                   lmc_mii_readreg (sc, 0, 16),
  1170.                   lmc_mii_readreg (sc, 0, 17));
  1173.     if (sc->lmc_ok){
  1174.         lmc_trace(dev, "lmc_open lmc_ok out");
  1175.         return (0);
  1176.     }
  1178.     lmc_softreset (sc);
  1180.     /* Since we have to use PCI bus, this should work on x86,alpha,ppc */
  1181.     if (request_irq (dev->irq, &lmc_interrupt, SA_SHIRQ, dev->name, dev)){
  1182.         printk(KERN_WARNING "%s: could not get irq: %dn", dev->name, dev->irq);
  1183.         lmc_trace(dev, "lmc_open irq failed out");
  1184.         return -EAGAIN;
  1185.     }
  1186.     sc->got_irq = 1;
  1188.     /* Assert Terminal Active */
  1189.     sc->lmc_miireg16 |= LMC_MII16_LED_ALL;
  1190.     sc->lmc_media->set_link_status (sc, LMC_LINK_UP);
  1192.     /*
  1193.      * reset to last state.
  1194.      */
  1195.     sc->lmc_media->set_status (sc, NULL);
  1197.     /* setup default bits to be used in tulip_desc_t transmit descriptor
  1198.      * -baz */
  1199.     sc->TxDescriptControlInit = (
  1200.                                  LMC_TDES_INTERRUPT_ON_COMPLETION
  1201.                                  | LMC_TDES_FIRST_SEGMENT
  1202.                                  | LMC_TDES_LAST_SEGMENT
  1203.                                  | LMC_TDES_SECOND_ADDR_CHAINED
  1204.                                  | LMC_TDES_DISABLE_PADDING
  1205.                                 );
  1207.     if (sc->ictl.crc_length == LMC_CTL_CRC_LENGTH_16) {
  1208.         /* disable 32 bit CRC generated by ASIC */
  1209.         sc->TxDescriptControlInit |= LMC_TDES_ADD_CRC_DISABLE;
  1210.     }
  1211.     sc->lmc_media->set_crc_length(sc, sc->ictl.crc_length);
  1212.     /* Acknoledge the Terminal Active and light LEDs */
  1214.     /* dev->flags |= IFF_UP; */
  1216.     lmc_proto_open(sc);
  1218.     dev->do_ioctl = lmc_ioctl;
  1221.     LMC_XMITTER_INIT(dev);
  1222.     
  1223. #if LINUX_VERSION_CODE < 0x20363
  1224.     dev->start = 1;
  1225. #endif
  1226.     
  1227.     sc->stats.tx_tbusy0++ ;
  1229.     MOD_INC_USE_COUNT;
  1231.     /*
  1232.      * select what interrupts we want to get
  1233.      */
  1234.     sc->lmc_intrmask = 0;
  1235.     /* Should be using the default interrupt mask defined in the .h file. */
  1236.     sc->lmc_intrmask |= (TULIP_STS_NORMALINTR
  1237.                          | TULIP_STS_RXINTR
  1238.                          | TULIP_STS_TXINTR
  1239.                          | TULIP_STS_ABNRMLINTR
  1240.                          | TULIP_STS_SYSERROR
  1241.                          | TULIP_STS_TXSTOPPED
  1242.                          | TULIP_STS_TXUNDERFLOW
  1243.                          | TULIP_STS_RXSTOPPED
  1244.          | TULIP_STS_RXNOBUF
  1245.                         );
  1246.     LMC_CSR_WRITE (sc, csr_intr, sc->lmc_intrmask);
  1248.     sc->lmc_cmdmode |= TULIP_CMD_TXRUN;
  1249.     sc->lmc_cmdmode |= TULIP_CMD_RXRUN;
  1250.     LMC_CSR_WRITE (sc, csr_command, sc->lmc_cmdmode);
  1252.     sc->lmc_ok = 1; /* Run watchdog */
  1254.     /*
  1255.      * Set the if up now - pfb
  1256.      */
  1258.     sc->last_link_status = 1;
  1260.     /*
  1261.      * Setup a timer for the watchdog on probe, and start it running.
  1262.      * Since lmc_ok == 0, it will be a NOP for now.
  1263.      */
  1264.     init_timer (&sc->timer);
  1265.     sc->timer.expires = jiffies + HZ;
  1266.     sc->timer.data = (unsigned long) dev;
  1267.     sc->timer.function = &lmc_watchdog;
  1268.     add_timer (&sc->timer);
  1270.     lmc_trace(dev, "lmc_open out");
  1272.     return (0);
  1273. }
  1275. /* Total reset to compensate for the AdTran DSU doing bad things
  1276.  *  under heavy load
  1277.  */
  1279. static void lmc_running_reset (struct net_device *dev) /*fold00*/
  1280. {
  1282.     lmc_softc_t *sc = (lmc_softc_t *) dev->priv;
  1284.     lmc_trace(dev, "lmc_runnig_reset in");
  1286.     /* stop interrupts */
  1287.     /* Clear the interrupt mask */
  1288.     LMC_CSR_WRITE (sc, csr_intr, 0x00000000);
  1290.     lmc_dec_reset (sc);
  1291.     lmc_reset (sc);
  1292.     lmc_softreset (sc);
  1293.     /* sc->lmc_miireg16 |= LMC_MII16_LED_ALL; */
  1294.     sc->lmc_media->set_link_status (sc, 1);
  1295.     sc->lmc_media->set_status (sc, NULL);
  1297.     //dev->flags |= IFF_RUNNING;
  1298.     
  1299.     LMC_XMITTER_FREE(dev);
  1301.     sc->lmc_txfull = 0;
  1302.     sc->stats.tx_tbusy0++ ;
  1304.     sc->lmc_intrmask = TULIP_DEFAULT_INTR_MASK;
  1305.     LMC_CSR_WRITE (sc, csr_intr, sc->lmc_intrmask);
  1307.     sc->lmc_cmdmode |= (TULIP_CMD_TXRUN | TULIP_CMD_RXRUN);
  1308.     LMC_CSR_WRITE (sc, csr_command, sc->lmc_cmdmode);
  1310.     lmc_trace(dev, "lmc_runnin_reset_out");
  1311. }
  1314. /* This is what is called when you ifconfig down a device.
  1315.  * This disables the timer for the watchdog and keepalives,
  1316.  * and disables the irq for dev.
  1317.  */
  1318. static int lmc_close (struct net_device *dev) /*fold00*/
  1319. {
  1320.     /* not calling release_region() as we should */
  1321.     lmc_softc_t *sc;
  1323.     lmc_trace(dev, "lmc_close in");
  1324.     
  1325.     sc = dev->priv;
  1326.     sc->lmc_ok = 0;
  1327.     sc->lmc_media->set_link_status (sc, 0);
  1328.     del_timer (&sc->timer);
  1329.     lmc_proto_close(sc);
  1330.     lmc_ifdown (dev);
  1332.     lmc_trace(dev, "lmc_close out");
  1333.     
  1334.     return 0;
  1335. }
  1337. /* Ends the transfer of packets */
  1338. /* When the interface goes down, this is called */
  1339. static int lmc_ifdown (struct net_device *dev) /*fold00*/
  1340. {
  1341.     lmc_softc_t *sc = dev->priv;
  1342.     u32 csr6;
  1343.     int i;
  1345.     lmc_trace(dev, "lmc_ifdown in");
  1346.     
  1347.     /* Don't let anything else go on right now */
  1348.     //    dev->start = 0;
  1349.     LMC_XMITTER_BUSY(dev);
  1350.     sc->stats.tx_tbusy1++ ;
  1352.     /* stop interrupts */
  1353.     /* Clear the interrupt mask */
  1354.     LMC_CSR_WRITE (sc, csr_intr, 0x00000000);
  1356.     /* Stop Tx and Rx on the chip */
  1357.     csr6 = LMC_CSR_READ (sc, csr_command);
  1358.     csr6 &= ~LMC_DEC_ST; /* Turn off the Transmission bit */
  1359.     csr6 &= ~LMC_DEC_SR; /* Turn off the Receive bit */
  1360.     LMC_CSR_WRITE (sc, csr_command, csr6);
  1362.     dev->flags &= ~IFF_RUNNING;
  1364.     sc->stats.rx_missed_errors +=
  1365.         LMC_CSR_READ (sc, csr_missed_frames) & 0xffff;
  1367.     /* release the interrupt */
  1368.     if(sc->got_irq == 1){
  1369.         free_irq (dev->irq, dev);
  1370.         sc->got_irq = 0;
  1371.     }
  1373.     /* free skbuffs in the Rx queue */
  1374.     for (i = 0; i < LMC_RXDESCS; i++)
  1375.     {
  1376.         struct sk_buff *skb = sc->lmc_rxq[i];
  1377.         sc->lmc_rxq[i] = 0;
  1378.         sc->lmc_rxring[i].status = 0;
  1379.         sc->lmc_rxring[i].length = 0;
  1380.         sc->lmc_rxring[i].buffer1 = 0xDEADBEEF;
  1381.         if (skb != NULL)
  1382.         {
  1383.             LMC_SKB_FREE(skb, 1);
  1384.             LMC_DEV_KFREE_SKB (skb);
  1385.         }
  1386.         sc->lmc_rxq[i] = NULL;
  1387.     }
  1389.     for (i = 0; i < LMC_TXDESCS; i++)
  1390.     {
  1391.         if (sc->lmc_txq[i] != NULL)
  1392.             LMC_DEV_KFREE_SKB (sc->lmc_txq[i]);
  1393.         sc->lmc_txq[i] = NULL;
  1394.     }
  1396.     lmc_led_off (sc, LMC_MII16_LED_ALL);
  1398.     LMC_XMITTER_FREE(dev);
  1399.     sc->stats.tx_tbusy0++ ;
  1401.     lmc_trace(dev, "lmc_ifdown out");
  1403.     MOD_DEC_USE_COUNT;
  1404.     return 0;
  1405. }
  1407. /* Interrupt handling routine.  This will take an incoming packet, or clean
  1408.  * up after a trasmit.
  1409.  */
  1410. static void lmc_interrupt (int irq, void *dev_instance, struct pt_regs *regs) /*fold00*/
  1411. {
  1412.     struct net_device *dev = (struct net_device *) dev_instance;
  1413.     lmc_softc_t *sc;
  1414.     u32 csr;
  1415.     int i;
  1416.     s32 stat;
  1417.     unsigned int badtx;
  1418.     u32 firstcsr;
  1419.     int max_work = LMC_RXDESCS;
  1421.     lmc_trace(dev, "lmc_interrupt in");
  1423.     sc = dev->priv;
  1424.     
  1425.     spin_lock(&sc->lmc_lock);
  1427.     /*
  1428.      * Read the csr to find what interrupts we have (if any)
  1429.      */
  1430.     csr = LMC_CSR_READ (sc, csr_status);
  1432.     /*
  1433.      * Make sure this is our interrupt
  1434.      */
  1435.     if ( ! (csr & sc->lmc_intrmask)) {
  1436.         goto lmc_int_fail_out;
  1437.     }
  1439.     firstcsr = csr;
  1441.     /* always go through this loop at least once */
  1442.     while (csr & sc->lmc_intrmask) {
  1443.         /*
  1444.          * Clear interrupt bits, we handle all case below
  1445.          */
  1446.         LMC_CSR_WRITE (sc, csr_status, csr);
  1448.         /*
  1449.          * One of
  1450.          *  - Transmit process timed out CSR5<1>
  1451.          *  - Transmit jabber timeout    CSR5<3>
  1452.          *  - Transmit underflow         CSR5<5>
  1453.          *  - Transmit Receiver buffer unavailable CSR5<7>
  1454.          *  - Receive process stopped    CSR5<8>
  1455.          *  - Receive watchdog timeout   CSR5<9>
  1456.          *  - Early transmit interrupt   CSR5<10>
  1457.          *
  1458.          * Is this really right? Should we do a running reset for jabber?
  1459.          * (being a WAN card and all)
  1460.          */
  1461.         if (csr & TULIP_STS_ABNRMLINTR){
  1462.             lmc_running_reset (dev);
  1463.             break;
  1464.         }
  1465.         
  1466.         if (csr & TULIP_STS_RXINTR){
  1467.             lmc_trace(dev, "rx interrupt");
  1468.             lmc_rx (dev);
  1469.             
  1470.         }
  1471.         if (csr & (TULIP_STS_TXINTR | TULIP_STS_TXNOBUF | TULIP_STS_TXSTOPPED)) {
  1473.     int n_compl = 0 ;
  1474.             /* reset the transmit timeout detection flag -baz */
  1475.             sc->stats.tx_NoCompleteCnt = 0;
  1477.             badtx = sc->lmc_taint_tx;
  1478.             i = badtx % LMC_TXDESCS;
  1480.             while ((badtx < sc->lmc_next_tx)) {
  1481.                 stat = sc->lmc_txring[i].status;
  1483.                 LMC_EVENT_LOG (LMC_EVENT_XMTINT, stat,
  1484.  sc->lmc_txring[i].length);
  1485.                 /*
  1486.                  * If bit 31 is 1 the tulip owns it break out of the loop
  1487.                  */
  1488.                 if (stat & 0x80000000)
  1489.                     break;
  1491. n_compl++ ; /* i.e., have an empty slot in ring */
  1492.                 /*
  1493.                  * If we have no skbuff or have cleared it
  1494.                  * Already continue to the next buffer
  1495.                  */
  1496.                 if (sc->lmc_txq[i] == NULL)
  1497.                     continue;
  1499.                 /*
  1500.                  * Check the total error summary to look for any errors
  1501.                  */
  1502.                 if (stat & 0x8000) {
  1503.                     sc->stats.tx_errors++;
  1504.                     if (stat & 0x4104)
  1505.                         sc->stats.tx_aborted_errors++;
  1506.                     if (stat & 0x0C00)
  1507.                         sc->stats.tx_carrier_errors++;
  1508.                     if (stat & 0x0200)
  1509.                         sc->stats.tx_window_errors++;
  1510.                     if (stat & 0x0002)
  1511.                         sc->stats.tx_fifo_errors++;
  1512.                 }
  1513.                 else {
  1514.                     
  1515. #if LINUX_VERSION_CODE >= 0x20200
  1516.                     sc->stats.tx_bytes += sc->lmc_txring[i].length & 0x7ff;
  1517. #endif
  1518.                     
  1519.                     sc->stats.tx_packets++;
  1520.                 }
  1521.                 
  1522.                 //                LMC_DEV_KFREE_SKB (sc->lmc_txq[i]);
  1523.                 dev_kfree_skb_irq(sc->lmc_txq[i]);
  1524.                 sc->lmc_txq[i] = 0;
  1526.                 badtx++;
  1527.                 i = badtx % LMC_TXDESCS;
  1528.             }
  1530.             if (sc->lmc_next_tx - badtx > LMC_TXDESCS)
  1531.             {
  1532.                 printk ("%s: out of sync pointern", dev->name);
  1533.                 badtx += LMC_TXDESCS;
  1534.             }
  1535.             LMC_EVENT_LOG(LMC_EVENT_TBUSY0, n_compl, 0);
  1536.             sc->lmc_txfull = 0;
  1537.             LMC_XMITTER_FREE(dev);
  1538.             sc->stats.tx_tbusy0++ ;
  1539. #if LINUX_VERSION_CODE < 0x20363
  1540.             mark_bh (NET_BH); /* Tell Linux to give me more packets */
  1541. #endif
  1544. #ifdef DEBUG
  1545.             sc->stats.dirtyTx = badtx;
  1546.             sc->stats.lmc_next_tx = sc->lmc_next_tx;
  1547.             sc->stats.lmc_txfull = sc->lmc_txfull;
  1548. #if LINUX_VERSION_CODE < 0x20363
  1549.             sc->stats.tbusy = dev->tbusy;
  1550. #endif
  1551. #endif
  1552.             sc->lmc_taint_tx = badtx;
  1554.             /*
  1555.              * Why was there a break here???
  1556.              */
  1557.         } /* end handle transmit interrupt */
  1559.         if (csr & TULIP_STS_SYSERROR) {
  1560.             u32 error;
  1561.             printk (KERN_WARNING "%s: system bus error csr: %#8.8xn", dev->name, csr);
  1562.             error = csr>>23 & 0x7;
  1563.             switch(error){
  1564.             case 0x000:
  1565.                 printk(KERN_WARNING "%s: Parity Fault (bad)n", dev->name);
  1566.                 break;
  1567.             case 0x001:
  1568.                 printk(KERN_WARNING "%s: Master Abort (naughty)n", dev->name);
  1569.                 break;
  1570.             case 0x010:
  1571.                 printk(KERN_WARNING "%s: Target Abort (not so naughty)n", dev->name);
  1572.                 break;
  1573.             default:
  1574.                 printk(KERN_WARNING "%s: This bus error code was supposed to be reserved!n", dev->name);
  1575.             }
  1576.             lmc_dec_reset (sc);
  1577.             lmc_reset (sc);
  1578.             LMC_EVENT_LOG(LMC_EVENT_RESET1, LMC_CSR_READ (sc, csr_status), 0);
  1579.             LMC_EVENT_LOG(LMC_EVENT_RESET2,
  1580.                           lmc_mii_readreg (sc, 0, 16),
  1581.                           lmc_mii_readreg (sc, 0, 17));
  1583.         }
  1585.         
  1586.         if(max_work-- <= 0)
  1587.             break;
  1588.         
  1589.         /*
  1590.          * Get current csr status to make sure
  1591.          * we've cleared all interrupts
  1592.          */
  1593.         csr = LMC_CSR_READ (sc, csr_status);
  1594.     } /* end interrupt loop */
  1595.     LMC_EVENT_LOG(LMC_EVENT_INT, firstcsr, csr);
  1597. lmc_int_fail_out:
  1599.     spin_unlock(&sc->lmc_lock);
  1601.     lmc_trace(dev, "lmc_interrupt out");
  1602. }
  1604. static int lmc_start_xmit (struct sk_buff *skb, struct net_device *dev) /*fold00*/
  1605. {
  1606.     lmc_softc_t *sc;
  1607.     u32 flag;
  1608.     int entry;
  1609.     int ret = 0;
  1610.     LMC_SPIN_FLAGS;
  1612.     lmc_trace(dev, "lmc_start_xmit in");
  1614.     sc = dev->priv;
  1616.     spin_lock_irqsave(&sc->lmc_lock, flags);
  1618.     /*
  1619.      * If the transmitter is busy
  1620.      * this must be the 5 second polling
  1621.      * from the kernel which called us.
  1622.      * Poke the chip and try to get it running
  1623.      *
  1624.      */
  1625. #if LINUX_VERSION_CODE < 0x20363
  1626.     if(dev->tbusy != 0){
  1627.         u32 csr6;
  1629.         printk("%s: Xmitter busy|n", dev->name);
  1631. sc->stats.tx_tbusy_calls++ ;
  1632.         if (jiffies - dev->trans_start < TX_TIMEOUT) {
  1633.             ret = 1;
  1634.             goto lmc_start_xmit_bug_out;
  1635.         }
  1637.         /*
  1638.          * Chip seems to have locked up
  1639.          * Reset it
  1640.          * This whips out all our decriptor
  1641.          * table and starts from scartch
  1642.          */
  1644.         LMC_EVENT_LOG(LMC_EVENT_XMTPRCTMO,
  1645.                       LMC_CSR_READ (sc, csr_status),
  1646.                       sc->stats.tx_ProcTimeout);
  1648.         lmc_running_reset (dev);
  1650.         LMC_EVENT_LOG(LMC_EVENT_RESET1, LMC_CSR_READ (sc, csr_status), 0);
  1651.         LMC_EVENT_LOG(LMC_EVENT_RESET2,
  1652.                       lmc_mii_readreg (sc, 0, 16),
  1653.                       lmc_mii_readreg (sc, 0, 17));
  1655.         /* restart the tx processes */
  1656.         csr6 = LMC_CSR_READ (sc, csr_command);
  1657.         LMC_CSR_WRITE (sc, csr_command, csr6 | 0x0002);
  1658.         LMC_CSR_WRITE (sc, csr_command, csr6 | 0x2002);
  1660.         /* immediate transmit */
  1661.         LMC_CSR_WRITE (sc, csr_txpoll, 0);
  1663.         sc->stats.tx_errors++;
  1664.         sc->stats.tx_ProcTimeout++; /* -baz */
  1666.         dev->trans_start = jiffies;
  1668.         ret = 1;
  1669.         goto lmc_start_xmit_bug_out;
  1670.     }
  1671. #endif
  1672.     /* normal path, tbusy known to be zero */
  1674.     entry = sc->lmc_next_tx % LMC_TXDESCS;
  1676.     sc->lmc_txq[entry] = skb;
  1677.     sc->lmc_txring[entry].buffer1 = virt_to_bus (skb->data);
  1679.     LMC_CONSOLE_LOG("xmit", skb->data, skb->len);
  1681. #ifndef GCOM
  1682.     /* If the queue is less than half full, don't interrupt */
  1683.     if (sc->lmc_next_tx - sc->lmc_taint_tx < LMC_TXDESCS / 2)
  1684.     {
  1685.         /* Do not interrupt on completion of this packet */
  1686.         flag = 0x60000000;
  1687.         LMC_XMITTER_FREE(dev);
  1688.     }
  1689.     else if (sc->lmc_next_tx - sc->lmc_taint_tx == LMC_TXDESCS / 2)
  1690.     {
  1691.         /* This generates an interrupt on completion of this packet */
  1692.         flag = 0xe0000000;
  1693.         LMC_XMITTER_FREE(dev);
  1694.     }
  1695.     else if (sc->lmc_next_tx - sc->lmc_taint_tx < LMC_TXDESCS - 1)
  1696.     {
  1697.         /* Do not interrupt on completion of this packet */
  1698.         flag = 0x60000000;
  1699.         LMC_XMITTER_FREE(dev);
  1700.     }
  1701.     else
  1702.     {
  1703.         /* This generates an interrupt on completion of this packet */
  1704.         flag = 0xe0000000;
  1705.         sc->lmc_txfull = 1;
  1706.         LMC_XMITTER_BUSY(dev);
  1707.     }
  1708. #else
  1709.     flag = LMC_TDES_INTERRUPT_ON_COMPLETION;
  1711.     if (sc->lmc_next_tx - sc->lmc_taint_tx >= LMC_TXDESCS - 1)
  1712.     { /* ring full, go busy */
  1713.         sc->lmc_txfull = 1;
  1714.         LMC_XMITTER_BUSY(dev);
  1715.         sc->stats.tx_tbusy1++ ;
  1716.         LMC_EVENT_LOG(LMC_EVENT_TBUSY1, entry, 0);
  1717.     }
  1718. #endif
  1721.     if (entry == LMC_TXDESCS - 1) /* last descriptor in ring */
  1722. flag |= LMC_TDES_END_OF_RING; /* flag as such for Tulip */
  1724.     /* don't pad small packets either */
  1725.     flag = sc->lmc_txring[entry].length = (skb->len) | flag |
  1726. sc->TxDescriptControlInit;
  1728.     /* set the transmit timeout flag to be checked in
  1729.      * the watchdog timer handler. -baz
  1730.      */
  1732.     sc->stats.tx_NoCompleteCnt++;
  1733.     sc->lmc_next_tx++;
  1735.     /* give ownership to the chip */
  1736.     LMC_EVENT_LOG(LMC_EVENT_XMT, flag, entry);
  1737.     sc->lmc_txring[entry].status = 0x80000000;
  1739.     /* send now! */
  1740.     LMC_CSR_WRITE (sc, csr_txpoll, 0);
  1742.     dev->trans_start = jiffies;
  1744. #if LINUX_VERSION_CODE < 0x20363
  1745. lmc_start_xmit_bug_out:
  1746. #endif
  1748.     spin_unlock_irqrestore(&sc->lmc_lock, flags);
  1750.     lmc_trace(dev, "lmc_start_xmit_out");
  1751.     return ret;
  1752. }
  1755. static int lmc_rx (struct net_device *dev) /*fold00*/
  1756. {
  1757.     lmc_softc_t *sc;
  1758.     int i;
  1759.     int rx_work_limit = LMC_RXDESCS;
  1760.     unsigned int next_rx;
  1761.     int rxIntLoopCnt; /* debug -baz */
  1762.     int localLengthErrCnt = 0;
  1763.     long stat;
  1764.     struct sk_buff *skb, *nsb;
  1765.     u16 len;
  1767.     lmc_trace(dev, "lmc_rx in");
  1769.     sc = dev->priv;
  1771.     lmc_led_on(sc, LMC_DS3_LED3);
  1773.     rxIntLoopCnt = 0; /* debug -baz */
  1775.     i = sc->lmc_next_rx % LMC_RXDESCS;
  1776.     next_rx = sc->lmc_next_rx;
  1778.     while (((stat = sc->lmc_rxring[i].status) & LMC_RDES_OWN_BIT) != DESC_OWNED_BY_DC21X4)
  1779.     {
  1780.         rxIntLoopCnt++; /* debug -baz */
  1781.         len = ((stat & LMC_RDES_FRAME_LENGTH) >> RDES_FRAME_LENGTH_BIT_NUMBER);
  1782.         if ((stat & 0x0300) != 0x0300) {  /* Check first segment and last segment */
  1783.             if ((stat & 0x0000ffff) != 0x7fff) {
  1784.                 /* Oversized frame */
  1785.                 sc->stats.rx_length_errors++;
  1786.                 goto skip_packet;
  1787.             }
  1788.         }
  1790.         if(stat & 0x00000008){ /* Catch a dribbling bit error */
  1791.             sc->stats.rx_errors++;
  1792.             sc->stats.rx_frame_errors++;
  1793.             goto skip_packet;
  1794.         }
  1797.         if(stat & 0x00000004){ /* Catch a CRC error by the Xilinx */
  1798.             sc->stats.rx_errors++;
  1799.             sc->stats.rx_crc_errors++;
  1800.             goto skip_packet;
  1801.         }
  1804.         if (len > LMC_PKT_BUF_SZ){
  1805.             sc->stats.rx_length_errors++;
  1806.             localLengthErrCnt++;
  1807.             goto skip_packet;
  1808.         }
  1810.         if (len < sc->lmc_crcSize + 2) {
  1811.             sc->stats.rx_length_errors++;
  1812.             sc->stats.rx_SmallPktCnt++;
  1813.             localLengthErrCnt++;
  1814.             goto skip_packet;
  1815.         }
  1817.         if(stat & 0x00004000){
  1818.             printk(KERN_WARNING "%s: Receiver descriptor error, receiver out of sync?n", dev->name);
  1819.         }
  1821.         len -= sc->lmc_crcSize;
  1823.         skb = sc->lmc_rxq[i];
  1825.         /*
  1826.          * We ran out of memory at some point
  1827.          * just allocate an skb buff and continue.
  1828.          */
  1829.         
  1830.         if(skb == 0x0){
  1831.             nsb = dev_alloc_skb (LMC_PKT_BUF_SZ + 2);
  1832.             if (nsb) {
  1833.                 LMC_SKB_FREE(nsb, 1);
  1834.                 sc->lmc_rxq[i] = nsb;
  1835.                 nsb->dev = dev;
  1836.                 sc->lmc_rxring[i].buffer1 = virt_to_bus (nsb->tail);
  1837.             }
  1838.             sc->failed_recv_alloc = 1;
  1839.             goto skip_packet;
  1840.         }
  1841.         
  1842.         dev->last_rx = jiffies;
  1843.         sc->stats.rx_packets++;
  1844.         sc->stats.rx_bytes += len;
  1846.         LMC_CONSOLE_LOG("recv", skb->data, len);
  1848.         /*
  1849.          * I'm not sure of the sanity of this
  1850.          * Packets could be arriving at a constant
  1851.          * 44.210mbits/sec and we're going to copy
  1852.          * them into a new buffer??
  1853.          */
  1854.         
  1855.         if(len > (LMC_MTU - (LMC_MTU>>2))){ /* len > LMC_MTU * 0.75 */
  1856.             /*
  1857.              * If it's a large packet don't copy it just hand it up
  1858.              */
  1859.         give_it_anyways:
  1861.             sc->lmc_rxq[i] = 0x0;
  1862.             sc->lmc_rxring[i].buffer1 = 0x0;
  1864.             skb_put (skb, len);
  1865.             skb->protocol = lmc_proto_type(sc, skb);
  1866.             skb->protocol = htons(ETH_P_WAN_PPP);
  1867.             skb->mac.raw = skb->data;
  1868. //            skb->nh.raw = skb->data;
  1869.             skb->dev = dev;
  1870.             lmc_proto_netif(sc, skb);
  1872.             /*
  1873.              * This skb will be destroyed by the upper layers, make a new one
  1874.              */
  1875.             nsb = dev_alloc_skb (LMC_PKT_BUF_SZ + 2);
  1876.             if (nsb) {
  1877.                 LMC_SKB_FREE(nsb, 1);
  1878.                 sc->lmc_rxq[i] = nsb;
  1879.                 nsb->dev = dev;
  1880.                 sc->lmc_rxring[i].buffer1 = virt_to_bus (nsb->tail);
  1881.                 /* Transferred to 21140 below */
  1882.             }
  1883.             else {
  1884.                 /*
  1885.                  * We've run out of memory, stop trying to allocate
  1886.                  * memory and exit the interrupt handler
  1887.                  *
  1888.                  * The chip may run out of receivers and stop
  1889.                  * in which care we'll try to allocate the buffer
  1890.                  * again.  (once a second)
  1891.                  */
  1892.                 sc->stats.rx_BuffAllocErr++;
  1893.                 LMC_EVENT_LOG(LMC_EVENT_RCVINT, stat, len);
  1894.                 sc->failed_recv_alloc = 1;
  1895.                 goto skip_out_of_mem;
  1896.             }
  1897.         }
  1898.         else {
  1899.             nsb = dev_alloc_skb(len);
  1900.             if(!nsb) {
  1901.                 goto give_it_anyways;
  1902.             }
  1903.             memcpy(skb_put(nsb, len), skb->data, len);
  1904.             
  1905.             nsb->protocol = lmc_proto_type(sc, skb);
  1906.             nsb->mac.raw = nsb->data;
  1907. //            nsb->nh.raw = nsb->data;
  1908.             nsb->dev = dev;
  1909.             lmc_proto_netif(sc, nsb);
  1910.         }
  1912.     skip_packet:
  1913.         LMC_EVENT_LOG(LMC_EVENT_RCVINT, stat, len);
  1914.         sc->lmc_rxring[i].status = DESC_OWNED_BY_DC21X4;
  1916.         sc->lmc_next_rx++;
  1917.         i = sc->lmc_next_rx % LMC_RXDESCS;
  1918.         rx_work_limit--;
  1919.         if (rx_work_limit < 0)
  1920.             break;
  1921.     }
  1923.     /* detect condition for LMC1000 where DSU cable attaches and fills
  1924.      * descriptors with bogus packets
  1925.      *
  1926.     if (localLengthErrCnt > LMC_RXDESCS - 3) {
  1927.         sc->stats.rx_BadPktSurgeCnt++;
  1928.         LMC_EVENT_LOG(LMC_EVENT_BADPKTSURGE,
  1929.                       localLengthErrCnt,
  1930.                       sc->stats.rx_BadPktSurgeCnt);
  1931.     } */
  1933.     /* save max count of receive descriptors serviced */
  1934.     if (rxIntLoopCnt > sc->stats.rxIntLoopCnt) {
  1935.         sc->stats.rxIntLoopCnt = rxIntLoopCnt; /* debug -baz */
  1936.     }
  1938. #ifdef DEBUG
  1939.     if (rxIntLoopCnt == 0)
  1940.     {
  1941.         for (i = 0; i < LMC_RXDESCS; i++)
  1942.         {
  1943.             if ((sc->lmc_rxring[i].status & LMC_RDES_OWN_BIT)
  1944.                 != DESC_OWNED_BY_DC21X4)
  1945.             {
  1946.                 rxIntLoopCnt++;
  1947.             }
  1948.         }
  1949.         LMC_EVENT_LOG(LMC_EVENT_RCVEND, rxIntLoopCnt, 0);
  1950.     }
  1951. #endif
  1954.     lmc_led_off(sc, LMC_DS3_LED3);
  1956. skip_out_of_mem:
  1958.     lmc_trace(dev, "lmc_rx out");
  1960.     return 0;
  1961. }
  1963. static struct net_device_stats *lmc_get_stats (struct net_device *dev) /*fold00*/
  1964. {
  1965.     lmc_softc_t *sc;
  1966.     LMC_SPIN_FLAGS;
  1968.     lmc_trace(dev, "lmc_get_stats in");
  1970.     sc = dev->priv;
  1972.     spin_lock_irqsave(&sc->lmc_lock, flags);
  1974.     sc->stats.rx_missed_errors += LMC_CSR_READ (sc, csr_missed_frames) & 0xffff;
  1976.     spin_unlock_irqrestore(&sc->lmc_lock, flags);
  1978.     lmc_trace(dev, "lmc_get_stats out");
  1980.     return (struct net_device_stats *) &sc->stats;
  1981. }
  1983. #ifdef MODULE
  1985. int init_module (void) /*fold00*/
  1986. {
  1987.     printk ("lmc: module loadedn");
  1989.     /* Have lmc_probe search for all the cards, and allocate devices */
  1990.     if (lmc_probe (NULL) < 0)
  1991.         return -EIO;
  1993.     return 0;
  1994. }
  1996. void cleanup_module (void) /*fold00*/
  1997. {
  1998.     struct net_device *dev, *next;
  1999.     lmc_softc_t *sc;
  2001.     /* we have no pointer to our devices, since they are all dynamically
  2002.      * allocated.  So, here we loop through all the network devices
  2003.      * looking for ours.  When found, dispose of them properly.
  2004.      */
  2006.     for (dev = Lmc_root_dev;
  2007.          dev != NULL;
  2008.          dev = next )
  2009.     {
  2011.         next = ((lmc_softc_t *) dev->priv)->next_module; /* get it now before we deallocate it */
  2012.         printk ("%s: removing...n", dev->name);
  2014.         /* close the syncppp stuff, and release irq. Close is run on unreg net */
  2015.         lmc_close (dev);
  2016. sc = dev->priv;
  2017.         if (sc != NULL)
  2018.             lmc_proto_detach(sc);
  2020.         /* Remove the device from the linked list */
  2021.         unregister_netdev (dev);
  2023.         /* Let go of the io region */;
  2024.         release_region (dev->base_addr, LMC_REG_RANGE);
  2026.         /* free our allocated structures. */
  2027.         kfree (dev->priv);
  2028.         dev->priv = NULL;
  2030.         kfree ((struct ppp_device *) dev);
  2031.         dev = NULL;
  2032.     }
  2035.     Lmc_root_dev = NULL;
  2036.     printk ("lmc module unloadedn");
  2037. }
  2038. #endif
  2040. unsigned lmc_mii_readreg (lmc_softc_t * const sc, unsigned devaddr, unsigned regno) /*fold00*/
  2041. {
  2042.     int i;
  2043.     int command = (0xf6 << 10) | (devaddr << 5) | regno;
  2044.     int retval = 0;
  2046.     lmc_trace(sc->lmc_device, "lmc_mii_readreg in");
  2048.     LMC_MII_SYNC (sc);
  2050.     lmc_trace(sc->lmc_device, "lmc_mii_readreg: done sync");
  2052.     for (i = 15; i >= 0; i--)
  2053.     {
  2054.         int dataval = (command & (1 << i)) ? 0x20000 : 0;
  2056.         LMC_CSR_WRITE (sc, csr_9, dataval);
  2057.         lmc_delay ();
  2058.         /* __SLOW_DOWN_IO; */
  2059.         LMC_CSR_WRITE (sc, csr_9, dataval | 0x10000);
  2060.         lmc_delay ();
  2061.         /* __SLOW_DOWN_IO; */
  2062.     }
  2064.     lmc_trace(sc->lmc_device, "lmc_mii_readreg: done1");
  2066.     for (i = 19; i > 0; i--)
  2067.     {
  2068.         LMC_CSR_WRITE (sc, csr_9, 0x40000);
  2069.         lmc_delay ();
  2070.         /* __SLOW_DOWN_IO; */
  2071.         retval = (retval << 1) | ((LMC_CSR_READ (sc, csr_9) & 0x80000) ? 1 : 0);
  2072.         LMC_CSR_WRITE (sc, csr_9, 0x40000 | 0x10000);
  2073.         lmc_delay ();
  2074.         /* __SLOW_DOWN_IO; */
  2075.     }
  2077.     lmc_trace(sc->lmc_device, "lmc_mii_readreg out");
  2079.     return (retval >> 1) & 0xffff;
  2080. }
  2082. void lmc_mii_writereg (lmc_softc_t * const sc, unsigned devaddr, unsigned regno, unsigned data) /*fold00*/
  2083. {
  2084.     int i = 32;
  2085.     int command = (0x5002 << 16) | (devaddr << 23) | (regno << 18) | data;
  2087.     lmc_trace(sc->lmc_device, "lmc_mii_writereg in");
  2089.     LMC_MII_SYNC (sc);
  2091.     i = 31;
  2092.     while (i >= 0)
  2093.     {
  2094.         int datav;
  2096.         if (command & (1 << i))
  2097.             datav = 0x20000;
  2098.         else
  2099.             datav = 0x00000;
  2101.         LMC_CSR_WRITE (sc, csr_9, datav);
  2102.         lmc_delay ();
  2103.         /* __SLOW_DOWN_IO; */
  2104.         LMC_CSR_WRITE (sc, csr_9, (datav | 0x10000));
  2105.         lmc_delay ();
  2106.         /* __SLOW_DOWN_IO; */
  2107.         i--;
  2108.     }
  2110.     i = 2;
  2111.     while (i > 0)
  2112.     {
  2113.         LMC_CSR_WRITE (sc, csr_9, 0x40000);
  2114.         lmc_delay ();
  2115.         /* __SLOW_DOWN_IO; */
  2116.         LMC_CSR_WRITE (sc, csr_9, 0x50000);
  2117.         lmc_delay ();
  2118.         /* __SLOW_DOWN_IO; */
  2119.         i--;
  2120.     }
  2122.     lmc_trace(sc->lmc_device, "lmc_mii_writereg out");
  2123. }
  2125. static void lmc_softreset (lmc_softc_t * const sc) /*fold00*/
  2126. {
  2127.     int i;
  2129.     lmc_trace(sc->lmc_device, "lmc_softreset in");
  2131.     /* Initialize the receive rings and buffers. */
  2132.     sc->lmc_txfull = 0;
  2133.     sc->lmc_next_rx = 0;
  2134.     sc->lmc_next_tx = 0;
  2135.     sc->lmc_taint_rx = 0;
  2136.     sc->lmc_taint_tx = 0;
  2138.     /*
  2139.      * Setup each one of the receiver buffers
  2140.      * allocate an skbuff for each one, setup the descriptor table
  2141.      * and point each buffer at the next one
  2142.      */
  2144.     for (i = 0; i < LMC_RXDESCS; i++)
  2145.     {
  2146.         struct sk_buff *skb;
  2148.         if (sc->lmc_rxq[i] == NULL)
  2149.         {
  2150.             skb = dev_alloc_skb (LMC_PKT_BUF_SZ + 2);
  2151.             if(skb == NULL){
  2152.                 printk(KERN_WARNING "%s: Failed to allocate receiver ring, will try againn", sc->name);
  2153.                 sc->failed_ring = 1;
  2154.                 break;
  2155.             }
  2156.             else{
  2157.                 sc->lmc_rxq[i] = skb;
  2158.             }
  2159.         }
  2160.         else
  2161.         {
  2162.             skb = sc->lmc_rxq[i];
  2163.         }
  2165.         skb->dev = sc->lmc_device;
  2166.         LMC_SKB_FREE(skb, 1);
  2168.         /* owned by 21140 */
  2169.         sc->lmc_rxring[i].status = 0x80000000;
  2171.         /* used to be PKT_BUF_SZ now uses skb since we loose some to head room */
  2172.         sc->lmc_rxring[i].length = skb->end - skb->data;
  2174.         /* use to be tail which is dumb since you're thinking why write
  2175.          * to the end of the packj,et but since there's nothing there tail == data
  2176.          */
  2177.         sc->lmc_rxring[i].buffer1 = virt_to_bus (skb->data);
  2179.         /* This is fair since the structure is static and we have the next address */
  2180.         sc->lmc_rxring[i].buffer2 = virt_to_bus (&sc->lmc_rxring[i + 1]);
  2182.     }
  2184.     /*
  2185.      * Sets end of ring
  2186.      */
  2187.     sc->lmc_rxring[i - 1].length |= 0x02000000; /* Set end of buffers flag */
  2188.     sc->lmc_rxring[i - 1].buffer2 = virt_to_bus (&sc->lmc_rxring[0]); /* Point back to the start */
  2189.     LMC_CSR_WRITE (sc, csr_rxlist, virt_to_bus (sc->lmc_rxring)); /* write base address */
  2192.     /* Initialize the transmit rings and buffers */
  2193.     for (i = 0; i < LMC_TXDESCS; i++)
  2194.     {
  2195.         if (sc->lmc_txq[i] != NULL){ /* have buffer */
  2196.             dev_kfree_skb(sc->lmc_txq[i]); /* free it */
  2197.             sc->stats.tx_dropped++;      /* We just dropped a packet */
  2198.         }
  2199.         sc->lmc_txq[i] = 0;
  2200.         sc->lmc_txring[i].status = 0x00000000;
  2201.         sc->lmc_txring[i].buffer2 = virt_to_bus (&sc->lmc_txring[i + 1]);
  2202.     }
  2203.     sc->lmc_txring[i - 1].buffer2 = virt_to_bus (&sc->lmc_txring[0]);
  2204.     LMC_CSR_WRITE (sc, csr_txlist, virt_to_bus (sc->lmc_txring));
  2206.     lmc_trace(sc->lmc_device, "lmc_softreset out");
  2207. }
  2209. static int lmc_set_config(struct net_device *dev, struct ifmap *map) /*fold00*/
  2210. {
  2211.     lmc_trace(dev, "lmc_set_config in");
  2212.     lmc_trace(dev, "lmc_set_config out");
  2213.     return -EOPNOTSUPP;
  2214. }
  2216. void lmc_gpio_mkinput(lmc_softc_t * const sc, u_int32_t bits) /*fold00*/
  2217. {
  2218.     lmc_trace(sc->lmc_device, "lmc_gpio_mkinput in");
  2219.     sc->lmc_gpio_io &= ~bits;
  2220.     LMC_CSR_WRITE(sc, csr_gp, TULIP_GP_PINSET | (sc->lmc_gpio_io));
  2221.     lmc_trace(sc->lmc_device, "lmc_gpio_mkinput out");
  2222. }
  2224. void lmc_gpio_mkoutput(lmc_softc_t * const sc, u_int32_t bits) /*fold00*/
  2225. {
  2226.     lmc_trace(sc->lmc_device, "lmc_gpio_mkoutput in");
  2227.     sc->lmc_gpio_io |= bits;
  2228.     LMC_CSR_WRITE(sc, csr_gp, TULIP_GP_PINSET | (sc->lmc_gpio_io));
  2229.     lmc_trace(sc->lmc_device, "lmc_gpio_mkoutput out");
  2230. }
  2232. void lmc_led_on(lmc_softc_t * const sc, u_int32_t led) /*fold00*/
  2233. {
  2234.     lmc_trace(sc->lmc_device, "lmc_led_on in");
  2235.     if((~sc->lmc_miireg16) & led){ /* Already on! */
  2236.         lmc_trace(sc->lmc_device, "lmc_led_on aon out");
  2237.         return;
  2238.     }
  2239.     
  2240.     sc->lmc_miireg16 &= ~led;
  2241.     lmc_mii_writereg(sc, 0, 16, sc->lmc_miireg16);
  2242.     lmc_trace(sc->lmc_device, "lmc_led_on out");
  2243. }
  2245. void lmc_led_off(lmc_softc_t * const sc, u_int32_t led) /*fold00*/
  2246. {
  2247.     lmc_trace(sc->lmc_device, "lmc_led_off in");
  2248.     if(sc->lmc_miireg16 & led){ /* Already set don't do anything */
  2249.         lmc_trace(sc->lmc_device, "lmc_led_off aoff out");
  2250.         return;
  2251.     }
  2252.     
  2253.     sc->lmc_miireg16 |= led;
  2254.     lmc_mii_writereg(sc, 0, 16, sc->lmc_miireg16);
  2255.     lmc_trace(sc->lmc_device, "lmc_led_off out");
  2256. }
  2258. static void lmc_reset(lmc_softc_t * const sc) /*fold00*/
  2259. {
  2260.     lmc_trace(sc->lmc_device, "lmc_reset in");
  2261.     sc->lmc_miireg16 |= LMC_MII16_FIFO_RESET;
  2262.     lmc_mii_writereg(sc, 0, 16, sc->lmc_miireg16);
  2264.     sc->lmc_miireg16 &= ~LMC_MII16_FIFO_RESET;
  2265.     lmc_mii_writereg(sc, 0, 16, sc->lmc_miireg16);
  2267.     /*
  2268.      * make some of the GPIO pins be outputs
  2269.      */
  2270.     lmc_gpio_mkoutput(sc, LMC_GEP_RESET);
  2272.     /*
  2273.      * RESET low to force state reset.  This also forces
  2274.      * the transmitter clock to be internal, but we expect to reset
  2275.      * that later anyway.
  2276.      */
  2277.     sc->lmc_gpio &= ~(LMC_GEP_RESET);
  2278.     LMC_CSR_WRITE(sc, csr_gp, sc->lmc_gpio);
  2280.     /*
  2281.      * hold for more than 10 microseconds
  2282.      */
  2283.     udelay(50);
  2285.     /*
  2286.      * stop driving Xilinx-related signals
  2287.      */
  2288.     lmc_gpio_mkinput(sc, LMC_GEP_RESET);
  2290.     /*
  2291.      * Call media specific init routine
  2292.      */
  2293.     sc->lmc_media->init(sc);
  2295.     sc->stats.resetCount++;
  2296.     lmc_trace(sc->lmc_device, "lmc_reset out");
  2297. }
  2299. static void lmc_dec_reset(lmc_softc_t * const sc) /*fold00*/
  2300. {
  2301.     u_int32_t val;
  2302.     lmc_trace(sc->lmc_device, "lmc_dec_reset in");
  2304.     /*
  2305.      * disable all interrupts
  2306.      */
  2307.     sc->lmc_intrmask = 0;
  2308.     LMC_CSR_WRITE(sc, csr_intr, sc->lmc_intrmask);
  2310.     /*
  2311.      * Reset the chip with a software reset command.
  2312.      * Wait 10 microseconds (actually 50 PCI cycles but at
  2313.      * 33MHz that comes to two microseconds but wait a
  2314.      * bit longer anyways)
  2315.      */
  2316.     LMC_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
  2317.     udelay(25);
  2318. #ifdef __sparc__
  2319.     sc->lmc_busmode = LMC_CSR_READ(sc, csr_busmode);
  2320.     sc->lmc_busmode = 0x00100000;
  2321.     sc->lmc_busmode &= ~TULIP_BUSMODE_SWRESET;
  2322.     LMC_CSR_WRITE(sc, csr_busmode, sc->lmc_busmode);
  2323. #endif
  2324.     sc->lmc_cmdmode = LMC_CSR_READ(sc, csr_command);
  2326.     /*
  2327.      * We want:
  2328.      *   no ethernet address in frames we write
  2329.      *   disable padding (txdesc, padding disable)
  2330.      *   ignore runt frames (rdes0 bit 15)
  2331.      *   no receiver watchdog or transmitter jabber timer
  2332.      *       (csr15 bit 0,14 == 1)
  2333.      *   if using 16-bit CRC, turn off CRC (trans desc, crc disable)
  2334.      */
  2336.     sc->lmc_cmdmode |= ( TULIP_CMD_PROMISCUOUS
  2337.                          | TULIP_CMD_FULLDUPLEX
  2338.                          | TULIP_CMD_PASSBADPKT
  2339.                          | TULIP_CMD_NOHEARTBEAT
  2340.                          | TULIP_CMD_PORTSELECT
  2341.                          | TULIP_CMD_RECEIVEALL
  2342.                          | TULIP_CMD_MUSTBEONE
  2343.                        );
  2344.     sc->lmc_cmdmode &= ~( TULIP_CMD_OPERMODE
  2345.                           | TULIP_CMD_THRESHOLDCTL
  2346.                           | TULIP_CMD_STOREFWD
  2347.                           | TULIP_CMD_TXTHRSHLDCTL
  2348.                         );
  2350.     LMC_CSR_WRITE(sc, csr_command, sc->lmc_cmdmode);
  2352.     /*
  2353.      * disable receiver watchdog and transmit jabber
  2354.      */
  2355.     val = LMC_CSR_READ(sc, csr_sia_general);
  2356.     val |= (TULIP_WATCHDOG_TXDISABLE | TULIP_WATCHDOG_RXDISABLE);
  2357.     LMC_CSR_WRITE(sc, csr_sia_general, val);
  2359.     lmc_trace(sc->lmc_device, "lmc_dec_reset out");
  2360. }
  2362. static void lmc_initcsrs(lmc_softc_t * const sc, lmc_csrptr_t csr_base, /*fold00*/
  2363.                          size_t csr_size)
  2364. {
  2365.     lmc_trace(sc->lmc_device, "lmc_initcsrs in");
  2366.     sc->lmc_csrs.csr_busmode         = csr_base +  0 * csr_size;
  2367.     sc->lmc_csrs.csr_txpoll = csr_base +  1 * csr_size;
  2368.     sc->lmc_csrs.csr_rxpoll = csr_base +  2 * csr_size;
  2369.     sc->lmc_csrs.csr_rxlist = csr_base +  3 * csr_size;
  2370.     sc->lmc_csrs.csr_txlist = csr_base +  4 * csr_size;
  2371.     sc->lmc_csrs.csr_status = csr_base +  5 * csr_size;
  2372.     sc->lmc_csrs.csr_command         = csr_base +  6 * csr_size;
  2373.     sc->lmc_csrs.csr_intr = csr_base +  7 * csr_size;
  2374.     sc->lmc_csrs.csr_missed_frames = csr_base +  8 * csr_size;
  2375.     sc->lmc_csrs.csr_9         = csr_base +  9 * csr_size;
  2376.     sc->lmc_csrs.csr_10         = csr_base + 10 * csr_size;
  2377.     sc->lmc_csrs.csr_11         = csr_base + 11 * csr_size;
  2378.     sc->lmc_csrs.csr_12         = csr_base + 12 * csr_size;
  2379.     sc->lmc_csrs.csr_13         = csr_base + 13 * csr_size;
  2380.     sc->lmc_csrs.csr_14         = csr_base + 14 * csr_size;
  2381.     sc->lmc_csrs.csr_15         = csr_base + 15 * csr_size;
  2382.     lmc_trace(sc->lmc_device, "lmc_initcsrs out");
  2383. }
  2385. #if LINUX_VERSION_CODE >= 0x20363
  2386. static void lmc_driver_timeout(struct net_device *dev) { /*fold00*/
  2387.     lmc_softc_t *sc;
  2388.     u32 csr6;
  2389.     LMC_SPIN_FLAGS;
  2391.     lmc_trace(dev, "lmc_driver_timeout in");
  2393.     sc = dev->priv;
  2395.     spin_lock_irqsave(&sc->lmc_lock, flags);
  2397.     printk("%s: Xmitter busy|n", dev->name);
  2399.     sc->stats.tx_tbusy_calls++ ;
  2400.     if (jiffies - dev->trans_start < TX_TIMEOUT) {
  2401.         goto bug_out;
  2402.     }
  2404.     /*
  2405.      * Chip seems to have locked up
  2406.      * Reset it
  2407.      * This whips out all our decriptor
  2408.      * table and starts from scartch
  2409.      */
  2411.     LMC_EVENT_LOG(LMC_EVENT_XMTPRCTMO,
  2412.                   LMC_CSR_READ (sc, csr_status),
  2413.                   sc->stats.tx_ProcTimeout);
  2415.     lmc_running_reset (dev);
  2417.     LMC_EVENT_LOG(LMC_EVENT_RESET1, LMC_CSR_READ (sc, csr_status), 0);
  2418.     LMC_EVENT_LOG(LMC_EVENT_RESET2,
  2419.                   lmc_mii_readreg (sc, 0, 16),
  2420.                   lmc_mii_readreg (sc, 0, 17));
  2422.     /* restart the tx processes */
  2423.     csr6 = LMC_CSR_READ (sc, csr_command);
  2424.     LMC_CSR_WRITE (sc, csr_command, csr6 | 0x0002);
  2425.     LMC_CSR_WRITE (sc, csr_command, csr6 | 0x2002);
  2427.     /* immediate transmit */
  2428.     LMC_CSR_WRITE (sc, csr_txpoll, 0);
  2430.     sc->stats.tx_errors++;
  2431.     sc->stats.tx_ProcTimeout++; /* -baz */
  2433.     dev->trans_start = jiffies;
  2435. bug_out:
  2437.     spin_unlock_irqrestore(&sc->lmc_lock, flags);
  2439.     lmc_trace(dev, "lmc_driver_timout out");
  2442. }
  2444. int lmc_setup(void) { /*FOLD00*/
  2445.    return lmc_probe(NULL);
  2446. }
  2448. #endif