| /* | |
| * Copyright 2020, Data61, CSIRO (ABN 41 687 119 230) | |
| * | |
| * SPDX-License-Identifier: GPL-2.0-only | |
| */ | |
| #include <errno.h> | |
| #include <string.h> | |
| #include <assert.h> | |
| #include <platsupport/driver_module.h> | |
| #include <platsupport/fdt.h> | |
| #include <ethdrivers/gen_config.h> | |
| #include <ethdrivers/odroidc2.h> | |
| #include <ethdrivers/raw.h> | |
| #include <ethdrivers/helpers.h> | |
| #include <utils/util.h> | |
| #include "uboot/common.h" | |
| #include "uboot/net.h" | |
| #include "uboot/miiphy.h" | |
| #include "io.h" | |
| #include "uboot/netdev.h" | |
| #include "unimplemented.h" | |
| #include "uboot/designware.h" | |
| #define BUF_SIZE 2048 | |
| #define MAC_LEN 6 | |
| #define DMA_ALIGN 64 | |
| struct descriptor { | |
| uint32_t txrx_status; | |
| uint32_t dmamac_cntl; | |
| uint32_t dmamac_addr; | |
| uint32_t dmamac_next; | |
| }; | |
| struct odroidc2_eth_data { | |
| struct eth_device *eth_dev; | |
| uint8_t mac[MAC_LEN]; | |
| uintptr_t tx_ring_phys; | |
| uintptr_t rx_ring_phys; | |
| volatile struct descriptor *tx_ring; | |
| volatile struct descriptor *rx_ring; | |
| unsigned int rx_size; | |
| unsigned int tx_size; | |
| void **rx_cookies; /* Array of rx_size elements of type 'void *' */ | |
| void **tx_cookies; /* Array of tx_size elements of type 'void *' */ | |
| unsigned int rx_remain; | |
| unsigned int tx_remain; | |
| unsigned int *tx_lengths; | |
| /* Indexes used to keep track of the head and tail of the descriptor queues */ | |
| unsigned int rdt, rdh, tdt, tdh; | |
| }; | |
| static bool enabled = false; | |
| static void low_level_init(struct eth_driver *driver, uint8_t *mac, int *mtu) | |
| { | |
| struct odroidc2_eth_data *dev = (struct odroidc2_eth_data *)driver->eth_data; | |
| memcpy(mac, dev->mac, MAC_LEN); | |
| *mtu = MAX_PKT_SIZE; | |
| } | |
| static void fill_rx_bufs(struct eth_driver *driver) | |
| { | |
| struct odroidc2_eth_data *dev = (struct odroidc2_eth_data *)driver->eth_data; | |
| __sync_synchronize(); | |
| while (dev->rx_remain > 0) { | |
| /* request a buffer */ | |
| void *cookie = NULL; | |
| int next_rdt = (dev->rdt + 1) % dev->rx_size; | |
| // This fn ptr is either lwip_allocate_rx_buf or lwip_pbuf_allocate_rx_buf (in src/lwip.c) | |
| uintptr_t phys = driver->i_cb.allocate_rx_buf ? driver->i_cb.allocate_rx_buf(driver->cb_cookie, BUF_SIZE, &cookie) : 0; | |
| if (!phys) { | |
| // NOTE: This condition could happen if | |
| // CONFIG_LIB_ETHDRIVER_NUM_PREALLOCATED_BUFFERS < CONFIG_LIB_ETHDRIVER_RX_DESC_COUNT | |
| break; | |
| } | |
| dev->rx_cookies[dev->rdt] = cookie; | |
| dev->rx_ring[dev->rdt].dmamac_addr = phys; | |
| dev->rx_ring[dev->rdt].dmamac_cntl = (MAC_MAX_FRAME_SZ & DESC_RXCTRL_SIZE1MASK) | DESC_RXCTRL_RXCHAIN; | |
| dev->rx_ring[dev->rdt].txrx_status = DESC_RXSTS_OWNBYDMA; | |
| __sync_synchronize(); | |
| dev->rdt = next_rdt; | |
| dev->rx_remain--; | |
| } | |
| __sync_synchronize(); | |
| /* NOTE Maybe check if receiving isn't enabled? */ | |
| if (enabled) { | |
| designware_start_receive(dev->eth_dev); | |
| } | |
| } | |
| static void free_desc_ring(struct odroidc2_eth_data *dev, ps_dma_man_t *dma_man) | |
| { | |
| if (dev->rx_ring) { | |
| dma_unpin_free(dma_man, (void *)dev->rx_ring, sizeof(struct descriptor) * dev->rx_size); | |
| dev->rx_ring = NULL; | |
| } | |
| if (dev->tx_ring) { | |
| dma_unpin_free(dma_man, (void *)dev->tx_ring, sizeof(struct descriptor) * dev->tx_size); | |
| dev->tx_ring = NULL; | |
| } | |
| if (dev->rx_cookies) { | |
| free(dev->rx_cookies); | |
| dev->rx_cookies = NULL; | |
| } | |
| if (dev->tx_cookies) { | |
| free(dev->tx_cookies); | |
| dev->tx_cookies = NULL; | |
| } | |
| if (dev->tx_lengths) { | |
| free(dev->tx_lengths); | |
| dev->tx_lengths = NULL; | |
| } | |
| } | |
| static int initialize_desc_ring(struct odroidc2_eth_data *dev, ps_dma_man_t *dma_man) | |
| { | |
| dma_addr_t rx_ring = dma_alloc_pin(dma_man, sizeof(struct descriptor) * dev->rx_size, 0, DMA_ALIGN); | |
| if (!rx_ring.phys) { | |
| LOG_ERROR("Failed to allocate rx_ring"); | |
| return -1; | |
| } | |
| dev->rx_ring = rx_ring.virt; | |
| dev->rx_ring_phys = rx_ring.phys; | |
| dma_addr_t tx_ring = dma_alloc_pin(dma_man, sizeof(struct descriptor) * dev->tx_size, 0, DMA_ALIGN); | |
| if (!tx_ring.phys) { | |
| LOG_ERROR("Failed to allocate tx_ring"); | |
| free_desc_ring(dev, dma_man); | |
| return -1; | |
| } | |
| ps_dma_cache_clean_invalidate(dma_man, rx_ring.virt, sizeof(struct descriptor) * dev->rx_size); | |
| ps_dma_cache_clean_invalidate(dma_man, tx_ring.virt, sizeof(struct descriptor) * dev->tx_size); | |
| dev->rx_cookies = malloc(sizeof(void *) * dev->rx_size); | |
| dev->tx_cookies = malloc(sizeof(void *) * dev->tx_size); | |
| dev->tx_lengths = malloc(sizeof(unsigned int) * dev->tx_size); | |
| if (!dev->rx_cookies || !dev->tx_cookies || !dev->tx_lengths) { | |
| if (dev->rx_cookies) { | |
| free(dev->rx_cookies); | |
| } | |
| if (dev->tx_cookies) { | |
| free(dev->tx_cookies); | |
| } | |
| if (dev->tx_lengths) { | |
| free(dev->tx_lengths); | |
| } | |
| LOG_ERROR("Failed to malloc"); | |
| free_desc_ring(dev, dma_man); | |
| return -1; | |
| } | |
| dev->tx_ring = tx_ring.virt; | |
| dev->tx_ring_phys = tx_ring.phys; | |
| /* Remaining needs to be 2 less than size as we cannot actually enqueue size many descriptors, | |
| * since then the head and tail pointers would be equal, indicating empty. */ | |
| dev->rx_remain = dev->rx_size - 2; | |
| dev->tx_remain = dev->tx_size - 2; | |
| dev->rdt = dev->rdh = dev->tdt = dev->tdh = 0; | |
| uintptr_t next_phys = dev->tx_ring_phys; | |
| for (unsigned int i = 0; i < dev->tx_size; i++) { | |
| next_phys += sizeof(struct descriptor); | |
| dev->tx_ring[i].dmamac_addr = 0; | |
| if (i == (dev->tx_size - 1)) { | |
| dev->tx_ring[i].dmamac_next = (uint32_t)(dev->tx_ring_phys & 0xFFFFFFFF); | |
| } else { | |
| dev->tx_ring[i].dmamac_next = (uint32_t)(next_phys & 0xFFFFFFFF); | |
| } | |
| dev->tx_ring[i].dmamac_cntl = DESC_TXCTRL_TXCHAIN; | |
| dev->tx_ring[i].txrx_status = 0; | |
| } | |
| next_phys = dev->rx_ring_phys; | |
| for (unsigned int i = 0; i < dev->rx_size; i++) { | |
| next_phys += sizeof(struct descriptor); | |
| dev->rx_ring[i].dmamac_addr = 0; | |
| if (i == (dev->rx_size - 1)) { | |
| dev->rx_ring[i].dmamac_next = (uint32_t)(dev->rx_ring_phys & 0xFFFFFFFF); | |
| } else { | |
| dev->rx_ring[i].dmamac_next = (uint32_t)(next_phys & 0xFFFFFFFF); | |
| } | |
| dev->rx_ring[i].dmamac_cntl = (MAC_MAX_FRAME_SZ & DESC_RXCTRL_SIZE1MASK) | DESC_RXCTRL_RXCHAIN; | |
| dev->rx_ring[i].txrx_status = 0; | |
| } | |
| __sync_synchronize(); | |
| return 0; | |
| } | |
| static void complete_rx(struct eth_driver *eth_driver) | |
| { | |
| struct odroidc2_eth_data *dev = (struct odroidc2_eth_data *)eth_driver->eth_data; | |
| unsigned int rdt = dev->rdt; | |
| while (dev->rdh != rdt) { | |
| unsigned int status = dev->rx_ring[dev->rdh].txrx_status; | |
| /* Ensure no memory references get ordered before we checked the descriptor was written back */ | |
| __sync_synchronize(); | |
| if (status & DESC_RXSTS_OWNBYDMA) { | |
| /* not complete yet */ | |
| break; | |
| } | |
| void *cookie = dev->rx_cookies[dev->rdh]; | |
| unsigned int len = (status & DESC_RXSTS_FRMLENMSK) >> DESC_RXSTS_FRMLENSHFT; | |
| /* update rdh */ | |
| dev->rdh = (dev->rdh + 1) % dev->rx_size; | |
| dev->rx_remain++; | |
| /* Give the buffers back */ | |
| eth_driver->i_cb.rx_complete(eth_driver->cb_cookie, 1, &cookie, &len); | |
| } | |
| /* NOTE Maybe re-enable the Ethernet device for RX if there are still descriptors? */ | |
| } | |
| static void complete_tx(struct eth_driver *driver) | |
| { | |
| struct odroidc2_eth_data *dev = (struct odroidc2_eth_data *)driver->eth_data; | |
| while (dev->tdh != dev->tdt) { | |
| unsigned int i; | |
| for (i = 0; i < dev->tx_lengths[dev->tdh]; i++) { | |
| if (dev->tx_ring[dev->tdh + i].txrx_status & DESC_TXSTS_OWNBYDMA) { | |
| /* Not yet complete */ | |
| return; | |
| } | |
| } | |
| /* do not let memory loads happen before our checking of the descriptor write back */ | |
| __sync_synchronize(); | |
| /* increase where we believe tdh to be */ | |
| void *cookie = dev->tx_cookies[dev->tdh]; | |
| dev->tx_remain += dev->tx_lengths[dev->tdh]; | |
| dev->tdh = (dev->tdh + dev->tx_lengths[dev->tdh]) % dev->tx_size; | |
| /* give the buffer back */ | |
| driver->i_cb.tx_complete(driver->cb_cookie, cookie); | |
| } | |
| /* NOTE Maybe re-enable the Ethernet device for TX if there are still descriptors? */ | |
| } | |
| static void print_state(struct eth_driver *eth_driver) | |
| { | |
| ZF_LOGE("Not implemented"); | |
| } | |
| static void handle_irq(struct eth_driver *driver, int irq) | |
| { | |
| struct odroidc2_eth_data *eth_data = (struct odroidc2_eth_data *)driver->eth_data; | |
| uint32_t status = 0; | |
| designware_interrupt_status(eth_data->eth_dev, &status); | |
| designware_ack(eth_data->eth_dev, status); | |
| if (status & DMA_INTR_ENA_TIE) { | |
| complete_tx(driver); | |
| } | |
| if (status & DMA_INTR_ENA_RIE) { | |
| complete_rx(driver); | |
| fill_rx_bufs(driver); | |
| } | |
| if (status & DMA_INTR_ABNORMAL) { | |
| ZF_LOGE("Ethernet device crashed with an abnormal interrupt, reporting..."); | |
| if (status & DMA_INTR_ENA_FBE) { | |
| ZF_LOGE(" Ethernet device fatal bus error"); | |
| } | |
| if (status & DMA_INTR_ENA_UNE) { | |
| ZF_LOGE(" Ethernet device TX underflow"); | |
| } | |
| ZF_LOGF("Done."); | |
| } | |
| } | |
| /* This is a platsuport IRQ interface IRQ handler wrapper for handle_irq() */ | |
| static void eth_irq_handle(void *data, ps_irq_acknowledge_fn_t acknowledge_fn, void *ack_data) | |
| { | |
| ZF_LOGF_IF(data == NULL, "Passed in NULL for the data"); | |
| struct eth_driver *driver = data; | |
| /* handle_irq doesn't really expect an IRQ number */ | |
| handle_irq(driver, 0); | |
| int error = acknowledge_fn(ack_data); | |
| if (error) { | |
| LOG_ERROR("Failed to acknowledge the Ethernet device's IRQ"); | |
| } | |
| } | |
| static void raw_poll(struct eth_driver *driver) | |
| { | |
| complete_rx(driver); | |
| complete_tx(driver); | |
| fill_rx_bufs(driver); | |
| } | |
| static int raw_tx(struct eth_driver *driver, unsigned int num, uintptr_t *phys, unsigned int *len, void *cookie) | |
| { | |
| struct odroidc2_eth_data *dev = (struct odroidc2_eth_data *)driver->eth_data; | |
| /* Ensure we have room */ | |
| if (dev->tx_remain < num) { | |
| /* try and complete some */ | |
| complete_tx(driver); | |
| if (dev->tx_remain < num) { | |
| return ETHIF_TX_FAILED; | |
| } | |
| } | |
| unsigned int i; | |
| __sync_synchronize(); | |
| for (i = 0; i < num; i++) { | |
| unsigned int ring = (dev->tdt + i) % dev->tx_size; | |
| dev->tx_ring[ring].dmamac_addr = phys[i]; | |
| dev->tx_ring[ring].dmamac_cntl = DESC_TXCTRL_TXCHAIN; | |
| dev->tx_ring[ring].dmamac_cntl |= (len[i] << DESC_TXCTRL_SIZE1SHFT) & DESC_TXCTRL_SIZE1MASK; | |
| if (i == 0) { | |
| dev->tx_ring[ring].dmamac_cntl |= DESC_TXCTRL_TXFIRST; | |
| } | |
| if (i == (num - 1)) { | |
| dev->tx_ring[ring].dmamac_cntl |= DESC_TXCTRL_TXLAST; | |
| } | |
| dev->tx_ring[ring].dmamac_cntl |= DESC_TXCTRL_TXINT; | |
| dev->tx_ring[ring].txrx_status = DESC_TXSTS_OWNBYDMA; | |
| } | |
| dev->tx_cookies[dev->tdt] = cookie; | |
| dev->tx_lengths[dev->tdt] = num; | |
| dev->tdt = (dev->tdt + num) % dev->tx_size; | |
| dev->tx_remain -= num; | |
| __sync_synchronize(); | |
| /* NOTE Maybe check if it's in the middle of sending? */ | |
| designware_start_send(dev->eth_dev); | |
| return ETHIF_TX_ENQUEUED; | |
| } | |
| static void get_mac(struct eth_driver *driver, uint8_t *mac) | |
| { | |
| struct odroidc2_eth_data *eth_data = (struct odroidc2_eth_data *) driver->eth_data; | |
| memcpy(mac, eth_data->mac, MAC_LEN); | |
| } | |
| static struct raw_iface_funcs iface_fns = { | |
| .raw_handleIRQ = handle_irq, | |
| .print_state = print_state, | |
| .low_level_init = low_level_init, | |
| .raw_tx = raw_tx, | |
| .raw_poll = raw_poll, | |
| .get_mac = get_mac | |
| }; | |
| int ethif_odroidc2_init(struct eth_driver *eth_driver, ps_io_ops_t io_ops, void *config) | |
| { | |
| int err; | |
| struct odroidc2_eth_data *eth_data = NULL; | |
| struct eth_device *eth_dev; | |
| if (config == NULL) { | |
| ZF_LOGE("Cannot get platform info; passed in config pointer NULL"); | |
| goto error; | |
| } | |
| struct arm_eth_plat_config *plat_config = (struct arm_eth_plat_config *)config; | |
| unsigned long base_addr = (unsigned long)((uintptr_t) plat_config->buffer_addr); | |
| eth_data = (struct odroidc2_eth_data *)malloc(sizeof(struct odroidc2_eth_data)); | |
| if (eth_data == NULL) { | |
| ZF_LOGE("Failed to allocate eth data struct"); | |
| goto error; | |
| } | |
| eth_data->tx_size = CONFIG_LIB_ETHDRIVER_TX_DESC_COUNT; | |
| eth_data->rx_size = CONFIG_LIB_ETHDRIVER_RX_DESC_COUNT; | |
| eth_driver->eth_data = eth_data; | |
| eth_driver->dma_alignment = DMA_ALIGN; | |
| eth_driver->i_fn = iface_fns; | |
| err = initialize_desc_ring(eth_data, &io_ops.dma_manager); | |
| if (err) { | |
| LOG_ERROR("Failed to allocate descriptor rings"); | |
| goto error; | |
| } | |
| /* Initialise the MII abstraction layer */ | |
| miiphy_init(); | |
| /* Initialise the actual Realtek PHY */ | |
| phy_init(); | |
| /* Do some more PHY init, setup structures */ | |
| eth_dev = malloc(sizeof(*eth_dev)); | |
| if (NULL == eth_dev) { | |
| ZF_LOGE("Failed to allocate eth_dev structure"); | |
| goto error; | |
| } | |
| int ret = designware_initialize(base_addr, 0, eth_dev); | |
| if (ret != 0) { | |
| ZF_LOGE("Failed: designware_initialize."); | |
| goto error; | |
| } | |
| eth_data->eth_dev = eth_dev; | |
| /* We must read the MAC address out of the device after the register | |
| * addresses have been initialized (designware_initialize), but before | |
| * initializing the hardware (uboot_eth_dev.init), because initializing | |
| * the hardware involves a soft reset which will wipe the MAC address | |
| * which was configured by u-boot */ | |
| ret = designware_read_hwaddr(eth_dev, eth_data->mac); | |
| if (ret != 0) { | |
| ZF_LOGE("Failed: designware_read_hwaddr."); | |
| goto error; | |
| } | |
| /* NOTE: This line determines what our MAC address will be, it is | |
| * internally programmed into the device during the next init step*/ | |
| memcpy(eth_dev->enetaddr, eth_data->mac, 6); | |
| /* Bring up the interface */ | |
| ret = designware_startup(eth_dev); | |
| if (ret != 0) { | |
| ZF_LOGE("Failed: designware_startup"); | |
| goto error; | |
| } | |
| ret = designware_write_descriptors(eth_dev, eth_data->tx_ring_phys, eth_data->rx_ring_phys); | |
| if (ret != 0) { | |
| ZF_LOGE("Failed: designware_write_descriptors"); | |
| goto error; | |
| } | |
| fill_rx_bufs(eth_driver); | |
| enabled = true; | |
| /* Last step, enable it */ | |
| ret = designware_enable(eth_dev); | |
| if (ret != 0) { | |
| ZF_LOGE("Failed: designware_enable"); | |
| } | |
| return 0; | |
| error: | |
| if (eth_data) { | |
| free(eth_data); | |
| } | |
| if (eth_dev) { | |
| free(eth_dev); | |
| } | |
| free_desc_ring(eth_data, &io_ops.dma_manager); | |
| return -1; | |
| } | |
| int ethif_odroidc2_init_module(ps_io_ops_t *io_ops, const char *device_path) | |
| { | |
| struct arm_eth_plat_config plat_config; | |
| struct eth_driver *eth_driver; | |
| int error = ps_calloc(&io_ops->malloc_ops, 1, sizeof(*eth_driver), (void **) ð_driver); | |
| if (error) { | |
| ZF_LOGE("Failed to allocate memory for the Ethernet driver"); | |
| return -ENOMEM; | |
| } | |
| ps_fdt_cookie_t *cookie = NULL; | |
| error = ps_fdt_read_path(&io_ops->io_fdt, &io_ops->malloc_ops, device_path, &cookie); | |
| if (error) { | |
| ZF_LOGE("Failed to read the path of the Ethernet driver"); | |
| return -ENODEV; | |
| } | |
| void *mapped_addr = ps_fdt_index_map_register(io_ops, cookie, 0, NULL); | |
| if (mapped_addr == NULL) { | |
| ZF_LOGE("Failed to map the registers"); | |
| return -ENODEV; | |
| } | |
| irq_id_t eth_irq_id = ps_fdt_index_register_irq(io_ops, cookie, 0, eth_irq_handle, eth_driver); | |
| if (eth_irq_id < 0) { | |
| ZF_LOGE("Failed to register the Ethernet's IRQ"); | |
| return -ENODEV; | |
| } | |
| plat_config.buffer_addr = mapped_addr; | |
| plat_config.prom_mode = 1; | |
| error = ethif_odroidc2_init(eth_driver, *io_ops, &plat_config); | |
| if (error) { | |
| ZF_LOGE("Failed to initialise the Ethernet driver"); | |
| return -ENODEV; | |
| } | |
| return ps_interface_register(&io_ops->interface_registration_ops, PS_ETHERNET_INTERFACE, eth_driver, NULL); | |
| } | |
| static const char *compatible_strings[] = { | |
| "amlogic,meson-gx-dwmac", | |
| "amlogic,meson-gxbb-dwmac", | |
| "snps,dwmac", | |
| NULL | |
| }; | |
| PS_DRIVER_MODULE_DEFINE(odroidc2_ethernet, compatible_strings, ethif_odroidc2_init_module); |