rtl_rtl8139_drv.c

Go to the documentation of this file.

/*
 
        8139too.c: A RealTek RTL-8139 Fast Ethernet driver for Linux.
 
        Maintained by Jeff Garzik <jgarzik@mandrakesoft.com>
        Copyright 2000,2001 Jeff Garzik
 
        Much code comes from Donald Becker's rtl8139.c driver,
        versions 1.13 and older.  This driver was originally based
        on rtl8139.c version 1.07.  Header of rtl8139.c version 1.13:
 
        -----<snip>-----
 
                Written 1997-2001 by Donald Becker.
                This software may be used and distributed according to the
                terms of the GNU General Public License (GPL), incorporated
                herein by reference.  Drivers based on or derived from this
                code fall under the GPL and must retain the authorship,
                copyright and license notice.  This file is not a complete
                program and may only be used when the entire operating
                system is licensed under the GPL.
 
                This driver is for boards based on the RTL8129 and RTL8139
                PCI ethernet chips.
 
                The author may be reached as becker@scyld.com, or C/O Scyld
                Computing Corporation 410 Severn Ave., Suite 210 Annapolis
                MD 21403
                Support and updates available at
                http://www.scyld.com/network/rtl8139.html
                Twister-tuning table provided by Kinston
                <shangh@realtek.com.tw>.
 
        -----<snip>-----
        This software may be used and distributed according to the terms
        of the GNU General Public License, incorporated herein by reference.
 
        Contributors:
 
                Donald Becker - he wrote the original driver, kudos to him!
                (but please don't e-mail him for support, this isn't his driver)
 
                Tigran Aivazian - bug fixes, skbuff free cleanup
 
                Martin Mares - suggestions for PCI cleanup
 
                David S. Miller - PCI DMA and softnet updates
 
                Ernst Gill - fixes ported from BSD driver
 
                Daniel Kobras - identified specific locations of
                        posted MMIO write bugginess
 
                Gerard Sharp - bug fix, testing and feedback

                David Ford - Rx ring wrap fix

                Dan DeMaggio - swapped RTL8139 cards with me, and allowed me
                to find and fix a crucial bug on older chipsets.
 
                Donald Becker/Chris Butterworth/Marcus Westergren -
                Noticed various Rx packet size-related buglets.
 
                Santiago Garcia Mantinan - testing and feedback
 
                Jens David - 2.2.x kernel backports
 
                Martin Dennett - incredibly helpful insight on undocumented
                features of the 8139 chips
 
                Jean-Jacques Michel - bug fix
 
                Tobias Ringström - Rx interrupt status checking suggestion
 
                Andrew Morton - Clear blocked signals, avoid
                buffer overrun setting current->comm.

        Submitting bug reports:
 
                "rtl8139-diag -mmmaaavvveefN" output
                enable RTL8139_DEBUG below, and look at 'dmesg' or kernel log
 
                See 8139too.txt for more details.
 
-----------------------------------------------------------------------------
2001/09/21
Comments by ShuChen Shao
 
1.This driver is originally based on 8139too.c version "0.9.15".
 
2.It has been enhanced to support RTL8139C+ PCI ethernet chips and tested in 2.4.2 kernel.
 
3.RTL8139C+ PCI ethernet chips is set to support C+ mode by default.
  If FORCE_C_Mode below is enable, the RTL8139C+ chip will be forced to support C mode
  after reboot.
 
4.This program can be compiled at /usr/src/linux-2.4.2/drivers/net/ using the attached Makefile.
  And the object file named 8139too.o should be moved to the directory
  /lib/modules/2.4.2-2/kernel/drivers/net/
 
-----------------------------------------------------------------------------

=====================================================================================
                          PORTING TO RT-LINUX
=====================================================================================
 
15 May 2003 
            
            ByungGi Baek <gi@realtimewave.com||weapon100@empal.com>
 
            1. This driver is originally based on 8139too.c
            2. This   file  is also based  in   one file  part  of the
            RTL-lwIP TCP/IP   stack.   The  file  is: rt_3c905x_phys.c
            which   author      is:       Sergio    Perez      Alcañiz
            <serpeal@disca.upv.es>
            3. This file is compiled and tested on RTL-lwIP-0.2.1
            4.  Unload the original 8139  linux  driver then load this
            driver.
 

12     January    2004

            Sergio Perez Alcañiz <serpeal@disca.upv.es> Departamento
            de Informática de Sistemas y Computadores Universidad
            Politécnica de Valencia

            The RTL-lwIP project  has  been supported by   the Spanish
            Government     Research   Office   (CICYT)    under  grant
            TIC2002-04123-C03-03  SISTEMAS DE  TIEMPO REAL EMPOTRADOS,
            FIABLES Y  DISTRIBUIDOS  BASADOS EN  COMPONENTES  Valencia
            (Spain)

            -Removed threads  registration (to  better comply with the
            POSIX standard).
            -Added  a semaphore   to block   threads  when they    are
            performing a read and there are not packets available.
            -Modified to use the  new release of DIDMA (Dynamic Memory
            Allocator) now called TLSF.

 
=====================================================================================
 
*/

#include "rtl_rtl8139_drv.h"
#include "netif/net_policy/FIFO_policy.h"
#include "rt_pci.h"

MODULE_LICENSE("GPL");

static sem_t rtl8139_sem;

static struct net_policy_operations rt_rtl8139_policy = {
  FIFO_add_frame_to_buffer,
  FIFO_extract_frame_of_buffer,
  FIFO_initialize_rx_buffer,
  FIFO_dealloc_rx_buffer,
};

static struct fifo_rx_buffer_t rt_rtl8139_rx_buffer;

#define RTL8139_MAJOR   205
#define RTL8139_NAME    "rtl"
#define RTL8139_SIGNAL  RTL_SIGUSR1

static int rt_rtl8139_read_eeprom (void *ioaddr, int location, int addr_len);
static int rt_rtl8139_mdio_read (struct pci_dev *dev, int phy_id, int location);
static void rt_rtl8139_mdio_write (struct pci_dev *dev, int phy_id, int location, int val);
struct pci_dev *init_rtl8139_device(void);
int start_up_rtl8139_device(struct pci_dev *dev);


static int dev_rtl8139_open(struct pci_dev *dev);

static int rt_rtl8139_open (struct rtl_file *filp);
static int rt_rtl8139_release (struct rtl_file *filp);
static ssize_t rt_rtl8139_write(struct rtl_file *filp, const char *buf, size_t count, loff_t* ppos);
static int rt_rtl8139_ioctl(struct rtl_file * filp, unsigned int request, unsigned long other);
static ssize_t rt_rtl8139_read(struct rtl_file *filp, char *buf, size_t count, loff_t* ppos);
void rt_rtl8139_send_signal(void);



static struct rtl_file_operations rt_rtl8139_fops = {
        NULL,
        rt_rtl8139_read,
        rt_rtl8139_write,
        rt_rtl8139_ioctl,
        NULL,
        rt_rtl8139_open,
        rt_rtl8139_release
};

static int rt_rtl8139_inside_the_interrupt_handler = 0, rt_rtl8139_trying_to_close = 0;
static int rt_rtl8139_interrupted = 0, rt_rtl8139_writting = 0;

/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
static int rt_rtl8139_max_interrupt_work = 20;
unsigned char rt_rtl8139_ip_addr[2][4]={{0x00,0x00,0x00,0x00},{0x00,0x00,0x00,0x00}};                     
static int rt_rtl8139_n_filters = 0;
unsigned char rt_rtl8139_registered = 0x00, rt_rtl8139_opened = 0x00, rt_rtl8139_sended = 0x01;
struct pci_dev *rtl8139dev;
struct rtl8139_private rtl_8139_tp;  

/***************************************************************************************/
int rt_rtl8139_obtain_mac_address(unsigned char *mac){
        int i;
        for(i=0; i<6; i++)
                mac[i]=rtl_8139_tp.dev_addr[i];
        return 0;
}



/*************************************************************************************/
int rt_rtl8139_set_ip_filter(long ipaddr){
        if(rt_rtl8139_n_filters<=1){
                rt_rtl8139_ip_addr[rt_rtl8139_n_filters][0]=ipaddr & 0x000000ff; rt_rtl8139_ip_addr[rt_rtl8139_n_filters][1]= (ipaddr >> 8) & 0x000000ff;
                rt_rtl8139_ip_addr[rt_rtl8139_n_filters][2]= (ipaddr >> 16) & 0x000000ff; rt_rtl8139_ip_addr[rt_rtl8139_n_filters][3]= (ipaddr >> 24) & 0x000000ff;
                rt_rtl8139_n_filters++;
                return 0;
        }
 
        rtl_printf("You cannot set more than 2 IP filters !!");
        return -1;
}


/* The data sheet doesn't describe the Rx ring at all, so I'm guessing at the
   field alignments and semantics. */
static void rt_rtl8139_rx_interrupt (struct pci_dev *dev)
{
        unsigned char *rx_ring;
        u16 cur_rx;
        unsigned char mine = 0x01;
        unsigned char multicast_packet= 0x01;
        unsigned char arp_request_for_me = 0x01 ;
        void *ioaddr = rtl_8139_tp.mmio_addr;
        int i, j;


        rx_ring = rtl_8139_tp.rx_ring;
        cur_rx = rtl_8139_tp.cur_rx;

        while ((RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
                int ring_offset = cur_rx % RX_BUF_LEN;
                u32 rx_status;
                unsigned int rx_size;
                unsigned int pkt_size;
                unsigned char *skb;
 
                /* read size+status of next frame from DMA ring buffer */
                rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));
                rx_size = rx_status >> 16;
                pkt_size = rx_size - 4;

                if (rx_size == 0xfff0)
                        break;

                if ((rx_size > (MAX_ETH_FRAME_SIZE+4)) || (!(rx_status & RxStatusOK))) {
                        return;
                }
                
                skb = &rx_ring[ring_offset+4]; 
                rtl_8139_tp.stats.rx_bytes += pkt_size;

                rtl_8139_tp.stats.rx_packets++;
                
                for(i=0; i<6; i++){
                        if(skb[i] == rtl_8139_tp.dev_addr[i]) {
                                continue;
                        } else{
                                mine = 0x00;
                                break;
                        }
                }

                if(mine == 0x01) {
                   goto accept_frame;
                }

                if((skb[12]==0x08) && (skb[13]==0x06)){
                    for(j=0; j<rt_rtl8139_n_filters; j++){
                        for(i=0; i<4;i++){
                                if(skb[38+i]==rt_rtl8139_ip_addr[j][i]) {
                                        continue;
                                } else{
                                        arp_request_for_me = 0x00;
                                        break;
                                }
                        }
                    }
                }else
                arp_request_for_me = 0x00;

                
                for(i=0; i<6; i++){
                        if(skb[i] == 0xff)
                                continue;
                        else{
                                multicast_packet = 0x00;
                                break;
                        }
                }

accept_frame:
                if((mine == 0x01) || ((multicast_packet==0x01) && (arp_request_for_me==0x01))){ 
                   rtl_8139_tp.rx_frames_for_us++;
                   if(rt_rtl8139_policy.add_frame_to_buffer(&rt_rtl8139_rx_buffer,skb,pkt_size)== 0){
                     sem_post(&rtl8139_sem);

                     rtl_schedule();
                   }
                }
 
                cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
                RTL_W16_F (RxBufPtr, cur_rx - 16);

                mine = 0x01;
                multicast_packet= 0x01;
                arp_request_for_me = 0x01 ;
        }
        rtl_8139_tp.cur_rx = cur_rx;
}               


/***************************************************************************************/
static int rt_rtl8139_send_packet(const char *buffer, size_t size)
{
        unsigned char *buff;
        void *ioaddr = rtl_8139_tp.mmio_addr;
        int entry, len = 0;
 
        rt_rtl8139_writting = 1;

        /* Calculate the next Tx descriptor entry. */
        entry = rtl_8139_tp.cur_tx % NUM_TX_DESC;

        buff = rtl_8139_tp.tx_buf[entry];
        if(buff) {
                memcpy(buff, buffer, size);
                len = sizeof(buff);
        }

        rtl_8139_tp.tx_info[entry].mapping = pci_map_single (rtl_8139_tp.pci_dev, rtl_8139_tp.tx_buf[entry], size, PCI_DMA_TODEVICE);

        RTL_W32 (TxAddr0 + (entry * 4), rtl_8139_tp.tx_info[entry].mapping);

        rtl_8139_tp.cur_tx++;                                                                                

        /* Note: the chip doesn't have auto-pad! */

        RTL_W32 (TxStatus0 + (entry * sizeof (u32)),
                 rtl_8139_tp.tx_flag | (size >= ETH_ZLEN ? size : ETH_ZLEN));

        rt_rtl8139_writting = 0; 
        return size;                                                                                        
}


static void rt_rtl8139_tx_interrupt (struct pci_dev *dev)
{
        void *ioaddr = rtl_8139_tp.mmio_addr;
        unsigned long dirty_tx, tx_left;
 
 
        dirty_tx = rtl_8139_tp.dirty_tx;
        tx_left = rtl_8139_tp.cur_tx - dirty_tx;
        while (tx_left > 0) {
                int entry = dirty_tx % NUM_TX_DESC;
                int txstatus;
 
                txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
 
                if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
                        break;  /* It still hasn't been Txed */
                /* Note: TxCarrierLost is always asserted at 100mbps. */
                if (txstatus & (TxOutOfWindow | TxAborted)) {
                        /* There was an major error, log it. */
                        rtl_printf ("Transmit error, Tx status %8.8x.\n",
                                 txstatus);
                        rtl_8139_tp.stats.tx_errors++;
                        if (txstatus & TxAborted) {
                                rtl_8139_tp.stats.tx_aborted_errors++;
                                RTL_W32 (TxConfig, TxClearAbt | (TX_DMA_BURST << TxDMAShift));
                        }
                        if (txstatus & TxCarrierLost)
                                rtl_8139_tp.stats.tx_carrier_errors++;
                        if (txstatus & TxOutOfWindow)
                                rtl_8139_tp.stats.tx_window_errors++;
#ifdef ETHER_STATS
                        if ((txstatus & 0x0f000000) == 0x0f000000)
                                rtl_8139_tp.stats.collisions16++;
#endif
                } else {
                        if (txstatus & TxUnderrun) {
                                /* Add 64 to the Tx FIFO threshold. */
                                if (rtl_8139_tp.tx_flag < 0x00300000)
                                        rtl_8139_tp.tx_flag += 0x00020000;
                                rtl_8139_tp.stats.tx_fifo_errors++;
                        }
                        rtl_8139_tp.stats.collisions += (txstatus >> 24) & 15;
                        rtl_8139_tp.stats.tx_bytes += txstatus & 0x7ff;
                        rtl_8139_tp.stats.tx_packets++;
                }
                /* Free the original skb. */
                if (rtl_8139_tp.tx_info[entry].mapping != 0) {
                        pci_unmap_single(rtl_8139_tp.pci_dev,
                                         rtl_8139_tp.tx_info[entry].mapping,
                                         rtl_8139_tp.tx_info[entry].skb->len,
                                         PCI_DMA_TODEVICE);
                        rtl_8139_tp.tx_info[entry].mapping = 0;
                }
                rtl_8139_tp.tx_info[entry].skb = NULL;
 
                dirty_tx++;
                tx_left--;
        }
 
#ifdef RTL8139_DEBUG
        if (rtl_8139_tp.cur_tx - dirty_tx > NUM_TX_DESC) {
                printk (KERN_ERR "%s: Out-of-sync dirty pointer, %ld vs. %ld.\n",
                        dev->name, dirty_tx, rtl_8139_tp.cur_tx);
                dirty_tx += NUM_TX_DESC;
        }
#endif /* RTL8139_NDEBUG */
        /* only wake the queue if we did work, and the queue is stopped */
        if (rtl_8139_tp.dirty_tx != dirty_tx) {
                rtl_8139_tp.dirty_tx = dirty_tx;
        }

}

                                                                         

/* The interrupt handler does all of the Rx thread work and cleans up
   after the Tx thread. */

unsigned int  rt_rtl8139_interrupt (unsigned int irq, struct pt_regs *regs)
{

        struct pci_dev *dev = rtl8139dev;
        int boguscnt = rt_rtl8139_max_interrupt_work; 
        void *ioaddr = rtl_8139_tp.mmio_addr;
        int status = 0, link_changed = 0; /* avoid bogus "uninit" warning */
  
        rt_rtl8139_inside_the_interrupt_handler = 1; 
        rt_rtl8139_interrupted++;
 
        do {
                status = RTL_R16 (IntrStatus);
 
                /* h/w no longer present (hotplug?) or major error, bail */
                if (status == 0xFFFF)
                        break;
                /* Acknowledge all of the current interrupt sources ASAP, but
                   an first get an additional status bit from CSCR. */
                if (status & RxUnderrun)
                        link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;

                RTL_W16_F (IntrStatus, (status & RxFIFOOver) ? (status | RxOverflow) : status);
 
                if ((status &
                     (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
                      RxFIFOOver | TxErr | TxOK | RxErr | RxOK)) == 0) {
                        break;
                        }
 
                if (status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOver))  {   /* Rx interrupt */
                        rt_rtl8139_rx_interrupt (dev);  
                }
 
                if (status & (TxOK | TxErr)) {
                        rt_rtl8139_tx_interrupt (dev);   
                }
 
                boguscnt--;
        } while (boguscnt > 0);  

        if (boguscnt <= 0) {
                rtl_printf ( "%s: Too much work at interrupt, "
                        "IntrStatus=0x%4.4x.\n", dev->name,
                        status);
 
                /* Clear all interrupt sources. */
                RTL_W16 (IntrStatus, 0xffff);
        }
        if(!rt_rtl8139_trying_to_close){
                rtl_hard_enable_irq(rtl_8139_tp.pci_dev->irq);
        }    

        rt_rtl8139_interrupted--;  
 
        return (rt_rtl8139_inside_the_interrupt_handler = 0);
}



/* Syncronize the MII management interface by shifting 32 one bits out. */                                    
static void rt_rtl8139_mdio_sync (void *mdio_addr)
{
        int i;
 
 
        for (i = 32; i >= 0; i--) {
                writeb (MDIO_WRITE1, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
                writeb (MDIO_WRITE1 | MDIO_CLK, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
        }
 
}


static int rt_rtl8139_mdio_read (struct pci_dev *dev, int phy_id, int location)
{
        void *mdio_addr = rtl_8139_tp.mmio_addr + Config4;
        int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
        int retval = 0;
        int i;
 
 
        if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
                return location < 8 && mii_2_8139_map[location] ?
                    readw (rtl_8139_tp.mmio_addr + mii_2_8139_map[location]) : 0;
        }
        rt_rtl8139_mdio_sync (mdio_addr);
        /* Shift the read command bits out. */
        for (i = 15; i >= 0; i--) {
                int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
 
                writeb (MDIO_DIR | dataval, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
                writeb (MDIO_DIR | dataval | MDIO_CLK, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
        }
 
        /* Read the two transition, 16 data, and wire-idle bits. */
        for (i = 19; i > 0; i--) {
                writeb (0, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
                retval = (retval << 1) | ((readb (mdio_addr) & MDIO_DATA_IN) ? 1 : 0);
                writeb (MDIO_CLK, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
        }
 
        return (retval >> 1) & 0xffff;
}


static void rt_rtl8139_mdio_write (struct pci_dev *dev, int phy_id, int location,
                        int value)
{
        void *mdio_addr = rtl_8139_tp.mmio_addr + Config4;
        int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
        int i;
 
 
        if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
                void *ioaddr = rtl_8139_tp.mmio_addr;
                if (location == 0) {
                        RTL_W8_F (Cfg9346, Cfg9346_Unlock);
                        switch(rtl_8139_tp.AutoNegoAbility){
                        case 1: RTL_W16 (NWayAdvert, AutoNegoAbility10half); break;
                        case 2: RTL_W16 (NWayAdvert, AutoNegoAbility10full); break;
                        case 4: RTL_W16 (NWayAdvert, AutoNegoAbility100half); break;
                        case 8: RTL_W16 (NWayAdvert, AutoNegoAbility100full); break;
                        default: break;
                        }
                        RTL_W16_F (BasicModeCtrl, AutoNegotiationEnable|AutoNegotiationRestart);
                        RTL_W8_F (Cfg9346, Cfg9346_Lock);
                } else if (location < 8 && mii_2_8139_map[location])
                        RTL_W16_F (mii_2_8139_map[location], value);
 
                return;
        }
        rt_rtl8139_mdio_sync (mdio_addr);
        /* Shift the command bits out. */
        for (i = 31; i >= 0; i--) {
                int dataval =
                    (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
                writeb (dataval, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
                writeb (dataval | MDIO_CLK, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
        }
        /* Clear out extra bits. */
        for (i = 2; i > 0; i--) {
                writeb (0, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
                writeb (MDIO_CLK, mdio_addr);
                rt_rtl8139_mdio_delay (mdio_addr);
        }
        return;
}


/* Serial EEPROM section. */
 
/*  EEPROM_Ctrl bits. */
#define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
#define EE_CS                   0x08    /* EEPROM chip select. */
#define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
#define EE_WRITE_0              0x00
#define EE_WRITE_1              0x02
#define EE_DATA_READ    0x01    /* EEPROM chip data out. */
#define EE_ENB                  (0x80 | EE_CS)
 
/* Delay between EEPROM clock transitions.
   No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
 */
 
#define rt_rtl8139_eeprom_delay()  readl(ee_addr)
 
/* The EEPROM commands include the alway-set leading bit. */
#define EE_WRITE_CMD    (5)
#define EE_READ_CMD             (6)
#define EE_ERASE_CMD    (7)

static int __devinit rt_rtl8139_read_eeprom (void *ioaddr, int location, int addr_len)
{
        int i;
        unsigned retval = 0;
        void *ee_addr = ioaddr + Cfg9346;
        int read_cmd = location | (EE_READ_CMD << addr_len);
 
 
        writeb (EE_ENB & ~EE_CS, ee_addr);
        writeb (EE_ENB, ee_addr);
        rt_rtl8139_eeprom_delay ();
 
        /* Shift the read command bits out. */
        for (i = 4 + addr_len; i >= 0; i--) {
                int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
                writeb (EE_ENB | dataval, ee_addr);
                rt_rtl8139_eeprom_delay ();
                writeb (EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
                rt_rtl8139_eeprom_delay ();
        }
        writeb (EE_ENB, ee_addr);
        rt_rtl8139_eeprom_delay ();
 
        for (i = 16; i > 0; i--) {
                writeb (EE_ENB | EE_SHIFT_CLK, ee_addr);
                rt_rtl8139_eeprom_delay ();
                retval =
                    (retval << 1) | ((readb (ee_addr) & EE_DATA_READ) ? 1 :
                                     0);
                writeb (EE_ENB, ee_addr);
                rt_rtl8139_eeprom_delay ();
        }
 
        /* Terminate the EEPROM access. */
        writeb (~EE_CS, ee_addr);
        rt_rtl8139_eeprom_delay ();
 
        return retval;
}


/* Set or clear the multicast filter for this adaptor.
   This routine is not state sensitive and need not be SMP locked. */
 
static unsigned const ethernet_polynomial = 0x04c11db7U;
static inline u32 rt_rtl8139_ether_crc (int length, unsigned char *data)
{
        int crc = -1;
 
 
        while (--length >= 0) {
                unsigned char current_octet = *data++;
                int bit;
                for (bit = 0; bit < 8; bit++, current_octet >>= 1)
                        crc = (crc << 1) ^ ((crc < 0) ^ (current_octet & 1) ?
                             ethernet_polynomial : 0);
        }
 
        return crc;
}


 
static void rt_rtl8139_set_rx_mode (struct pci_dev *dev)
{
        void *ioaddr = rtl_8139_tp.mmio_addr;
        int rx_mode;
        u32 tmp;
 
        /* Note: do not reorder, GCC is clever about common statements. */
        rx_mode = AcceptBroadcast | AcceptMyPhys | AcceptAllPhys;
 
        /* We can safely update without stopping the chip. */
        tmp = rtl8139_rx_config | rx_mode |
                (RTL_R32 (RxConfig) & rtl_chip_info[rtl_8139_tp.chipset].RxConfigMask);
        RTL_W32_F (RxConfig, tmp);
 
        rtl_printf ("%s:   rtl8139_set_rx_mode(%4.4x) done -- Rx config %8.8lx.\n",
                        dev->name, rtl_8139_tp.drv_flags, RTL_R32 (RxConfig));
 
}



/* Start the hardware at open or resume. */
static void rt_rtl8139_hw_start (struct pci_dev *dev)
{
        void *ioaddr = rtl_8139_tp.mmio_addr;
        u32 i;
        u8 tmp;
 
 
        /* Soft reset the chip. */
        RTL_W8 (ChipCmd, (RTL_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
        rtl_delay (100);
 
        /* Check that the chip has finished the reset. */
        for (i = 1000; i > 0; i--)
                if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
                        break;

        /* unlock Config[01234] and BMCR register writes */
        RTL_W8_F (Cfg9346, Cfg9346_Unlock);
        /* Restore our idea of the MAC address. */
        RTL_W32_F (MAC0 + 0, cpu_to_le32 (*(u32 *) (rtl_8139_tp.dev_addr + 0)));
        RTL_W32_F (MAC0 + 4, cpu_to_le32 (*(u32 *) (rtl_8139_tp.dev_addr + 4)));
 
        /* Must enable Tx/Rx before setting transfer thresholds! */
        RTL_W8_F (ChipCmd, (RTL_R8 (ChipCmd) & ChipCmdClear) |
                           CmdRxEnb | CmdTxEnb);
 
        i = rtl8139_rx_config |
            (RTL_R32 (RxConfig) & rtl_chip_info[rtl_8139_tp.chipset].RxConfigMask);
        RTL_W32_F (RxConfig, i);
 
        /* Check this value: the documentation for IFG contradicts ifself. */
        RTL_W32 (TxConfig, (TX_DMA_BURST << TxDMAShift));
 
        rtl_8139_tp.cur_rx = 0;
 
        /* This is check_duplex() */
        if (rtl_8139_tp.phys[0] >= 0  ||  (rtl_8139_tp.drv_flags & HAS_MII_XCVR)) {
                u16 mii_reg5 = rt_rtl8139_mdio_read(dev, rtl_8139_tp.phys[0], 5);
                if (mii_reg5 == 0xffff)
                        ;                                       /* Not there */
                else if ((mii_reg5 & 0x0100) == 0x0100
                                 || (mii_reg5 & 0x00C0) == 0x0040)
                        rtl_8139_tp.full_duplex = 1;
                rtl_printf("%s: Setting %s%s-duplex based on"
                           " auto-negotiated partner ability %4.4x.\n", dev->name,
                           mii_reg5 == 0 ? "" :
                           (mii_reg5 & 0x0180) ? "100mbps " : "10mbps ",
                           rtl_8139_tp.full_duplex ? "full" : "half", mii_reg5);
        }
        if (rtl_8139_tp.chipset >= CH_8139A) {
                tmp = RTL_R8 (Config1) & Config1Clear;
                tmp |= Cfg1_Driver_Load;
                tmp |= (rtl_8139_tp.chipset == CH_8139B) ? 3 : 1; /* Enable PM/VPD */
                RTL_W8_F (Config1, tmp);
        } else {
                u8 foo = RTL_R8 (Config1) & Config1Clear;
                RTL_W8 (Config1, rtl_8139_tp.full_duplex ? (foo|0x60) : (foo|0x20));
        }
 
        if (rtl_8139_tp.chipset >= CH_8139B) {
                tmp = RTL_R8 (Config4) & ~(1<<2);
                /* chip will clear Rx FIFO overflow automatically */
                tmp |= (1<<7);
                RTL_W8 (Config4, tmp);
 
                /* disable magic packet scanning, which is enabled
                 * when PM is enabled above (Config1) */
                RTL_W8 (Config3, RTL_R8 (Config3) & ~(1<<5));
        }

        /* Lock Config[01234] and BMCR register writes */
        RTL_W8_F (Cfg9346, Cfg9346_Lock);
        rtl_delay (10);
 
        /* init Rx ring buffer DMA address */
        RTL_W32_F (RxBuf, rtl_8139_tp.rx_ring_dma);
 
        /* init Tx buffer DMA addresses */
        for (i = 0; i < NUM_TX_DESC; i++)
                RTL_W32_F (TxAddr0 + (i * 4), rtl_8139_tp.tx_bufs_dma + (rtl_8139_tp.tx_buf[i] - rtl_8139_tp.tx_bufs)); 
        RTL_W32_F (RxMissed, 0);
 
        rt_rtl8139_set_rx_mode (dev);   
 
        /* no early-rx interrupts */
        RTL_W16 (MultiIntr, RTL_R16 (MultiIntr) & MultiIntrClear);
 
        /* make sure RxTx has started */
        RTL_W8_F (ChipCmd, (RTL_R8 (ChipCmd) & ChipCmdClear) |
                           CmdRxEnb | CmdTxEnb);
 
        /* Enable all known interrupts by setting the interrupt mask. */
        RTL_W16_F (IntrMask, rtl8139_intr_mask);
 
 
}



/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
static void rt_rtl8139_init_ring (struct pci_dev *dev)
{
        int i;
 
 
        rtl_8139_tp.cur_rx = 0;
        rtl_8139_tp.cur_tx = 0;
        rtl_8139_tp.dirty_tx = 0;
 
        for (i = 0; i < NUM_TX_DESC; i++) {
                rtl_8139_tp.tx_info[i].skb = NULL;
                rtl_8139_tp.tx_info[i].mapping = 0;
                rtl_8139_tp.tx_buf[i] = &rtl_8139_tp.tx_bufs[i * TX_BUF_SIZE];
        }
 
}



static int dev_rtl8139_open (struct pci_dev *dev)
{
        int retval;
        long ioaddr;
        ioaddr = (long)rtl_8139_tp.mmio_addr;
 
 
        retval = rtl_request_irq (dev->irq, &rt_rtl8139_interrupt);
        if (retval) {
                rtl_printf ("rtl_request_irq : EXIT, returning %d\n", retval);
                return retval;
        } else rtl_8139_tp.must_free_irq = 1;

        rtl_8139_tp.tx_bufs = pci_alloc_consistent(rtl_8139_tp.pci_dev, TX_BUF_TOT_LEN,
                                           &rtl_8139_tp.tx_bufs_dma);
        rtl_8139_tp.rx_ring = pci_alloc_consistent(rtl_8139_tp.pci_dev, RX_BUF_TOT_LEN,
                                           &rtl_8139_tp.rx_ring_dma);
        if (rtl_8139_tp.tx_bufs == NULL || rtl_8139_tp.rx_ring == NULL) {
                rtl_free_irq(dev->irq);
 
                if (rtl_8139_tp.tx_bufs)
                        pci_free_consistent(rtl_8139_tp.pci_dev, TX_BUF_TOT_LEN,
                                            rtl_8139_tp.tx_bufs, rtl_8139_tp.tx_bufs_dma);
                if (rtl_8139_tp.rx_ring)
                        pci_free_consistent(rtl_8139_tp.pci_dev, RX_BUF_TOT_LEN,
                                            rtl_8139_tp.rx_ring, rtl_8139_tp.rx_ring_dma);
 
                rtl_printf ("EXIT, returning -ENOMEM\n");
                return -ENOMEM;
 
        }
        rtl_8139_tp.full_duplex = rtl_8139_tp.duplex_lock;
        rtl_8139_tp.tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
        rtl_8139_tp.twistie = 1;
 
        rt_rtl8139_init_ring (dev);
        rt_rtl8139_hw_start (dev);     
 
        rtl_printf ("%s: dev_8139_open() ioaddr %#lx IRQ %d"
                        " GP Pins %2.2x %s-duplex.\n",
                        dev->name, pci_resource_start (rtl_8139_tp.pci_dev, 1),
                        dev->irq, RTL_R8 (MediaStatus),
                        rtl_8139_tp.full_duplex ? "full" : "half");
 
        if (rtl_8139_tp.thr_pid < 0)
                rtl_printf ( "%s: unable to start kernel thread\n",
                        dev->name);
 
        return 0;
}




/***************************************************************************************/
int start_up_rtl8139_device(struct pci_dev *dev){

        u32 pio_start, pio_end, pio_flags, pio_len;
        unsigned long mmio_start, mmio_end, mmio_flags;
        unsigned int mmio_len;
        u8 tmp8;
        int rc=0, i, option, addr_len;
        static int board_idx=0;
        u32 tmp;
        void *ioaddr = NULL;
        char *print_name;
 
        print_name = dev ? dev->slot_name : "rtl8139";

        pio_start = rt_pci_resource_start (dev, 0);
        pio_end = rt_pci_resource_end (dev, 0);
        pio_flags = rt_pci_resource_flags (dev, 0);
        pio_len = rt_pci_resource_len (dev, 0);
 
        mmio_start = rt_pci_resource_start (dev, 1);
        mmio_end = rt_pci_resource_end (dev, 1);
        mmio_flags = rt_pci_resource_flags (dev, 1);
        mmio_len = rt_pci_resource_len (dev, 1);
        rtl_8139_tp.mmio_len = mmio_len;

        /* set this immediately, we need to know before
        * we talk to the chip directly */
        if (pio_len == RTL8139B_IO_SIZE) {
                rtl_8139_tp.chipset = CH_8139B;
        }
 
        /* make sure PCI base addr 0 is PIO */
        if (!(pio_flags & IORESOURCE_IO)) {
                rtl_printf ("region #0 not a PIO resource, aborting\n");
        }
 
        /* make sure PCI base addr 1 is MMIO */
        if (!(mmio_flags & IORESOURCE_MEM)) {
                rtl_printf ( "region #1 not an MMIO resource, aborting\n");
        }
 
        /* check for weird/broken PCI region reporting */
        if ((pio_len < RTL_MIN_IO_SIZE) || (mmio_len < RTL_MIN_IO_SIZE)) {
                rtl_printf ( "Invalid PCI region size(s), aborting\n");
        }

 

 
        print_name = dev ? dev->slot_name : "rtl8139";

        rc = pci_request_regions (dev, dev->name);   


        if (rc)
                goto err_out;


        pci_set_master (dev); 

        /* ioremap MMIO region */
        ioaddr = ioremap (mmio_start, mmio_len);
        if (ioaddr == NULL) {
                rtl_printf ("cannot remap MMIO, aborting\n");
                rc = -EIO;
                goto err_out;
        }



        /* Soft reset the chip. */
        RTL_W8 (ChipCmd, (RTL_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
 
        /* Check that the chip has finished the reset. */
        for (i = 1000; i > 0; i--)
                if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
                        break;
                else
                        udelay (10);
 
        /* Bring the chip out of low-power mode. */
        if (rtl_8139_tp.chipset == CH_8139B) {
                RTL_W8 (Config1, RTL_R8 (Config1) & ~(1<<4));

                RTL_W8 (Config4, RTL_R8 (Config4) & ~(1<<2));
        } else {
                /* handle RTL8139A and RTL8139 cases */
                /* XXX from becker driver. is this right?? */
                RTL_W8 (Config1, 0);
        }

        /* make sure chip thinks PIO and MMIO are enabled */
        tmp8 = RTL_R8 (Config1);
        if ((tmp8 & Cfg1_PIO) == 0) {
                rtl_printf ("PIO not enabled, Cfg1=%02X, aborting\n", tmp8);
                rc = -EIO;
                goto err_out;
        }
        if ((tmp8 & Cfg1_MMIO) == 0) {
                rtl_printf ("MMIO not enabled, Cfg1=%02X, aborting\n", tmp8);
                rc = -EIO;
                goto err_out;
        }

        /* identify chip attached to board */
        /*      tmp = RTL_R8 (ChipVersion);   */
        tmp = RTL_R32 (TxConfig);
        tmp = ( (tmp&0x7c000000) + ( (tmp&0x00800000)<<2 ) )>>24;



        rtl_8139_tp.drv_flags = board_info[0].hw_flags;
        rtl_8139_tp.pci_dev = dev;
        rtl_8139_tp.mmio_addr = ioaddr;
 
        for (i = ARRAY_SIZE (rtl_chip_info) - 1; i >= 0; i--)
                if (tmp == rtl_chip_info[i].version) {
                        rtl_8139_tp.chipset = i;
                }
        if(rtl_8139_tp.chipset > (ARRAY_SIZE (rtl_chip_info) - 2))
                rtl_8139_tp.chipset = ARRAY_SIZE (rtl_chip_info) - 2;
 

        /* Find the connected MII xcvrs.
        Doing this in open() would allow detecting external xcvrs later, but takes too much time. */

        if (rtl_8139_tp.drv_flags & HAS_MII_XCVR) {
                int phy, phy_idx = 0;
                for (phy = 0; phy < 32 && phy_idx < sizeof(rtl_8139_tp.phys); phy++) {
                        int mii_status = rt_rtl8139_mdio_read(dev, phy, 1);
                        if (mii_status != 0xffff  &&  mii_status != 0x0000) {
                                rtl_8139_tp.phys[phy_idx++] = phy;
                                rtl_8139_tp.advertising = rt_rtl8139_mdio_read(dev, phy, 4);
                                rtl_printf( "%s: MII transceiver %d status 0x%4.4x "
                                        "advertising %4.4x.\n",
                                        dev->name, phy, mii_status, rtl_8139_tp.advertising);
                        }
                }
                if (phy_idx == 0) {
                        rtl_printf( "%s: No MII transceivers found!  Assuming SYM "
                                "transceiver.\n",
                                dev->name);
                        rtl_8139_tp.phys[0] = 32;
                }
        } else
                rtl_8139_tp.phys[0] = 32;
 
        /* Put the chip into low-power mode. */
        RTL_W8_F (Cfg9346, Cfg9346_Unlock);
 
        tmp = RTL_R8 (Config1) & Config1Clear;
        tmp |= (rtl_8139_tp.chipset == CH_8139B) ? 3 : 1; /* Enable PM/VPD */
        RTL_W8_F (Config1, tmp);
 
        RTL_W8_F (HltClk, 'H'); /* 'R' would leave the clock running. */
 
        /* The lower four bits are the media type. */
        option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
        rtl_8139_tp.AutoNegoAbility = option&0xF;
 
        if (option > 0) {
                rtl_8139_tp.full_duplex = (option & 0x210) ? 1 : 0;
                rtl_8139_tp.default_port = option & 0xFF;
                if (rtl_8139_tp.default_port)
                        rtl_8139_tp.medialock = 1;
        }
        if (board_idx < MAX_UNITS  &&  full_duplex[board_idx] > 0)
                rtl_8139_tp.full_duplex = full_duplex[board_idx];
        if (rtl_8139_tp.full_duplex) {
                rtl_printf( "%s: Media type forced to Full Duplex.\n", dev->name);
                /* Changing the MII-advertised media because might prevent  re-connection. */
                rtl_8139_tp.duplex_lock = 1;
        }
 
        if (rtl_8139_tp.default_port) {
                rtl_printf( "%s: Forcing %dMbs %s-duplex operation.\n", dev->name,
                        (option & 0x0C ? 100 : 10),
                        (option & 0x0A ? "full" : "half"));
                        rt_rtl8139_mdio_write(dev, rtl_8139_tp.phys[0], 0,
                        ((option & 0x20) ? 0x2000 : 0) |     /* 100mbps? */
                        ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
        }

        addr_len = rt_rtl8139_read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
        for (i = 0; i < 3; i++)
                ((u16 *) (rtl_8139_tp.dev_addr))[i] =  le16_to_cpu (rt_rtl8139_read_eeprom (ioaddr, i + 7, addr_len));

        rtl_printf( "%s: %s at 0x%lx, "
                "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
                "IRQ %d\n",
                dev->name,
                board_info[0].name,
                rtl_8139_tp.mmio_addr,
                rtl_8139_tp.dev_addr[0], rtl_8139_tp.dev_addr[1],
                rtl_8139_tp.dev_addr[2], rtl_8139_tp.dev_addr[3],
                rtl_8139_tp.dev_addr[4], rtl_8139_tp.dev_addr[5],
                dev->irq);

        dev_rtl8139_open(dev);

        return 0;
err_out:
                rtl_printf ("EXIT, returning %d\n", rc);
                return rc;
}



static void rt_rtl8139_tx_clear (struct rtl8139_private rtl_8139_tp)
{
        int i;
 
        rtl_8139_tp.cur_tx = 0;
        rtl_8139_tp.dirty_tx = 0;
 
        /* Dump the unsent Tx packets. */
        for (i = 0; i < NUM_TX_DESC; i++) {
                struct ring_info *rp = &rtl_8139_tp.tx_info[i];
                if (rp->mapping != 0) {
                        pci_unmap_single (rtl_8139_tp.pci_dev, rp->mapping,
                                          rp->skb->len, PCI_DMA_TODEVICE);
                        rp->mapping = 0;
                }
                if (rp->skb) {
                        dev_kfree_skb (rp->skb);
                        rp->skb = NULL;
                        rtl_8139_tp.stats.tx_dropped++;
                }
        }
}



static int rt_rtl8139_close (struct pci_dev *dev)
{
        void *ioaddr = rtl_8139_tp.mmio_addr;
 
        rtl_printf ("%s: Shutting down ethercard, status was 0x%4.4x.\n", dev->name, RTL_R16 (IntrStatus));
 
        /* Stop the chip's Tx and Rx DMA processes. */
        RTL_W8 (ChipCmd, (RTL_R8 (ChipCmd) & ChipCmdClear));
 
        /* Disable interrupts by clearing the interrupt mask. */
        RTL_W16 (IntrMask, 0x0000);
 
        /* Update the error counts. */
        rtl_8139_tp.stats.rx_missed_errors += RTL_R32 (RxMissed);
        RTL_W32 (RxMissed, 0);
 
        if(rtl_8139_tp.must_free_irq) { 
            rtl_free_irq (dev->irq);
            rtl_8139_tp.must_free_irq = 0;
        }
 
        rt_rtl8139_tx_clear(rtl_8139_tp);
        pci_free_consistent(rtl_8139_tp.pci_dev, RX_BUF_TOT_LEN,rtl_8139_tp.rx_ring, rtl_8139_tp.rx_ring_dma);
        pci_free_consistent(rtl_8139_tp.pci_dev, TX_BUF_TOT_LEN,rtl_8139_tp.tx_bufs, rtl_8139_tp.tx_bufs_dma);
        rtl_8139_tp.rx_ring = NULL;
        rtl_8139_tp.tx_bufs = NULL;
 
        /* Green! Put the chip in low-power mode. */
        RTL_W8 (Cfg9346, Cfg9346_Unlock);
        RTL_W8 (Config1, 0x03);
        RTL_W8 (HltClk, 'H');   /* 'R' would leave the clock running. */
 
        return 0;
}


static void  rt_rtl8139_remove_one (struct pci_dev *pdev)
{
        long io_addr;
        io_addr = (long)rtl_8139_tp.mmio_addr;
 
        iounmap (rtl_8139_tp.mmio_addr);

        pci_release_regions (pdev);  
}




/***************************************************************************************/
static ssize_t rt_rtl8139_read(struct rtl_file *filp, char *buf, size_t count, loff_t* ppos){
  sem_wait(&rtl8139_sem);
  return  rt_rtl8139_policy.extract_frame_of_buffer(&rt_rtl8139_rx_buffer,buf); 
}


/***************************************************************************************/
static int rt_rtl8139_ioctl(struct rtl_file * filp, unsigned int request, unsigned long other){


        switch(request) {
        case 1:           /* set_ip_filter */
                rt_rtl8139_set_ip_filter(other);
                break;
        case 2:           /* obtain_mac_address */
                rt_rtl8139_obtain_mac_address((unsigned char *)other);
                break;
        }
        return 0;
}

/***************************************************************************************/
static int rt_rtl8139_release (struct rtl_file *filp){
        rtl_irqstate_t state;
        rtl_no_interrupts(state);
        
        rtl_printf("rtl8139_close\n");

        rt_rtl8139_close(rtl8139dev);

        rtl_printf("rtl8139_remove_one\n");

        rt_rtl8139_remove_one (rtl8139dev);

        if(rt_rtl8139_opened == 0x01){
          sem_destroy(&rtl8139_sem);
          rtl_printf("Deallocating rx_buffer\n");
          rt_rtl8139_policy.dealloc_rx_buffer(&rt_rtl8139_rx_buffer);
        }

        rtl_printf("After deallocating rx_buffer\n");

        rt_rtl8139_opened = 0x00;
        rtl_restore_interrupts(state);

        return 0;
}

/***************************************************************************************/
static ssize_t rt_rtl8139_write(struct rtl_file *filp, const char *buf, size_t count, loff_t* ppos)
{

        ssize_t tmp;
        rtl_irqstate_t state;
 
        rtl_no_interrupts(state);
        tmp=rt_rtl8139_send_packet(buf,count);
        rtl_restore_interrupts(state);
 
        return tmp;
 
}

/***************************************************************************************/
static int rt_rtl8139_open (struct rtl_file *filp){


        if(rt_rtl8139_opened == 0x00){
                if((rtl8139dev = init_rtl8139_device())!=NULL){
                  sem_init(&rtl8139_sem, 0, 0);

                  start_up_rtl8139_device(rtl8139dev);
                  rt_rtl8139_opened = 0x01;
                  rtl_printf("Successfully Opened\n");
                  return RTL8139_MAJOR;
                }else{
                        rtl_printf("ERROR: Couldn't initialize device\n");
                        return -1;
                }
        }else{
                rtl_printf("Device is already opened\n");
                return -1;
        }
}

/***************************************************************************************/
struct pci_dev *init_rtl8139_device(void){
        struct pci_dev *dev;
 
        /* First of all, we must get a pointer to the pci_dev structure */
        if((dev = rt_pci_find_device(RTL8139_VENDOR_ID, RTL8139_DEVICE_ID, NULL))== NULL)
        return NULL;
 
        rt_rtl8139_policy.initialize_rx_buffer(&rt_rtl8139_rx_buffer);
 
        /* Let's enable the device */
        if (rt_pci_enable_device(dev)){
                rtl_printf("PCI ERROR: Can't enable device\n");
                return NULL;
        }
 
        return dev;
}



/***************************************************************************************/
int init_module(void){
        printk("\n\n\nRT-Linux driver for the Ethernet Card rtl8139 being loaded\n\n\n");
 
        if (rtl_register_rtldev (RTL8139_MAJOR, RTL8139_NAME, &rt_rtl8139_fops)) {
                printk ("RTLinux /dev/%s: unable to get RTLinux major %d\n", RTL8139_NAME, RTL8139_MAJOR);
                return -EIO;
        }else{
                printk("Registered device /dev/%s major number %d\n",RTL8139_NAME, RTL8139_MAJOR);
                rt_rtl8139_registered = 0x01;
                return 0;
        }
}


/***************************************************************************************/
void cleanup_module(void){

        int inside = 1;
        rtl_irqstate_t state;
 
        if((rt_rtl8139_opened == 0x01) || rt_rtl8139_inside_the_interrupt_handler){

          rt_rtl8139_trying_to_close = 1;
 
          /* Since inside the interrupt handler there's a call to the scheduler, there may  */
          /* be an execution of the interrupt handler that hasn't been completely executed. */
          /* The card cannot be released in that case, so we must be sure that there is no  */
          /* interrupt handler execution pending. Otherwise, that may crash the system.     */
          while(inside){
            rtl_no_interrupts(state);
 
            if(rt_rtl8139_inside_the_interrupt_handler){
              rtl_restore_interrupts(state);
              usleep(10);
            }else{
              rtl_hard_disable_irq(rtl_8139_tp.pci_dev->irq);
              rtl_restore_interrupts(state);
              inside = 0;
            }
          }
        }

        if(rt_rtl8139_registered == 0x01){
                printk("Unregistering device /dev/%s\n",RTL8139_NAME);
                rtl_unregister_rtldev(RTL8139_MAJOR,RTL8139_NAME);
        }
        printk("\n\n\nRT-Linux driver for the Ethernet Card rtl8139 being removed\n\n\n");
}

---