text: /* Stellaris Ethernet Controller
   *
   * Copyright (c) 2018 Zilogic Systems
   *
   * SPDX-License-Identifier: Apache-2.0
   */
  
  #define LOG_MODULE_NAME eth_stellaris
  #define LOG_LEVEL CONFIG_ETHERNET_LOG_LEVEL
  #include <logging/log.h>
  LOG_MODULE_REGISTER(LOG_MODULE_NAME);
  
  #include <net/ethernet.h>
  #include <net/net_pkt.h>
  #include <net/net_if.h>
  #include <device.h>
  #include <soc.h>
  #include <ethernet/eth_stats.h>
  #include "eth_stellaris_priv.h"
  
  static void eth_stellaris_assign_mac(struct device *dev)
  {
  	u32_t value = 0x0;
  
  	value |= DT_ETH_MAC_ADDR_0;
  	value |= DT_ETH_MAC_ADDR_1 << 8;
  	value |= DT_ETH_MAC_ADDR_2 << 16;
  	value |= DT_ETH_MAC_ADDR_3 << 24;
  	sys_write32(value, REG_MACIA0);
  
  	value = 0x0;
  	value |= DT_ETH_MAC_ADDR_4;
  	value |= DT_ETH_MAC_ADDR_5 << 8;
  	sys_write32(value, REG_MACIA1);
  }
  
  static void eth_stellaris_flush(struct device *dev)
  {
  	struct eth_stellaris_runtime *dev_data = DEV_DATA(dev);
  
  	if (dev_data->tx_pos != 0) {
  		sys_write32(dev_data->tx_word, REG_MACDATA);
  		dev_data->tx_pos = 0;
  		dev_data->tx_word = 0;
  	}
  }
  
  static void eth_stellaris_send_byte(struct device *dev, u8_t byte)
  {
  	struct eth_stellaris_runtime *dev_data = DEV_DATA(dev);
  
  	dev_data->tx_word |= byte << (dev_data->tx_pos * 8);
  	dev_data->tx_pos++;
  	if (dev_data->tx_pos == 4) {
  		sys_write32(dev_data->tx_word, REG_MACDATA);
  		dev_data->tx_pos = 0;
  		dev_data->tx_word = 0;
  	}
  }
  
  static int eth_stellaris_send(struct device *dev, struct net_pkt *pkt)
  {
  	struct eth_stellaris_runtime *dev_data = DEV_DATA(dev);
  	struct net_buf *frag;
  	u16_t head_len_left, i, data_len;
  	u8_t *eth_hdr;
  
  	if (!pkt->frags) {
  		LOG_ERR("No data to send");
  		net_pkt_unref(pkt);
  		return -ENODATA;
  	}
  
  	/* Frame transmission
  	 * First two bytes are data_len for frame,
  	 * Initially send the data_len
  	 */
  	data_len = net_pkt_get_len(pkt);
  	eth_stellaris_send_byte(dev, data_len & 0xff);
  	eth_stellaris_send_byte(dev, (data_len & 0xff00) >> 8);
  
  	/* Send the header, header is 14 bytes */
  	head_len_left = net_pkt_ll_reserve(pkt);
  	eth_hdr = net_pkt_ll(pkt);
  	for (i = 0; i < head_len_left; ++i) {
  		eth_stellaris_send_byte(dev, eth_hdr[i]);
  	}
  
  	/* Send the payload */
  	for (frag = pkt->frags; frag; frag = frag->frags) {
  		for (i = 0; i < frag->len; ++i) {
  			eth_stellaris_send_byte(dev, frag->data[i]);
  		}
  	}
  
  	/* Will transmit the partial word. */
  	eth_stellaris_flush(dev);
  
  	/* Enable transmit. */
  	sys_write32(BIT_MACTR_NEWTX, REG_MACTR);
  
  	/* Wait and check if transmit successful or not. */
  	k_sem_take(&dev_data->tx_sem, K_FOREVER);
  
  	if (dev_data->tx_err) {
  		dev_data->tx_err = false;
  		net_pkt_unref(pkt);
  		return -EIO;
  	}
  
  	if (IS_ENABLED(CONFIG_NET_STATISTICS_ETHERNET)) {
  		struct net_eth_hdr *pkt_hdr;
  
  		/* Update statistics counters */
  		eth_stats_update_bytes_tx(net_pkt_iface(pkt),
  					  data_len);
  		eth_stats_update_pkts_tx(net_pkt_iface(pkt));
  		pkt_hdr = NET_ETH_HDR(pkt);
  		if (net_eth_is_addr_multicast(&pkt_hdr->dst)) {
  			eth_stats_update_multicast_tx(net_pkt_iface(pkt));
  		} else if (net_eth_is_addr_broadcast(&pkt_hdr->dst)) {
  			eth_stats_update_broadcast_tx(net_pkt_iface(pkt));
  		}
  	}
  
  	LOG_DBG("pkt send %p len %d", pkt, net_pkt_get_len(pkt));
  	net_pkt_unref(pkt);
  
  	return 0;
  }
  
  static void eth_stellaris_rx_error(struct net_if *iface)
  {
  	struct device *dev = net_if_get_device(iface);
  	u32_t val;
  
  	eth_stats_update_errors_rx(iface);
  
  	/* Clear the rx_frame buffer,
  	 * otherwise it could lead to underflow errors
  	 */
  	sys_write32(0x0, REG_MACRCTL);
  	sys_write32(BIT_MACRCTL_RSTFIFO, REG_MACRCTL);
  	val = BIT_MACRCTL_BADCRC | BIT_MACRCTL_RXEN;
  	sys_write32(val, REG_MACRCTL);
  }
  
  static int eth_stellaris_rx_pkt(struct device *dev, struct net_pkt *pkt)
  {
  	u32_t reg_val;
  	int frame_len, bytes_left;
  	u16_t count;
  	u8_t *data;
  
  	/*
  	 * The Ethernet frame received from the hardware has the
  	 * following format. The first two bytes contains the ethernet
  	 * frame length, followed by the actual ethernet frame.
  	 *
  	 * +---------+---- ... -------+
  	 * | Length  | Ethernet Frame |
  	 * +---------+---- ... -------+
  	 */
  
  	/*
  	 * The first word contains the frame length and a portion of
  	 * the ethernet frame. Extract the frame length.
  	 */
  	reg_val = sys_read32(REG_MACDATA);
  	frame_len = reg_val & 0x0000ffff;
  
  	/*
  	 * The remaining 2 bytes, in the first word is appended to the
  	 * ethernet frame.
  	 */
  	count = 2;
  	data = (u8_t *)&reg_val + 2;
  	if (net_pkt_append(pkt, count, data, K_NO_WAIT) != count) {
  		return -1;
  	}
  
  	/* A word has been read already, thus minus 4 bytes to be read. */
  	bytes_left = frame_len - 4;
  
  	/* Read the rest of words, minus the partial word and FCS byte. */
  	for (; bytes_left > 7; bytes_left -= 4) {
  		reg_val = sys_read32(REG_MACDATA);
  		count = 4;
  		data = (u8_t *)&reg_val;
  		if (net_pkt_append(pkt, count, data, K_NO_WAIT) != count) {
  			return -1;
  		}
  	}
  
  	/* Handle the last partial word and discard the 4 Byte FCS. */
  	while (bytes_left > 0) {
  		/* Read the partial word. */
  		reg_val = sys_read32(REG_MACDATA);
  
  		/* Discard the last FCS word. */
  		if (bytes_left <= 4) {
  			bytes_left = 0;
  			break;
  		}
  
  		count = bytes_left - 4;
  		data = (u8_t *)&reg_val;
  		if (net_pkt_append(pkt, count, data, K_NO_WAIT) != count) {
  			return -1;
  		}
  
  		bytes_left -= 4;
  	}
  
  	return frame_len;
  }
  
  static void eth_stellaris_rx(struct device *dev)
  {
  	struct net_pkt *pkt = NULL;
  	struct eth_stellaris_runtime *dev_data = DEV_DATA(dev);
  	struct net_if *iface = dev_data->iface;
  	int frame_len, ret;
  
  	/* Obtain the packet to be populated. */
  	pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
  	if (!pkt) {
  		LOG_ERR("Could not allocate pkt");
  		goto err_mem;
  	}
  
  	frame_len = eth_stellaris_rx_pkt(dev, pkt);
  	if (frame_len < 0) {
  		LOG_ERR("Failed to append data to buffer");
  		goto pkt_unref;
  	}
  
  	ret = net_recv_data(iface, pkt);
  	if (ret < 0) {
  		LOG_ERR("Failed to place frame in RX Queue");
  		goto pkt_unref;
  	}
  
  	if (IS_ENABLED(CONFIG_NET_STATISTICS_ETHERNET)) {
  		struct net_eth_hdr *pkt_hdr;
  
  		/* Update statistics counters */
  		eth_stats_update_bytes_rx(iface, frame_len - 6);
  		eth_stats_update_pkts_rx(iface);
  		pkt_hdr = NET_ETH_HDR(pkt);
  		if (net_eth_is_addr_broadcast(&pkt_hdr->dst)) {
  			eth_stats_update_broadcast_rx(iface);
  		} else if (net_eth_is_addr_multicast(&pkt_hdr->dst)) {
  			eth_stats_update_multicast_rx(iface);
  		}
  	}
  
  	return;
  
  pkt_unref:
  	net_pkt_unref(pkt);
  
  err_mem:
  	eth_stellaris_rx_error(iface);
  }
  
  static void eth_stellaris_isr(void *arg)
  {
  	/* Read the interrupt status */
  	struct device *dev = (struct device *)arg;
  	struct eth_stellaris_runtime *dev_data = DEV_DATA(dev);
  	int isr_val = sys_read32(REG_MACRIS);
  	u32_t lock;
  
  	lock = irq_lock();
  
  	/* Acknowledge the interrupt. */
  	sys_write32(isr_val, REG_MACRIS);
  
  	if (isr_val & BIT_MACRIS_RXINT) {
  		eth_stellaris_rx(dev);
  	}
  
  	if (isr_val & BIT_MACRIS_TXEMP) {
  		dev_data->tx_err = false;
  		k_sem_give(&dev_data->tx_sem);
  	}
  
  	if (isr_val & BIT_MACRIS_TXER) {
  		LOG_ERR("Transmit Frame Error");
  		eth_stats_update_errors_tx(dev_data->iface);
  		dev_data->tx_err = true;
  		k_sem_give(&dev_data->tx_sem);
  	}
  
  	if (isr_val & BIT_MACRIS_RXER) {
  		LOG_ERR("Error Receiving Frame");
  		eth_stellaris_rx_error(dev_data->iface);
  	}
  
  	if (isr_val & BIT_MACRIS_FOV) {
  		LOG_ERR("Error Rx Overrun");
  		eth_stellaris_rx_error(dev_data->iface);
  	}
  
  	irq_unlock(lock);
  }
  
  static void eth_stellaris_init(struct net_if *iface)
  {
  	struct device *dev = net_if_get_device(iface);
  	struct eth_stellaris_config *dev_conf = DEV_CFG(dev);
  	struct eth_stellaris_runtime *dev_data = DEV_DATA(dev);
  
  	dev_data->iface = iface;
  
  	/* Assign link local address. */
  	net_if_set_link_addr(iface,
  			     dev_data->mac_addr, 6, NET_LINK_ETHERNET);
  
  	ethernet_init(iface);
  
  	/* Initialize semaphore. */
  	k_sem_init(&dev_data->tx_sem, 0, 1);
  
  	/* Initialize Interrupts. */
  	dev_conf->config_func(dev);
  }
  
  static struct net_stats_eth *eth_stellaris_stats(struct device *dev)
  {
  	return &(DEV_DATA(dev)->stats);
  }
  
  static int eth_stellaris_dev_init(struct device *dev)
  {
  	u32_t value;
  
  	/* Assign MAC address to Hardware */
  	eth_stellaris_assign_mac(dev);
  
  	/* Program MCRCTL to clear RXFIFO */
  	value = BIT_MACRCTL_RSTFIFO;
  	sys_write32(value, REG_MACRCTL);
  
  	/* Enable transmitter */
  	value = BIT_MACTCTL_DUPLEX | BIT_MACTCTL_CRC |
  		BIT_MACTCTL_PADEN | BIT_MACTCTL_TXEN;
  	sys_write32(value, REG_MACTCTL);
  
  	/* Enable Receiver */
  	value = BIT_MACRCTL_BADCRC | BIT_MACRCTL_RXEN;
  	sys_write32(value, REG_MACRCTL);
  
  	return 0;
  }
  
  static struct device DEVICE_NAME_GET(eth_stellaris);
  
  static void eth_stellaris_irq_config(struct device *dev)
  {
  	/* Enable Interrupt. */
  	IRQ_CONNECT(DT_ETH_IRQ,
  		    DT_ETH_IRQ_PRIO,
  		    eth_stellaris_isr, DEVICE_GET(eth_stellaris), 0);
  	irq_enable(DT_ETH_IRQ);
  }
  
  struct eth_stellaris_config eth_cfg = {
  	.mac_base = DT_ETH_BASE_ADDR,
  	.config_func = eth_stellaris_irq_config,
  };
  
  struct eth_stellaris_runtime eth_data = {
  	.mac_addr = {
  		(u8_t)DT_ETH_MAC_ADDR_0,
  		(u8_t)DT_ETH_MAC_ADDR_1,
  		(u8_t)DT_ETH_MAC_ADDR_2,
  		(u8_t)DT_ETH_MAC_ADDR_3,
  		(u8_t)DT_ETH_MAC_ADDR_4,
  		(u8_t)DT_ETH_MAC_ADDR_5
  	},
  	.tx_err = false,
  	.tx_word = 0,
  	.tx_pos = 0,
  };
  
  static const struct ethernet_api eth_stellaris_apis = {
  	.iface_api.init	= eth_stellaris_init,
  	.get_stats = eth_stellaris_stats,
  	.send =  eth_stellaris_send,
  };
  
  NET_DEVICE_INIT(eth_stellaris, DT_ETH_DRV_NAME,
  		eth_stellaris_dev_init, &eth_data, &eth_cfg,
  		CONFIG_ETH_INIT_PRIORITY,
  		&eth_stellaris_apis, ETHERNET_L2,
  		NET_L2_GET_CTX_TYPE(ETHERNET_L2), ETH_MTU);
  