rtl_rtl8139_drv.c File Reference

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

Include dependency graph for rtl_rtl8139_drv.c:

Go to the source code of this file.

Defines
#define	RTL8139_MAJOR   205
#define	RTL8139_NAME   "rtl"
#define	RTL8139_SIGNAL   RTL_SIGUSR1
#define	EE_SHIFT_CLK   0x04
#define	EE_CS   0x08
#define	EE_DATA_WRITE   0x02
#define	EE_WRITE_0   0x00
#define	EE_WRITE_1   0x02
#define	EE_DATA_READ   0x01
#define	EE_ENB   (0x80 | EE_CS)
#define	rt_rtl8139_eeprom_delay()   readl(ee_addr)
#define	EE_WRITE_CMD   (5)
#define	EE_READ_CMD   (6)
#define	EE_ERASE_CMD   (7)
Functions
	MODULE_LICENSE ("GPL")
int	rt_rtl8139_read_eeprom (void *ioaddr, int location, int addr_len)
int	rt_rtl8139_mdio_read (struct pci_dev *dev, int phy_id, int location)
void	rt_rtl8139_mdio_write (struct pci_dev *dev, int phy_id, int location, int val)
pci_dev *	init_rtl8139_device (void)
int	start_up_rtl8139_device (struct pci_dev *dev)
int	dev_rtl8139_open (struct pci_dev *dev)
int	rt_rtl8139_open (struct rtl_file *filp)
int	rt_rtl8139_release (struct rtl_file *filp)
ssize_t	rt_rtl8139_write (struct rtl_file *filp, const char *buf, size_t count, loff_t *ppos)
int	rt_rtl8139_ioctl (struct rtl_file *filp, unsigned int request, unsigned long other)
ssize_t	rt_rtl8139_read (struct rtl_file *filp, char *buf, size_t count, loff_t *ppos)
void	rt_rtl8139_send_signal (void)
int	rt_rtl8139_obtain_mac_address (unsigned char *mac)
int	rt_rtl8139_set_ip_filter (long ipaddr)
void	rt_rtl8139_rx_interrupt (struct pci_dev *dev)
int	rt_rtl8139_send_packet (const char *buffer, size_t size)
void	rt_rtl8139_tx_interrupt (struct pci_dev *dev)
unsigned int	rt_rtl8139_interrupt (unsigned int irq, struct pt_regs *regs)
void	rt_rtl8139_mdio_sync (void *mdio_addr)
u32	rt_rtl8139_ether_crc (int length, unsigned char *data)
void	rt_rtl8139_set_rx_mode (struct pci_dev *dev)
void	rt_rtl8139_hw_start (struct pci_dev *dev)
void	rt_rtl8139_init_ring (struct pci_dev *dev)
void	rt_rtl8139_tx_clear (struct rtl8139_private rtl_8139_tp)
int	rt_rtl8139_close (struct pci_dev *dev)
void	rt_rtl8139_remove_one (struct pci_dev *pdev)
int	init_module (void)
void	cleanup_module (void)
Variables
sem_t	rtl8139_sem
net_policy_operations	rt_rtl8139_policy
fifo_rx_buffer_t	rt_rtl8139_rx_buffer
rtl_file_operations	rt_rtl8139_fops
int	rt_rtl8139_inside_the_interrupt_handler = 0 rt_rtl8139_trying_to_close = 0
int	rt_rtl8139_interrupted = 0 rt_rtl8139_writting = 0
int	rt_rtl8139_max_interrupt_work = 20
unsigned char	rt_rtl8139_ip_addr [2][4] = {{0x00,0x00,0x00,0x00},{0x00,0x00,0x00,0x00}}
int	rt_rtl8139_n_filters = 0
unsigned char	rt_rtl8139_registered = 0x00 rt_rtl8139_opened = 0x00 rt_rtl8139_sended = 0x01
pci_dev *	rtl8139dev
rtl8139_private	rtl_8139_tp
unsigned const	ethernet_polynomial = 0x04c11db7U

---

Define Documentation

#define EE_CS   0x08

Definition at line 605 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_read_eeprom().

#define EE_DATA_READ   0x01

Definition at line 609 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_read_eeprom().

#define EE_DATA_WRITE   0x02

Definition at line 606 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_read_eeprom().

#define EE_ENB   (0x80 | EE_CS)

Definition at line 610 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_read_eeprom().

#define EE_ERASE_CMD   (7)

Definition at line 621 of file rtl_rtl8139_drv.c.

#define EE_READ_CMD   (6)

Definition at line 620 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_read_eeprom().

#define EE_SHIFT_CLK   0x04

Definition at line 604 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_read_eeprom().

#define EE_WRITE_0   0x00

Definition at line 607 of file rtl_rtl8139_drv.c.

#define EE_WRITE_1   0x02

Definition at line 608 of file rtl_rtl8139_drv.c.

#define EE_WRITE_CMD   (5)

Definition at line 619 of file rtl_rtl8139_drv.c.

#define rt_rtl8139_eeprom_delay (   )     readl(ee_addr)

Definition at line 616 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_read_eeprom().

#define RTL8139_MAJOR   205

Definition at line 163 of file rtl_rtl8139_drv.c. Referenced by cleanup_module(), init_module(), and rt_rtl8139_open().

#define RTL8139_NAME   "rtl"

Definition at line 164 of file rtl_rtl8139_drv.c. Referenced by cleanup_module(), and init_module().

#define RTL8139_SIGNAL   RTL_SIGUSR1

Definition at line 165 of file rtl_rtl8139_drv.c.

---

Function Documentation

void cleanup_module (  void   )

Definition at line 1287 of file rtl_rtl8139_drv.c. References rtl8139_private::pci_dev, rt_rtl8139_inside_the_interrupt_handler, rt_rtl8139_registered, RTL8139_MAJOR, RTL8139_NAME, and rtl_8139_tp. { 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"); }

int dev_rtl8139_open (  struct pci_dev *  dev  )  [static]

Definition at line 827 of file rtl_rtl8139_drv.c. References rtl8139_private::duplex_lock, rtl8139_private::full_duplex, MediaStatus, rtl8139_private::mmio_addr, rtl8139_private::must_free_irq, NULL, rtl8139_private::pci_dev, rt_rtl8139_hw_start(), rt_rtl8139_init_ring(), rt_rtl8139_interrupt(), rtl_8139_tp, RTL_R8, RX_BUF_TOT_LEN, rtl8139_private::rx_ring, rtl8139_private::rx_ring_dma, rtl8139_private::thr_pid, rtl8139_private::twistie, TX_BUF_TOT_LEN, rtl8139_private::tx_bufs, rtl8139_private::tx_bufs_dma, TX_FIFO_THRESH, and rtl8139_private::tx_flag. Referenced by start_up_rtl8139_device(). { 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; }

Here is the call graph for this function:

int init_module (  void   )

Definition at line 1272 of file rtl_rtl8139_drv.c. References rt_rtl8139_fops, rt_rtl8139_registered, RTL8139_MAJOR, and RTL8139_NAME. { 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; } }

struct pci_dev * init_rtl8139_device (  void   )

Definition at line 1251 of file rtl_rtl8139_drv.c. References net_policy_operations::initialize_rx_buffer, NULL, rt_pci_enable_device(), rt_pci_find_device(), rt_rtl8139_policy, rt_rtl8139_rx_buffer, RTL8139_DEVICE_ID, and RTL8139_VENDOR_ID. Referenced by rt_rtl8139_open(). { 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; }

Here is the call graph for this function:

MODULE_LICENSE (  "GPL"   )

int rt_rtl8139_close (  struct pci_dev *  dev  )  [static]

Definition at line 1115 of file rtl_rtl8139_drv.c. References Cfg9346, Cfg9346_Unlock, ChipCmd, ChipCmdClear, Config1, HltClk, IntrMask, IntrStatus, rtl8139_private::mmio_addr, rtl8139_private::must_free_irq, NULL, rtl8139_private::pci_dev, rt_rtl8139_tx_clear(), rtl_8139_tp, RTL_R16, RTL_R32, RTL_R8, RTL_W16, RTL_W32, RTL_W8, RX_BUF_TOT_LEN, rtl8139_private::rx_ring, rtl8139_private::rx_ring_dma, RxMissed, rtl8139_private::stats, TX_BUF_TOT_LEN, rtl8139_private::tx_bufs, and rtl8139_private::tx_bufs_dma. Referenced by rt_rtl8139_release(). { 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; }

Here is the call graph for this function:

u32 rt_rtl8139_ether_crc (  int  length, unsigned char *  data )  [inline, static]

Definition at line 668 of file rtl_rtl8139_drv.c. References data, and ethernet_polynomial. { 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; }

void rt_rtl8139_hw_start (  struct pci_dev *  dev  )  [static]

Definition at line 708 of file rtl_rtl8139_drv.c. References Cfg1_Driver_Load, Cfg9346, Cfg9346_Lock, Cfg9346_Unlock, CH_8139A, CH_8139B, ChipCmd, ChipCmdClear, rtl8139_private::chipset, CmdReset, CmdRxEnb, CmdTxEnb, Config1, Config1Clear, Config3, Config4, rtl8139_private::cur_rx, rtl8139_private::dev_addr, rtl8139_private::drv_flags, rtl8139_private::full_duplex, HAS_MII_XCVR, IntrMask, MAC0, rtl8139_private::mmio_addr, MultiIntr, MultiIntrClear, NUM_TX_DESC, rtl8139_private::phys, rt_rtl8139_mdio_read(), rt_rtl8139_set_rx_mode(), rtl_8139_tp, RTL_R16, RTL_R32, RTL_R8, RTL_W16, RTL_W16_F, RTL_W32, RTL_W32_F, RTL_W8, RTL_W8_F, rtl8139_private::rx_ring_dma, RxBuf, RxConfig, RxMissed, rtl8139_private::tx_buf, rtl8139_private::tx_bufs, rtl8139_private::tx_bufs_dma, TX_DMA_BURST, TxAddr0, TxConfig, and TxDMAShift. Referenced by dev_rtl8139_open(). { 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); }

Here is the call graph for this function:

void rt_rtl8139_init_ring (  struct pci_dev *  dev  )  [static]

Definition at line 808 of file rtl_rtl8139_drv.c. References rtl8139_private::cur_rx, rtl8139_private::cur_tx, rtl8139_private::dirty_tx, ring_info::mapping, NULL, NUM_TX_DESC, rtl_8139_tp, ring_info::skb, rtl8139_private::tx_buf, TX_BUF_SIZE, rtl8139_private::tx_bufs, and rtl8139_private::tx_info. Referenced by dev_rtl8139_open(). { 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]; } }

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

Definition at line 440 of file rtl_rtl8139_drv.c. References CSCR, CSCR_LinkChangeBit, IntrStatus, rtl8139_private::mmio_addr, rtl8139_private::pci_dev, PCIErr, PCSTimeout, rt_rtl8139_inside_the_interrupt_handler, rt_rtl8139_interrupted, rt_rtl8139_max_interrupt_work, rt_rtl8139_rx_interrupt(), rt_rtl8139_tx_interrupt(), rtl8139dev, rtl_8139_tp, RTL_R16, RTL_W16, RTL_W16_F, RxErr, RxFIFOOver, RxOK, RxOverflow, RxUnderrun, status, TxErr, and TxOK. Referenced by dev_rtl8139_open(). { 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); }

Here is the call graph for this function:

int rt_rtl8139_ioctl (  struct rtl_file *  filp, unsigned int  request, unsigned long  other )  [static]

Definition at line 1172 of file rtl_rtl8139_drv.c. References rt_rtl8139_obtain_mac_address(), and rt_rtl8139_set_ip_filter(). { 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; }

Here is the call graph for this function:

int rt_rtl8139_mdio_read (  struct pci_dev *  dev, int  phy_id, int  location )  [static]

Definition at line 516 of file rtl_rtl8139_drv.c. References Config4, MDIO_CLK, MDIO_DATA_IN, MDIO_DATA_OUT, MDIO_DIR, rtl8139_private::mmio_addr, rt_rtl8139_mdio_delay, rt_rtl8139_mdio_sync(), and rtl_8139_tp. Referenced by rt_rtl8139_hw_start(), and start_up_rtl8139_device(). { 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; }

Here is the call graph for this function:

void rt_rtl8139_mdio_sync (  void *  mdio_addr  )  [static]

Definition at line 501 of file rtl_rtl8139_drv.c. References MDIO_CLK, MDIO_WRITE1, and rt_rtl8139_mdio_delay. Referenced by rt_rtl8139_mdio_read(), and rt_rtl8139_mdio_write(). { 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); } }

void rt_rtl8139_mdio_write (  struct pci_dev *  dev, int  phy_id, int  location, int  val )  [static]

Definition at line 552 of file rtl_rtl8139_drv.c. References rtl8139_private::AutoNegoAbility, AutoNegoAbility100full, AutoNegoAbility100half, AutoNegoAbility10full, AutoNegoAbility10half, AutoNegotiationEnable, AutoNegotiationRestart, BasicModeCtrl, Cfg9346, Cfg9346_Lock, Cfg9346_Unlock, Config4, MDIO_CLK, MDIO_WRITE0, MDIO_WRITE1, rtl8139_private::mmio_addr, NWayAdvert, rt_rtl8139_mdio_delay, rt_rtl8139_mdio_sync(), rtl_8139_tp, RTL_W16, RTL_W16_F, and RTL_W8_F. Referenced by start_up_rtl8139_device(). { 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; }

Here is the call graph for this function:

int rt_rtl8139_obtain_mac_address (  unsigned char *  mac  )

Definition at line 207 of file rtl_rtl8139_drv.c. References rtl8139_private::dev_addr, and rtl_8139_tp. Referenced by rt_rtl8139_ioctl(). { int i; for(i=0; i<6; i++) mac[i]=rtl_8139_tp.dev_addr[i]; return 0; }

int rt_rtl8139_open (  struct rtl_file *  filp  )  [static]

Definition at line 1229 of file rtl_rtl8139_drv.c. References init_rtl8139_device(), NULL, RTL8139_MAJOR, rtl8139_sem, rtl8139dev, and start_up_rtl8139_device(). { 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; } }

Here is the call graph for this function:

ssize_t rt_rtl8139_read (  struct rtl_file *  filp, char *  buf, size_t  count, loff_t *  ppos )  [static]

Definition at line 1165 of file rtl_rtl8139_drv.c. References net_policy_operations::extract_frame_of_buffer, rt_rtl8139_policy, rt_rtl8139_rx_buffer, and rtl8139_sem. { sem_wait(&rtl8139_sem); return rt_rtl8139_policy.extract_frame_of_buffer(&rt_rtl8139_rx_buffer,buf); }

int __devinit rt_rtl8139_read_eeprom (  void *  ioaddr, int  location, int  addr_len )  [static]

Definition at line 623 of file rtl_rtl8139_drv.c. References Cfg9346, EE_CS, EE_DATA_READ, EE_DATA_WRITE, EE_ENB, EE_READ_CMD, EE_SHIFT_CLK, and rt_rtl8139_eeprom_delay. Referenced by start_up_rtl8139_device(). { 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; }

int rt_rtl8139_release (  struct rtl_file *  filp  )  [static]

Definition at line 1187 of file rtl_rtl8139_drv.c. References net_policy_operations::dealloc_rx_buffer, rt_rtl8139_close(), rt_rtl8139_policy, rt_rtl8139_remove_one(), rt_rtl8139_rx_buffer, rtl8139_sem, and rtl8139dev. { 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; }

Here is the call graph for this function:

void rt_rtl8139_remove_one (  struct pci_dev *  pdev  )  [static]

Definition at line 1151 of file rtl_rtl8139_drv.c. References rtl8139_private::mmio_addr, and rtl_8139_tp. Referenced by rt_rtl8139_release(). { long io_addr; io_addr = (long)rtl_8139_tp.mmio_addr; iounmap (rtl_8139_tp.mmio_addr); pci_release_regions (pdev); }

void rt_rtl8139_rx_interrupt (  struct pci_dev *  dev  )  [static]

Definition at line 232 of file rtl_rtl8139_drv.c. References net_policy_operations::add_frame_to_buffer, ChipCmd, rtl8139_private::cur_rx, rtl8139_private::dev_addr, MAX_ETH_FRAME_SIZE, rtl8139_private::mmio_addr, rt_rtl8139_ip_addr, rt_rtl8139_n_filters, rt_rtl8139_policy, rt_rtl8139_rx_buffer, rtl8139_sem, rtl_8139_tp, RTL_R8, RTL_W16_F, RX_BUF_LEN, rtl8139_private::rx_frames_for_us, rtl8139_private::rx_ring, RxBufEmpty, RxBufPtr, RxStatusOK, and rtl8139_private::stats. Referenced by rt_rtl8139_interrupt(). { 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; }

int rt_rtl8139_send_packet (  const char *  buffer, size_t  size )  [static]

Definition at line 329 of file rtl_rtl8139_drv.c. References buffer, rtl8139_private::cur_tx, len, ring_info::mapping, rtl8139_private::mmio_addr, NUM_TX_DESC, rtl8139_private::pci_dev, rtl_8139_tp, RTL_W32, rtl8139_private::tx_buf, rtl8139_private::tx_flag, rtl8139_private::tx_info, TxAddr0, and TxStatus0. Referenced by rt_rtl8139_write(). { 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; }

void rt_rtl8139_send_signal (  void   )

int rt_rtl8139_set_ip_filter (  long  ipaddr  )

Definition at line 217 of file rtl_rtl8139_drv.c. References ipaddr, rt_rtl8139_ip_addr, and rt_rtl8139_n_filters. Referenced by rt_rtl8139_ioctl(). { 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; }

void rt_rtl8139_set_rx_mode (  struct pci_dev *  dev  )  [static]

Definition at line 686 of file rtl_rtl8139_drv.c. References AcceptAllPhys, AcceptBroadcast, AcceptMyPhys, rtl8139_private::chipset, rtl8139_private::drv_flags, rtl8139_private::mmio_addr, rtl_8139_tp, RTL_R32, RTL_W32_F, and RxConfig. Referenced by rt_rtl8139_hw_start(). { 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)); }

void rt_rtl8139_tx_clear (  struct rtl8139_private  rtl_8139_tp  )  [static]

Definition at line 1090 of file rtl_rtl8139_drv.c. References rtl8139_private::cur_tx, rtl8139_private::dirty_tx, NULL, NUM_TX_DESC, rtl8139_private::pci_dev, rtl_8139_tp, rtl8139_private::stats, and rtl8139_private::tx_info. Referenced by rt_rtl8139_close(). { 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++; } } }

void rt_rtl8139_tx_interrupt (  struct pci_dev *  dev  )  [static]

Definition at line 362 of file rtl_rtl8139_drv.c. References rtl8139_private::cur_tx, rtl8139_private::dirty_tx, ring_info::mapping, rtl8139_private::mmio_addr, NULL, NUM_TX_DESC, rtl8139_private::pci_dev, rtl_8139_tp, RTL_R32, RTL_W32, ring_info::skb, rtl8139_private::stats, TX_DMA_BURST, rtl8139_private::tx_flag, rtl8139_private::tx_info, TxAborted, TxCarrierLost, TxClearAbt, TxConfig, TxDMAShift, TxOutOfWindow, TxStatOK, TxStatus0, and TxUnderrun. Referenced by rt_rtl8139_interrupt(). { 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; } }

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

Definition at line 1214 of file rtl_rtl8139_drv.c. References rt_rtl8139_send_packet(). { ssize_t tmp; rtl_irqstate_t state; rtl_no_interrupts(state); tmp=rt_rtl8139_send_packet(buf,count); rtl_restore_interrupts(state); return tmp; }

Here is the call graph for this function:

int start_up_rtl8139_device (  struct pci_dev *  dev  )

Definition at line 882 of file rtl_rtl8139_drv.c. References rtl8139_private::advertising, rtl8139_private::AutoNegoAbility, Cfg1_MMIO, Cfg1_PIO, Cfg9346, Cfg9346_Unlock, CH_8139B, ChipCmd, ChipCmdClear, rtl8139_private::chipset, CmdReset, Config1, Config1Clear, Config4, rtl8139_private::default_port, rtl8139_private::dev_addr, dev_rtl8139_open(), rtl8139_private::drv_flags, rtl8139_private::duplex_lock, rtl8139_private::full_duplex, HAS_MII_XCVR, HltClk, MAX_UNITS, rtl8139_private::medialock, rtl8139_private::mmio_addr, rtl8139_private::mmio_len, NULL, rtl8139_private::pci_dev, rtl8139_private::phys, rt_pci_resource_end, rt_pci_resource_flags, rt_pci_resource_len, rt_pci_resource_start, rt_rtl8139_mdio_read(), rt_rtl8139_mdio_write(), rt_rtl8139_read_eeprom(), RTL8139B_IO_SIZE, rtl_8139_tp, RTL_MIN_IO_SIZE, RTL_R32, RTL_R8, RTL_W8, RTL_W8_F, and TxConfig. Referenced by rt_rtl8139_open(). { 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; }

Here is the call graph for this function:

---

Variable Documentation

unsigned const ethernet_polynomial = 0x04c11db7U [static]

Definition at line 667 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_ether_crc().

struct rtl_file_operations rt_rtl8139_fops [static]

Initial value: { NULL, rt_rtl8139_read, rt_rtl8139_write, rt_rtl8139_ioctl, NULL, rt_rtl8139_open, rt_rtl8139_release } Definition at line 185 of file rtl_rtl8139_drv.c. Referenced by init_module().

int rt_rtl8139_inside_the_interrupt_handler = 0 rt_rtl8139_trying_to_close = 0 [static]

Definition at line 195 of file rtl_rtl8139_drv.c. Referenced by cleanup_module(), and rt_rtl8139_interrupt().

int rt_rtl8139_interrupted = 0 rt_rtl8139_writting = 0 [static]

Definition at line 196 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_interrupt().

unsigned char rt_rtl8139_ip_addr[2][4] = {{0x00,0x00,0x00,0x00},{0x00,0x00,0x00,0x00}}

Definition at line 200 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_rx_interrupt(), and rt_rtl8139_set_ip_filter().

int rt_rtl8139_max_interrupt_work = 20 [static]

Definition at line 199 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_interrupt().

int rt_rtl8139_n_filters = 0 [static]

Definition at line 201 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_rx_interrupt(), and rt_rtl8139_set_ip_filter().

struct net_policy_operations rt_rtl8139_policy [static]

Initial value: { FIFO_add_frame_to_buffer, FIFO_extract_frame_of_buffer, FIFO_initialize_rx_buffer, FIFO_dealloc_rx_buffer, } Definition at line 154 of file rtl_rtl8139_drv.c. Referenced by init_rtl8139_device(), rt_rtl8139_read(), rt_rtl8139_release(), and rt_rtl8139_rx_interrupt().

unsigned char rt_rtl8139_registered = 0x00 rt_rtl8139_opened = 0x00 rt_rtl8139_sended = 0x01

Definition at line 202 of file rtl_rtl8139_drv.c. Referenced by cleanup_module(), and init_module().

struct fifo_rx_buffer_t rt_rtl8139_rx_buffer [static]

Definition at line 161 of file rtl_rtl8139_drv.c. Referenced by init_rtl8139_device(), rt_rtl8139_read(), rt_rtl8139_release(), and rt_rtl8139_rx_interrupt().

sem_t rtl8139_sem [static]

Definition at line 152 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_open(), rt_rtl8139_read(), rt_rtl8139_release(), and rt_rtl8139_rx_interrupt().

struct pci_dev* rtl8139dev

Definition at line 203 of file rtl_rtl8139_drv.c. Referenced by rt_rtl8139_interrupt(), rt_rtl8139_open(), and rt_rtl8139_release().

struct rtl8139_private rtl_8139_tp

Definition at line 204 of file rtl_rtl8139_drv.c. Referenced by cleanup_module(), dev_rtl8139_open(), rt_rtl8139_close(), rt_rtl8139_hw_start(), rt_rtl8139_init_ring(), rt_rtl8139_interrupt(), rt_rtl8139_mdio_read(), rt_rtl8139_mdio_write(), rt_rtl8139_obtain_mac_address(), rt_rtl8139_remove_one(), rt_rtl8139_rx_interrupt(), rt_rtl8139_send_packet(), rt_rtl8139_set_rx_mode(), rt_rtl8139_tx_clear(), rt_rtl8139_tx_interrupt(), and start_up_rtl8139_device().

---