etherlabmaster: comparison drivers/drv

equal deleted inserted replaced

-:394c89f02e48
+:6f2508af550c
 /******************************************************************************
 *
 *  drv_8139too.c
 *
 *  EtherCAT-Treiber für RTL8139-kompatible Netzwerkkarten.
 *
 *  Autoren: Wilhelm Hagemeister, Florian Pose
 *
 *  $Date$
 *  $Author$
 *
 #include <asm/uaccess.h>
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 #include "ec_device.h"
-#include <rtai.h>
-#include <linux/delay.h>
 #include "ec_dbg.h"
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 #define RTL8139_DRIVER_NAME   DRV_NAME " Fast Ethernet driver " DRV_VERSION
 The RTL chips use a 64 element hash table based on the Ethernet CRC.  */
 static int multicast_filter_limit = 32;
 /* bitmapped message enable number */
 static int debug = -1;
+/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
+// Device index for EtherCAT device selection
+static int ec_device_index = -1;
+//#define ECAT_DEBUG
+EtherCAT_device_t rtl_ecat_dev;
+/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 /* Size of the in-memory receive ring. */
 #define RX_BUF_LEN_IDX	2	/* 0==8K, 1==16K, 2==32K, 3==64K */
 #define RX_BUF_LEN	(8192 << RX_BUF_LEN_IDX)
 #define RX_BUF_PAD	16
 MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");
 MODULE_PARM_DESC (max_interrupt_work, "8139too maximum events handled per interrupt");
 MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");
 MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");
+/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
+MODULE_PARM(ec_device_index, "i");
+MODULE_PARM_DESC(ec_device_index, "Index of the device reserved for EtherCAT.");
+/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 static int read_eeprom (void *ioaddr, int location, int addr_len);
 static int rtl8139_open (struct net_device *dev);
 static int mdio_read (struct net_device *dev, int phy_id, int location);
 static void mdio_write (struct net_device *dev, int phy_id, int location,
 			int val);
 static void rtl8139_init_ring (struct net_device *dev);
 static int rtl8139_start_xmit (struct sk_buff *skb,
 			       struct net_device *dev);
 static void rtl8139_interrupt (int irq, void *dev_instance,
 			       struct pt_regs *regs);
-static void rt_rtl8139_interrupt(void);
 static int rtl8139_close (struct net_device *dev);
 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);
 static void rtl8139_set_rx_mode (struct net_device *dev);
 static void __set_rx_mode (struct net_device *dev);
 #define RTL_R8(reg)		readb (ioaddr + (reg))
 #define RTL_R16(reg)		readw (ioaddr + (reg))
 #define RTL_R32(reg)		((unsigned long) readl (ioaddr + (reg)))
 #endif /* USE_IO_OPS */
-/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-#define ECATcard 1  // Diese Ethernetkarte wird für Ethercat verwendet
-//#define ECAT_DEBUG
-EtherCAT_device_t rtl_ecat_dev;
-/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 static const u16 rtl8139_intr_mask =
 	PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
 	TxErr | TxOK | RxErr | RxOK;
 	if (i < 0)
 		return i;
 	/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-	if (board_idx == ECATcard)
+	if (board_idx == ec_device_index)
 {
 EC_DBG("EtherCAT registering board %d.\n", board_idx);
 if (EtherCAT_device_assign(&rtl_ecat_dev, dev) < 0)
 goto err_out;
 	tp->mmio_addr = ioaddr;
 	spin_lock_init (&tp->lock);
 	/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-	if (board_idx == ECATcard)
+	if (board_idx == ec_device_index)
 {
 rtl_ecat_dev.lock = &tp->lock;
 	}
 	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 EC_DBG(KERN_DEBUG "%s: open\n", dev->name);
 	/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 if (dev != rtl_ecat_dev.dev)
 {
 retval = request_irq(dev->irq, rtl8139_interrupt, SA_SHIRQ, dev->name, dev);
+if (retval)
+return retval;
 }
-	else
-{
-//rt_disable_irq(dev->irq);
-retval =  rt_request_global_irq(dev->irq,rt_rtl8139_interrupt);
-	  //rt_enable_irq(dev->irq);
-}
-if (retval)
-return retval;
 	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
 					   &tp->tx_bufs_dma);
 if (dev != rtl_ecat_dev.dev)
 {
 free_irq(dev->irq, dev);
 }
-else
-{
-rt_free_global_irq (dev->irq);
-}
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 if (tp->tx_bufs)
 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
 tp->tx_bufs, tp->tx_bufs_dma);
 if (tp->rx_ring)
 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
 tp->rx_ring, tp->rx_ring_dma);
 return -ENOMEM;
 	}
 	tp->mii.full_duplex = tp->mii.force_media;
 if (tp->thr_pid < 0)
 EC_DBG (KERN_WARNING "%s: unable to start kernel thread\n",
 dev->name);
 	}
-#if 0
-else
-{
-rt_enable_irq(dev->irq);
-}
-#endif
 	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 EC_DBG(KERN_DEBUG "%s: open finished.\n", dev->name);
 {
 	struct rtl8139_private *tp = dev->priv;
 	if (tp->phys[0] >= 0) {
 		u16 mii_lpa = mdio_read(dev, tp->phys[0], MII_LPA);
 		if (mii_lpa == 0xffff)
 			;					/* Not there */
 		else if ((mii_lpa & LPA_100FULL) == LPA_100FULL
 				 || (mii_lpa & 0x00C0) == LPA_10FULL)
 			tp->mii.full_duplex = 1;
 	/* make sure RxTx has started */
 	tmp = RTL_R8 (ChipCmd);
 	if ((!(tmp & CmdRxEnb)) || (!(tmp & CmdTxEnb)))
 		RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
-	/* Enable all known interrupts by setting the interrupt mask. */
-	RTL_W16 (IntrMask, rtl8139_intr_mask);
 	/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-if (dev != rtl_ecat_dev.dev) netif_start_queue (dev);
+if (dev != rtl_ecat_dev.dev)
+{
-	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
+/* Enable all known interrupts by setting the interrupt mask. */
+RTL_W16 (IntrMask, rtl8139_intr_mask);
+netif_start_queue (dev);
+}
+else
+{
+RTL_W16 (IntrMask, 0x0000);
+}
+	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 EC_DBG(KERN_DEBUG "%s: rtl8139_hw_start finished.\n", dev->name);
 }
 		EC_DBG (KERN_DEBUG "%s:  Tx descriptor %d is %8.8lx.%s\n",
 			dev->name, i, RTL_R32 (TxStatus0 + (i * 4)),
 			i == (int) (tp->dirty_tx % NUM_TX_DESC) ?
 				" (queue head)" : "");
-	/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 	/* Stop a shared interrupt from scavenging while we are. */
-	if (dev == rtl_ecat_dev.dev)
+spin_lock_irqsave (&tp->lock, flags);
-{
+rtl8139_tx_clear (tp);
-	    flags = rt_spin_lock_irqsave (&tp->lock);
+spin_unlock_irqrestore (&tp->lock, flags);
-	    rtl8139_tx_clear (tp);
-	    rt_spin_unlock_irqrestore (&tp->lock,flags);
-	}
-	else {
-	    spin_lock_irqsave (&tp->lock, flags);
-	    rtl8139_tx_clear (tp);
-	    spin_unlock_irqrestore (&tp->lock, flags);
-	}
-	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	/* ...and finally, reset everything */
 	rtl8139_hw_start (dev);
 	/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 	if (likely(len < TX_BUF_SIZE))
 {
 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
 // Socket buffer nicht löschen, wenn vom EtherCAT-device
 if (dev != rtl_ecat_dev.dev) dev_kfree_skb(skb);
 	}
 else
 {
 if (dev != rtl_ecat_dev.dev) dev_kfree_skb(skb);
 tp->stats.tx_dropped++;
 return 0;
 	}
+	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	/* Note: the chip doesn't have auto-pad! */
-	if (dev == rtl_ecat_dev.dev)
+spin_lock_irq(&tp->lock);
-{
-rt_spin_lock_irq(&tp->lock);
-}
-	else
-{
-spin_lock_irq(&tp->lock);
-}
-/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
 		   tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
 	dev->trans_start = jiffies;
 && ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx))
 {
 netif_stop_queue (dev);
 }
-	if (dev == rtl_ecat_dev.dev)
-{
-rt_spin_unlock_irq(&tp->lock);
-}
-	else
-{
-spin_unlock_irq(&tp->lock);
-}
 	/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
+spin_unlock_irq(&tp->lock);
 	DPRINTK ("%s: Queued Tx packet size %u to slot %d.\n",
 		 dev->name, len, entry);
 	return 0;
 				tp->stats.tx_carrier_errors++;
 			if (txstatus & TxOutOfWindow)
 				tp->stats.tx_window_errors++;
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 if (dev == rtl_ecat_dev.dev)
 {
 rtl_ecat_dev.state = ECAT_DS_ERROR;
 }
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 		} else {
 			if (txstatus & TxUnderrun) {
 				/* Add 64 to the Tx FIFO threshold. */
 	} else {
 		tp->xstats.rx_lost_in_ring++;
 	}
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 if (dev == rtl_ecat_dev.dev)
 {
 rtl_ecat_dev.state = ECAT_DS_ERROR;
 }
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 #ifndef CONFIG_8139_OLD_RX_RESET
 	tmp8 = RTL_R8 (ChipCmd);
 	RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
 			 " cur %4.4x.\n", dev->name, rx_status,
 			 rx_size, cur_rx);
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 #if RTL8139_DEBUG > 2
 if (dev == rtl_ecat_dev.dev)
 		{
 int i;
 DPRINTK("%s: Frame contents ", dev->name);
 for (i = 0; i < 70; i++) EC_DBG(" %2.2x", rx_ring[ring_offset + i]);
 dev->last_rx = jiffies;
 tp->stats.rx_bytes += pkt_size;
 tp->stats.rx_packets++;
 }
 }
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 		cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
 		RTL_W16 (RxBufPtr, cur_rx - 16);
 		EC_DBG (KERN_ERR "%s: PCI Bus error %4.4x.\n",
 			dev->name, pci_cmd_status);
 	}
 }
 /* The interrupt handler does all of the Rx thread work and cleans up
 after the Tx thread. */
 static void rtl8139_interrupt (int irq, void *dev_instance,
 			       struct pt_regs *regs)
 {
 	int boguscnt = max_interrupt_work;
 	void *ioaddr = tp->mmio_addr;
 	int ackstat, status;
 	int link_changed = 0; /* avoid bogus "uninit" warning */
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
 	if (dev == rtl_ecat_dev.dev)
 {
-rt_spin_lock(&tp->lock);
 rtl_ecat_dev.intr_cnt++;
 	}
 	else
 {
-spin_lock (&tp->lock);
+spin_lock(&tp->lock);
 }
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	do {
 		RTL_W16 (IntrStatus, 0xffff);
 	}
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-	if (dev == rtl_ecat_dev.dev)
+	if (dev != rtl_ecat_dev.dev)
 {
-rt_spin_unlock(&tp->lock);
+spin_unlock (&tp->lock);
-}
-	else
-{
-spin_unlock(&tp->lock);
 }
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
 		 dev->name, RTL_R16 (IntrStatus));
 }
-/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-static void rt_rtl8139_interrupt(void)
-{
-rtl8139_interrupt(rtl_ecat_dev.dev->irq, rtl_ecat_dev.dev, NULL);
-}
-/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 static int rtl8139_close (struct net_device *dev)
 {
 	struct rtl8139_private *tp = dev->priv;
 	void *ioaddr = tp->mmio_addr;
 			return ret;
 		}
 		wait_for_completion (&tp->thr_exited);
 	    }
 	}
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	DPRINTK ("%s: Shutting down ethercard, status was 0x%4.4x.\n",
 			dev->name, RTL_R16 (IntrStatus));
-/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
+spin_lock_irqsave(&tp->lock, flags);
-	//mdelay(1);
-if (dev == rtl_ecat_dev.dev)
-{
-flags = rt_spin_lock_irqsave(&tp->lock);
-}
-	else
-{
-spin_lock_irqsave(&tp->lock, flags);
-}
-/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	/* Stop the chip's Tx and Rx DMA processes. */
 	RTL_W8 (ChipCmd, 0);
 	/* Disable interrupts by clearing the interrupt mask. */
 	/* Update the error counts. */
 	tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
 	RTL_W32 (RxMissed, 0);
+spin_unlock_irqrestore (&tp->lock, flags);
+synchronize_irq ();
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-if (dev == rtl_ecat_dev.dev)
-{
-rt_spin_unlock_irqrestore (&tp->lock, flags);
-synchronize_irq ();
-	}
-	else
-{
-spin_unlock_irqrestore (&tp->lock, flags);
-synchronize_irq ();
-	}
-	EC_DBG ("rtl8139: freeing irq");
-	//mdelay(1);
 if (dev != rtl_ecat_dev.dev)
 {
-free_irq (dev->irq, dev);
+free_irq(dev->irq, dev);
-	}
+}
-	else
-{
-rt_disable_irq(dev->irq);
-rt_free_global_irq (dev->irq);
-rt_enable_irq(dev->irq);
-	}
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	rtl8139_tx_clear (tp);
 rc = copy_from_user(&regs, useraddr, sizeof(regs));
 		if (rc) {
 			rc = -EFAULT;
 			goto err_out_gregs;
 		}
 if (regs.len > regs_len)
 regs.len = regs_len;
 if (regs.len < regs_len) {
 			rc = -EINVAL;
 			goto err_out_gregs;
 	EC_DBG("%s: rtl8139 GETSTATS called...",dev->name);
 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
-	if (dev == rtl_ecat_dev.dev)
+	if (dev == rtl_ecat_dev.dev || netif_running(dev))
 {
-flags = rt_spin_lock_irqsave (&tp->lock);
+spin_lock_irqsave (&tp->lock, flags);
 tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
 RTL_W32 (RxMissed, 0);
-rt_spin_unlock_irqrestore (&tp->lock, flags);
+spin_unlock_irqrestore (&tp->lock, flags);
-	}
-	else
-{
-if (netif_running(dev))
-{
-spin_lock_irqsave (&tp->lock, flags);
-tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
-RTL_W32 (RxMissed, 0);
-spin_unlock_irqrestore (&tp->lock, flags);
-}
 	}
 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 	return &tp->stats;
 static void rtl8139_set_rx_mode (struct net_device *dev)
 {
 	unsigned long flags;
 	struct rtl8139_private *tp = dev->priv;
-/* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
+spin_lock_irqsave (&tp->lock, flags);
+__set_rx_mode(dev);
-	if (dev == rtl_ecat_dev.dev)
+spin_unlock_irqrestore (&tp->lock, flags);
-{
-flags = rt_spin_lock_irqsave (&tp->lock);
-__set_rx_mode(dev);
-rt_spin_unlock_irqrestore (&tp->lock, flags);
-	}
-	else
-{
-spin_lock_irqsave (&tp->lock, flags);
-__set_rx_mode(dev);
-spin_unlock_irqrestore (&tp->lock, flags);
-	}
-/* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 }
 #ifdef CONFIG_PM
 static int rtl8139_suspend (struct pci_dev *pdev, u32 state)

changeset 5	6f2508af550c
parent 4	394c89f02e48
child 18	5a42f6d1085c