etherlabmaster: comparison devices/ccat/netdev.c

equal deleted inserted replaced

-:0f39e1e7b288
+:d70aad2f131f
 */
 #include <linux/etherdevice.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
-#include <linux/kfifo.h>
-#include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <linux/spinlock.h>
 #include "compat.h"
 #include "print.h"
 /**
 * EtherCAT frame to enable forwarding on EtherCAT Terminals
 */
-static const UINT8 frameForwardEthernetFrames[] = {
+static const u8 frameForwardEthernetFrames[] = {
 	0x01, 0x01, 0x05, 0x01, 0x00, 0x00,
 	0x00, 0x1b, 0x21, 0x36, 0x1b, 0xce,
 	0x88, 0xa4, 0x0e, 0x10,
 	0x08,
 	0x00,
 	0x00, 0x00,
 	0x00, 0x00
 };
 #define FIFO_LENGTH 64
-#define DMA_POLL_DELAY_RANGE_USECS 100, 100	/* time to sleep between rx/tx DMA polls */
-#define POLL_DELAY_RANGE_USECS 500, 1000	/* time to sleep between link state polls */
 static void ec_poll(struct net_device *dev);
-static int run_poll_thread(void *data);
+static enum hrtimer_restart poll_timer_callback(struct hrtimer *timer);
-static int run_rx_thread(void *data);
-static int run_tx_thread(void *data);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
 static struct rtnl_link_stats64 *ccat_eth_get_stats64(struct net_device *dev, struct rtnl_link_stats64
 						      *storage);
 #endif
 static void ecdev_kfree_skb_any(struct sk_buff *skb)
 {
 	/* never release a skb in EtherCAT mode */
 }
+static bool ecdev_carrier_ok(struct net_device *const netdev)
+{
+	struct ccat_eth_priv *const priv = netdev_priv(netdev);
+	return ecdev_get_link(priv->ecdev);
+}
 static void ecdev_carrier_on(struct net_device *const netdev)
 {
 	struct ccat_eth_priv *const priv = netdev_priv(netdev);
 	ecdev_set_link(priv->ecdev, 1);
 }
 static void ecdev_nop(struct net_device *const netdev)
 {
 	/* dummy called if nothing has to be done in EtherCAT operation mode */
 }
-static void ecdev_tx_fifo_full(struct net_device *const dev,
+static void ecdev_tx_fifo_full(struct ccat_eth_priv *const priv,
 			       const struct ccat_eth_frame *const frame)
 {
 	/* we are polled -> there is nothing we can do in EtherCAT mode */
 }
 static void ccat_eth_rx_fifo_add(struct ccat_eth_frame *frame,
 				 struct ccat_eth_dma_fifo *fifo)
 {
 	const size_t offset = ((void *)(frame) - fifo->dma.virt);
-	const uint32_t addr_and_length = (1 << 31) | offset;
+	const u32 addr_and_length = (1 << 31) | offset;
 	frame->received = 0;
 	iowrite32(addr_and_length, fifo->reg);
 }
 static void ccat_eth_tx_fifo_add_free(struct ccat_eth_frame *frame,
 {
 	/* mark frame as ready to use for tx */
 	frame->sent = 1;
 }
-static void ccat_eth_tx_fifo_full(struct net_device *const dev,
+static void ccat_eth_tx_fifo_full(struct ccat_eth_priv *const priv,
 				  const struct ccat_eth_frame *const frame)
 {
-	struct ccat_eth_priv *const priv = netdev_priv(dev);
+	priv->stop_queue(priv->netdev);
-	netif_stop_queue(dev);
 	priv->next_tx_frame = frame;
-	wake_up_process(priv->tx_thread);
 }
 static void ccat_eth_dma_fifo_reset(struct ccat_eth_dma_fifo *fifo)
 {
 	struct ccat_eth_frame *frame = fifo->dma.virt;
 				  struct ccat_eth_priv *const priv)
 {
 	if (0 !=
 	    ccat_dma_init(&fifo->dma, channel, priv->ccatdev->bar[2].ioaddr,
 			  &priv->ccatdev->pdev->dev)) {
-		pr_info("init DMA%llu memory failed.\n", (uint64_t) channel);
+		pr_info("init DMA%llu memory failed.\n", (u64) channel);
 		return -1;
 	}
 	fifo->add = add;
 	fifo->reg = fifo_reg;
 	return 0;
 	wmb();
 	/* release dma */
 	ccat_dma_free(&priv->rx_fifo.dma);
 	ccat_dma_free(&priv->tx_fifo.dma);
-	pr_debug("DMA fifo's stopped.\n");
 }
 /**
 * Initalizes both (Rx/Tx) DMA fifo's and related management structures
 */
 static void ccat_eth_priv_init_mappings(struct ccat_eth_priv *priv)
 {
 	CCatInfoBlockOffs offsets;
 	void __iomem *const func_base =
 	    priv->ccatdev->bar[0].ioaddr + priv->info.nAddr;
 	memcpy_fromio(&offsets, func_base, sizeof(offsets));
 	priv->reg.mii = func_base + offsets.nMMIOffs;
 	priv->reg.tx_fifo = func_base + offsets.nTxFifoOffs;
 	priv->reg.rx_fifo = func_base + offsets.nTxFifoOffs + 0x10;
 	priv->reg.mac = func_base + offsets.nMacRegOffs;
 static struct rtnl_link_stats64 *ccat_eth_get_stats64(struct net_device *dev, struct rtnl_link_stats64
 						      *storage)
 {
 	struct ccat_eth_priv *const priv = netdev_priv(dev);
 	CCatMacRegs mac;
 	memcpy_fromio(&mac, priv->reg.mac, sizeof(mac));
 	storage->rx_packets = mac.rxFrameCnt;	/* total packets received       */
 	storage->tx_packets = mac.txFrameCnt;	/* total packets transmitted    */
 	storage->rx_bytes = atomic64_read(&priv->rx_bytes);	/* total bytes received         */
 	storage->tx_bytes = atomic64_read(&priv->tx_bytes);	/* total bytes transmitted      */
 struct ccat_eth_priv *ccat_eth_init(const struct ccat_device *const ccatdev,
 				    const void __iomem * const addr)
 {
 	struct ccat_eth_priv *priv;
 	struct net_device *const netdev = alloc_etherdev(sizeof(*priv));
 	priv = netdev_priv(netdev);
 	priv->netdev = netdev;
 	priv->ccatdev = ccatdev;
 	/* ccat register mappings */
 	/* use as EtherCAT device? */
 	priv->ecdev = ecdev_offer(netdev, ec_poll, THIS_MODULE);
 	if (priv->ecdev) {
 		priv->carrier_off = ecdev_carrier_off;
+		priv->carrier_ok = ecdev_carrier_ok;
 		priv->carrier_on = ecdev_carrier_on;
 		priv->kfree_skb_any = ecdev_kfree_skb_any;
 		priv->start_queue = ecdev_nop;
 		priv->stop_queue = ecdev_nop;
 		priv->tx_fifo_full = ecdev_tx_fifo_full;
 		return priv;
 	}
 	/* EtherCAT disabled -> prepare normal ethernet mode */
 	priv->carrier_off = netif_carrier_off;
+	priv->carrier_ok = netif_carrier_ok;
 	priv->carrier_on = netif_carrier_on;
 	priv->kfree_skb_any = dev_kfree_skb_any;
 	priv->start_queue = netif_start_queue;
 	priv->stop_queue = netif_stop_queue;
 	priv->tx_fifo_full = ccat_eth_tx_fifo_full;
 		ccat_eth_priv_free_dma(priv);
 		free_netdev(netdev);
 		return NULL;
 	}
 	pr_info("registered %s as network device.\n", netdev->name);
-	priv->rx_thread = kthread_run(run_rx_thread, netdev, "%s_rx", KBUILD_MODNAME);
-	priv->tx_thread = kthread_run(run_tx_thread, netdev, "%s_tx", KBUILD_MODNAME);
 	return priv;
 }
 void ccat_eth_remove(struct ccat_eth_priv *const priv)
 {
-	if (priv->rx_thread) {
-		kthread_stop(priv->rx_thread);
-	}
-	if (priv->tx_thread) {
-		kthread_stop(priv->tx_thread);
-	}
 	priv->unregister(priv->netdev);
 	ccat_eth_priv_free_dma(priv);
 	free_netdev(priv->netdev);
 	pr_debug("%s(): done\n", __FUNCTION__);
 }
 static int ccat_eth_open(struct net_device *dev)
 {
 	struct ccat_eth_priv *const priv = netdev_priv(dev);
 	priv->carrier_off(dev);
-	priv->poll_thread =
+	hrtimer_init(&priv->poll_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
-	    kthread_run(run_poll_thread, dev, "%s_poll", KBUILD_MODNAME);
+	priv->poll_timer.function = poll_timer_callback;
+	hrtimer_start(&priv->poll_timer, ktime_set(0, 100000),
-	//TODO
+		      HRTIMER_MODE_REL);
 	return 0;
 }
 static const size_t CCATRXDESC_HEADER_LEN = 20;
 static void ccat_eth_receive(struct net_device *const dev,
 			     const struct ccat_eth_frame *const frame)
 {
 	struct ccat_eth_priv *const priv = netdev_priv(dev);
 	const size_t len = frame->length - CCATRXDESC_HEADER_LEN;
 	struct sk_buff *skb = dev_alloc_skb(len + NET_IP_ALIGN);
 	if (!skb) {
 		pr_info("%s() out of memory :-(\n", __FUNCTION__);
 		atomic64_inc(&priv->rx_dropped);
 		return;
 	}
 {
 	static size_t next = 0;
 	struct ccat_eth_priv *const priv = netdev_priv(dev);
 	struct ccat_eth_frame *const frame =
 	    ((struct ccat_eth_frame *)priv->tx_fifo.dma.virt);
-	uint32_t addr_and_length;
+	u32 addr_and_length;
 	if (skb_is_nonlinear(skb)) {
 		pr_warn("Non linear skb not supported -> drop frame.\n");
 		atomic64_inc(&priv->tx_dropped);
 		priv->kfree_skb_any(skb);
 		return NETDEV_TX_OK;
 	}
 	if (skb->len > sizeof(frame->data)) {
 		pr_warn("skb.len %llu exceeds dma buffer %llu -> drop frame.\n",
-			(uint64_t) skb->len, (uint64_t) sizeof(frame->data));
+			(u64) skb->len, (u64) sizeof(frame->data));
 		atomic64_inc(&priv->tx_dropped);
 		priv->kfree_skb_any(skb);
 		return NETDEV_TX_OK;
 	}
 	if (!frame[next].sent) {
 		netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
-		ccat_eth_tx_fifo_full(dev, &frame[next]);
+		ccat_eth_tx_fifo_full(priv, &frame[next]);
 		return NETDEV_TX_BUSY;
 	}
 	/* prepare frame in DMA memory */
 	frame[next].sent = 0;
 	atomic64_add(frame[next].length, &priv->tx_bytes);	/* update stats */
 	next = (next + 1) % FIFO_LENGTH;
 	/* stop queue if tx ring is full */
 	if (!frame[next].sent) {
-		ccat_eth_tx_fifo_full(dev, &frame[next]);
+		ccat_eth_tx_fifo_full(priv, &frame[next]);
 	}
 	return NETDEV_TX_OK;
 }
 static int ccat_eth_stop(struct net_device *dev)
 {
 	struct ccat_eth_priv *const priv = netdev_priv(dev);
 	priv->stop_queue(dev);
-	if (priv->poll_thread) {
+	hrtimer_cancel(&priv->poll_timer);
-		/* TODO care about smp context? */
-		kthread_stop(priv->poll_thread);
-		priv->poll_thread = NULL;
-	}
 	netdev_info(dev, "stopped.\n");
 	return 0;
 }
 static void ccat_eth_link_down(struct net_device *dev)
 {
 	struct ccat_eth_priv *const priv = netdev_priv(dev);
 	priv->stop_queue(dev);
 	priv->carrier_off(dev);
 	netdev_info(dev, "NIC Link is Down\n");
 }
 static void ccat_eth_link_up(struct net_device *const dev)
 {
 	struct ccat_eth_priv *const priv = netdev_priv(dev);
 	netdev_info(dev, "NIC Link is Up\n");
 	/* TODO netdev_info(dev, "NIC Link is Up %u Mbps %s Duplex\n",
 	   speed == SPEED_100 ? 100 : 10,
 	   cmd.duplex == DUPLEX_FULL ? "Full" : "Half"); */
 */
 static void ccat_eth_xmit_raw(struct net_device *dev, const char *const data,
 			      size_t len)
 {
 	struct sk_buff *skb = dev_alloc_skb(len);
 	skb->dev = dev;
 	skb_copy_to_linear_data(skb, data, len);
 	skb_put(skb, len);
 	ccat_eth_start_xmit(skb, dev);
 }
 /**
+* Poll for link state changes
+*/
+static void poll_link(struct ccat_eth_priv *const priv)
+{
+	const size_t link = ccat_eth_priv_read_link_state(priv);
+	if (link != priv->carrier_ok(priv->netdev)) {
+		if (link)
+			ccat_eth_link_up(priv->netdev);
+		else
+			ccat_eth_link_down(priv->netdev);
+	}
+}
+/**
+* Poll for available rx dma descriptors in ethernet operating mode
+*/
+static void poll_rx(struct ccat_eth_priv *const priv)
+{
+	struct ccat_eth_frame *const frame = priv->rx_fifo.dma.virt;
+	static size_t next = 0;
+	/* TODO omit possible deadlock in situations with heavy traffic */
+	while (frame[next].received) {
+		ccat_eth_receive(priv->netdev, frame + next);
+		frame[next].received = 0;
+		ccat_eth_rx_fifo_add(frame + next, &priv->rx_fifo);
+		next = (next + 1) % FIFO_LENGTH;
+	}
+}
+/**
+* Poll for available tx dma descriptors in ethernet operating mode
+*/
+static void poll_tx(struct ccat_eth_priv *const priv)
+{
+	if (priv->next_tx_frame && priv->next_tx_frame->sent) {
+		priv->next_tx_frame = NULL;
+		netif_wake_queue(priv->netdev);
+	}
+}
+/**
 * Since CCAT doesn't support interrupts until now, we have to poll
 * some status bits to recognize things like link change etc.
 */
-static int run_poll_thread(void *data)
+static enum hrtimer_restart poll_timer_callback(struct hrtimer *timer)
 {
-	struct net_device *const dev = (struct net_device *)data;
+	struct ccat_eth_priv *priv = container_of(timer, struct ccat_eth_priv,
-	struct ccat_eth_priv *const priv = netdev_priv(dev);
+						  poll_timer);
-	size_t link = 0;
+	poll_link(priv);
-	while (!kthread_should_stop()) {
+	if(!priv->ecdev)
-		if (ccat_eth_priv_read_link_state(priv) != link) {
+		poll_rx(priv);
-			link = !link;
+	poll_tx(priv);
-			link ? ccat_eth_link_up(dev) : ccat_eth_link_down(dev);
+	hrtimer_forward_now(timer, ktime_set(0, 100 * NSEC_PER_USEC));
-		}
+	return HRTIMER_RESTART;
-		usleep_range(POLL_DELAY_RANGE_USECS);
+}
-	}
-	pr_debug("%s() stopped.\n", __FUNCTION__);
-	return 0;
-}
-static int run_rx_thread(void *data)
-{
-	struct net_device *const dev = (struct net_device *)data;
-	struct ccat_eth_priv *const priv = netdev_priv(dev);
-	struct ccat_eth_frame *frame = priv->rx_fifo.dma.virt;
-	const struct ccat_eth_frame *const end = frame + FIFO_LENGTH;
-	while (!kthread_should_stop()) {
-		/* wait until frame was used by DMA for Rx */
-		while (!kthread_should_stop() && !frame->received) {
-			usleep_range(DMA_POLL_DELAY_RANGE_USECS);
-		}
-		/* can be NULL, if we are asked to stop! */
-		if (frame->received) {
-			ccat_eth_receive(dev, frame);
-			frame->received = 0;
-			ccat_eth_rx_fifo_add(frame, &priv->rx_fifo);
-		}
-		if (++frame >= end) {
-			frame = priv->rx_fifo.dma.virt;
-		}
-	}
-	pr_debug("%s() stopped.\n", __FUNCTION__);
-	return 0;
-}
-/**
-* Polling of tx dma descriptors in ethernet operating mode
-*/
-static int run_tx_thread(void *data)
-{
-	struct net_device *const dev = (struct net_device *)data;
-	struct ccat_eth_priv *const priv = netdev_priv(dev);
-	set_current_state(TASK_INTERRUPTIBLE);
-	while (!kthread_should_stop()) {
-		const struct ccat_eth_frame *const frame = priv->next_tx_frame;
-		if (frame) {
-			while (!kthread_should_stop() && !frame->sent) {
-				usleep_range(DMA_POLL_DELAY_RANGE_USECS);
-			}
-		}
-		netif_wake_queue(dev);
-		schedule();
-		set_current_state(TASK_INTERRUPTIBLE);
-	}
-	set_current_state(TASK_RUNNING);
-	pr_debug("%s() stopped.\n", __FUNCTION__);
-	return 0;
-}

branch	stable-1.5
changeset 2567	d70aad2f131f
parent 2565	f7b06b264646
child 2568	2f3078ec9ffb