/* * Cirrus Logic EP93xx ethernet MAC / MII driver. * * Copyright (C) 2010, 2009 * Matthias Kaehlcke <matthias@kaehlcke.net> * * Copyright (C) 2004, 2005 * Cory T. Tusar, Videon Central, Inc., <ctusar@videon-central.com> * * Based on the original eth.[ch] Cirrus Logic EP93xx Rev D. Ethernet Driver, * which is * * (C) Copyright 2002 2003 * Adam Bezanson, Network Audio Technologies, Inc. * <bezanson@netaudiotech.com> * * See file CREDITS for list of people who contributed to this project. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <command.h> #include <common.h> #include <asm/arch/ep93xx.h> #include <asm/io.h> #include <malloc.h> #include <miiphy.h> #include <linux/types.h> #include "ep93xx_eth.h" #define GET_PRIV(eth_dev) ((struct ep93xx_priv *)(eth_dev)->priv) #define GET_REGS(eth_dev) (GET_PRIV(eth_dev)->regs) /* ep93xx_miiphy ops forward declarations */ static int ep93xx_miiphy_read(const char * const dev, unsigned char const addr, unsigned char const reg, unsigned short * const value); static int ep93xx_miiphy_write(const char * const dev, unsigned char const addr, unsigned char const reg, unsigned short const value); #if defined(EP93XX_MAC_DEBUG) /** * Dump ep93xx_mac values to the terminal. */ static void dump_dev(struct eth_device *dev) { struct ep93xx_priv *priv = GET_PRIV(dev); int i; printf("\ndump_dev()\n"); printf(" rx_dq.base %p\n", priv->rx_dq.base); printf(" rx_dq.current %p\n", priv->rx_dq.current); printf(" rx_dq.end %p\n", priv->rx_dq.end); printf(" rx_sq.base %p\n", priv->rx_sq.base); printf(" rx_sq.current %p\n", priv->rx_sq.current); printf(" rx_sq.end %p\n", priv->rx_sq.end); for (i = 0; i < NUMRXDESC; i++) printf(" rx_buffer[%2.d] %p\n", i, NetRxPackets[i]); printf(" tx_dq.base %p\n", priv->tx_dq.base); printf(" tx_dq.current %p\n", priv->tx_dq.current); printf(" tx_dq.end %p\n", priv->tx_dq.end); printf(" tx_sq.base %p\n", priv->tx_sq.base); printf(" tx_sq.current %p\n", priv->tx_sq.current); printf(" tx_sq.end %p\n", priv->tx_sq.end); } /** * Dump all RX status queue entries to the terminal. */ static void dump_rx_status_queue(struct eth_device *dev) { struct ep93xx_priv *priv = GET_PRIV(dev); int i; printf("\ndump_rx_status_queue()\n"); printf(" descriptor address word1 word2\n"); for (i = 0; i < NUMRXDESC; i++) { printf(" [ %p ] %08X %08X\n", priv->rx_sq.base + i, (priv->rx_sq.base + i)->word1, (priv->rx_sq.base + i)->word2); } } /** * Dump all RX descriptor queue entries to the terminal. */ static void dump_rx_descriptor_queue(struct eth_device *dev) { struct ep93xx_priv *priv = GET_PRIV(dev); int i; printf("\ndump_rx_descriptor_queue()\n"); printf(" descriptor address word1 word2\n"); for (i = 0; i < NUMRXDESC; i++) { printf(" [ %p ] %08X %08X\n", priv->rx_dq.base + i, (priv->rx_dq.base + i)->word1, (priv->rx_dq.base + i)->word2); } } /** * Dump all TX descriptor queue entries to the terminal. */ static void dump_tx_descriptor_queue(struct eth_device *dev) { struct ep93xx_priv *priv = GET_PRIV(dev); int i; printf("\ndump_tx_descriptor_queue()\n"); printf(" descriptor address word1 word2\n"); for (i = 0; i < NUMTXDESC; i++) { printf(" [ %p ] %08X %08X\n", priv->tx_dq.base + i, (priv->tx_dq.base + i)->word1, (priv->tx_dq.base + i)->word2); } } /** * Dump all TX status queue entries to the terminal. */ static void dump_tx_status_queue(struct eth_device *dev) { struct ep93xx_priv *priv = GET_PRIV(dev); int i; printf("\ndump_tx_status_queue()\n"); printf(" descriptor address word1\n"); for (i = 0; i < NUMTXDESC; i++) { printf(" [ %p ] %08X\n", priv->rx_sq.base + i, (priv->rx_sq.base + i)->word1); } } #else #define dump_dev(x) #define dump_rx_descriptor_queue(x) #define dump_rx_status_queue(x) #define dump_tx_descriptor_queue(x) #define dump_tx_status_queue(x) #endif /* defined(EP93XX_MAC_DEBUG) */ /** * Reset the EP93xx MAC by twiddling the soft reset bit and spinning until * it's cleared. */ static void ep93xx_mac_reset(struct eth_device *dev) { struct mac_regs *mac = GET_REGS(dev); uint32_t value; debug("+ep93xx_mac_reset"); value = readl(&mac->selfctl); value |= SELFCTL_RESET; writel(value, &mac->selfctl); while (readl(&mac->selfctl) & SELFCTL_RESET) ; /* noop */ debug("-ep93xx_mac_reset"); } /* Eth device open */ static int ep93xx_eth_open(struct eth_device *dev, bd_t *bd) { struct ep93xx_priv *priv = GET_PRIV(dev); struct mac_regs *mac = GET_REGS(dev); uchar *mac_addr = dev->enetaddr; int i; debug("+ep93xx_eth_open"); /* Reset the MAC */ ep93xx_mac_reset(dev); /* Reset the descriptor queues' current and end address values */ priv->tx_dq.current = priv->tx_dq.base; priv->tx_dq.end = (priv->tx_dq.base + NUMTXDESC); priv->tx_sq.current = priv->tx_sq.base; priv->tx_sq.end = (priv->tx_sq.base + NUMTXDESC); priv->rx_dq.current = priv->rx_dq.base; priv->rx_dq.end = (priv->rx_dq.base + NUMRXDESC); priv->rx_sq.current = priv->rx_sq.base; priv->rx_sq.end = (priv->rx_sq.base + NUMRXDESC); /* * Set the transmit descriptor and status queues' base address, * current address, and length registers. Set the maximum frame * length and threshold. Enable the transmit descriptor processor. */ writel((uint32_t)priv->tx_dq.base, &mac->txdq.badd); writel((uint32_t)priv->tx_dq.base, &mac->txdq.curadd); writel(sizeof(struct tx_descriptor) * NUMTXDESC, &mac->txdq.blen); writel((uint32_t)priv->tx_sq.base, &mac->txstsq.badd); writel((uint32_t)priv->tx_sq.base, &mac->txstsq.curadd); writel(sizeof(struct tx_status) * NUMTXDESC, &mac->txstsq.blen); writel(0x00040000, &mac->txdthrshld); writel(0x00040000, &mac->txststhrshld); writel((TXSTARTMAX << 0) | (PKTSIZE_ALIGN << 16), &mac->maxfrmlen); writel(BMCTL_TXEN, &mac->bmctl); /* * Set the receive descriptor and status queues' base address, * current address, and length registers. Enable the receive * descriptor processor. */ writel((uint32_t)priv->rx_dq.base, &mac->rxdq.badd); writel((uint32_t)priv->rx_dq.base, &mac->rxdq.curadd); writel(sizeof(struct rx_descriptor) * NUMRXDESC, &mac->rxdq.blen); writel((uint32_t)priv->rx_sq.base, &mac->rxstsq.badd); writel((uint32_t)priv->rx_sq.base, &mac->rxstsq.curadd); writel(sizeof(struct rx_status) * NUMRXDESC, &mac->rxstsq.blen); writel(0x00040000, &mac->rxdthrshld); writel(BMCTL_RXEN, &mac->bmctl); writel(0x00040000, &mac->rxststhrshld); /* Wait until the receive descriptor processor is active */ while (!(readl(&mac->bmsts) & BMSTS_RXACT)) ; /* noop */ /* * Initialize the RX descriptor queue. Clear the TX descriptor queue. * Clear the RX and TX status queues. Enqueue the RX descriptor and * status entries to the MAC. */ for (i = 0; i < NUMRXDESC; i++) { /* set buffer address */ (priv->rx_dq.base + i)->word1 = (uint32_t)NetRxPackets[i]; /* set buffer length, clear buffer index and NSOF */ (priv->rx_dq.base + i)->word2 = PKTSIZE_ALIGN; } memset(priv->tx_dq.base, 0, (sizeof(struct tx_descriptor) * NUMTXDESC)); memset(priv->rx_sq.base, 0, (sizeof(struct rx_status) * NUMRXDESC)); memset(priv->tx_sq.base, 0, (sizeof(struct tx_status) * NUMTXDESC)); writel(NUMRXDESC, &mac->rxdqenq); writel(NUMRXDESC, &mac->rxstsqenq); /* Set the primary MAC address */ writel(AFP_IAPRIMARY, &mac->afp); writel(mac_addr[0] | (mac_addr[1] << 8) | (mac_addr[2] << 16) | (mac_addr[3] << 24), &mac->indad); writel(mac_addr[4] | (mac_addr[5] << 8), &mac->indad_upper); /* Turn on RX and TX */ writel(RXCTL_IA0 | RXCTL_BA | RXCTL_SRXON | RXCTL_RCRCA | RXCTL_MA, &mac->rxctl); writel(TXCTL_STXON, &mac->txctl); /* Dump data structures if we're debugging */ dump_dev(dev); dump_rx_descriptor_queue(dev); dump_rx_status_queue(dev); dump_tx_descriptor_queue(dev); dump_tx_status_queue(dev); debug("-ep93xx_eth_open"); return 1; } /** * Halt EP93xx MAC transmit and receive by clearing the TxCTL and RxCTL * registers. */ static void ep93xx_eth_close(struct eth_device *dev) { struct mac_regs *mac = GET_REGS(dev); debug("+ep93xx_eth_close"); writel(0x00000000, &mac->rxctl); writel(0x00000000, &mac->txctl); debug("-ep93xx_eth_close"); } /** * Copy a frame of data from the MAC into the protocol layer for further * processing. */ static int ep93xx_eth_rcv_packet(struct eth_device *dev) { struct mac_regs *mac = GET_REGS(dev); struct ep93xx_priv *priv = GET_PRIV(dev); int len = -1; debug("+ep93xx_eth_rcv_packet"); if (RX_STATUS_RFP(priv->rx_sq.current)) { if (RX_STATUS_RWE(priv->rx_sq.current)) { /* * We have a good frame. Extract the frame's length * from the current rx_status_queue entry, and copy * the frame's data into NetRxPackets[] of the * protocol stack. We track the total number of * bytes in the frame (nbytes_frame) which will be * used when we pass the data off to the protocol * layer via NetReceive(). */ len = RX_STATUS_FRAME_LEN(priv->rx_sq.current); NetReceive((uchar *)priv->rx_dq.current->word1, len); debug("reporting %d bytes...\n", len); } else { /* Do we have an erroneous packet? */ error("packet rx error, status %08X %08X", priv->rx_sq.current->word1, priv->rx_sq.current->word2); dump_rx_descriptor_queue(dev); dump_rx_status_queue(dev); } /* * Clear the associated status queue entry, and * increment our current pointers to the next RX * descriptor and status queue entries (making sure * we wrap properly). */ memset((void *)priv->rx_sq.current, 0, sizeof(struct rx_status)); priv->rx_sq.current++; if (priv->rx_sq.current >= priv->rx_sq.end) priv->rx_sq.current = priv->rx_sq.base; priv->rx_dq.current++; if (priv->rx_dq.current >= priv->rx_dq.end) priv->rx_dq.current = priv->rx_dq.base; /* * Finally, return the RX descriptor and status entries * back to the MAC engine, and loop again, checking for * more descriptors to process. */ writel(1, &mac->rxdqenq); writel(1, &mac->rxstsqenq); } else { len = 0; } debug("-ep93xx_eth_rcv_packet %d", len); return len; } /** * Send a block of data via ethernet. */ static int ep93xx_eth_send_packet(struct eth_device *dev, volatile void * const packet, int const length) { struct mac_regs *mac = GET_REGS(dev); struct ep93xx_priv *priv = GET_PRIV(dev); int ret = -1; debug("+ep93xx_eth_send_packet"); /* Parameter check */ BUG_ON(packet == NULL); /* * Initialize the TX descriptor queue with the new packet's info. * Clear the associated status queue entry. Enqueue the packet * to the MAC for transmission. */ /* set buffer address */ priv->tx_dq.current->word1 = (uint32_t)packet; /* set buffer length and EOF bit */ priv->tx_dq.current->word2 = length | TX_DESC_EOF; /* clear tx status */ priv->tx_sq.current->word1 = 0; /* enqueue the TX descriptor */ writel(1, &mac->txdqenq); /* wait for the frame to become processed */ while (!TX_STATUS_TXFP(priv->tx_sq.current)) ; /* noop */ if (!TX_STATUS_TXWE(priv->tx_sq.current)) { error("packet tx error, status %08X", priv->tx_sq.current->word1); dump_tx_descriptor_queue(dev); dump_tx_status_queue(dev); /* TODO: Add better error handling? */ goto eth_send_out; } ret = 0; /* Fall through */ eth_send_out: debug("-ep93xx_eth_send_packet %d", ret); return ret; } #if defined(CONFIG_MII) int ep93xx_miiphy_initialize(bd_t * const bd) { miiphy_register("ep93xx_eth0", ep93xx_miiphy_read, ep93xx_miiphy_write); return 0; } #endif /** * Initialize the EP93xx MAC. The MAC hardware is reset. Buffers are * allocated, if necessary, for the TX and RX descriptor and status queues, * as well as for received packets. The EP93XX MAC hardware is initialized. * Transmit and receive operations are enabled. */ int ep93xx_eth_initialize(u8 dev_num, int base_addr) { int ret = -1; struct eth_device *dev; struct ep93xx_priv *priv; debug("+ep93xx_eth_initialize"); priv = malloc(sizeof(*priv)); if (!priv) { error("malloc() failed"); goto eth_init_failed_0; } memset(priv, 0, sizeof(*priv)); priv->regs = (struct mac_regs *)base_addr; priv->tx_dq.base = calloc(NUMTXDESC, sizeof(struct tx_descriptor)); if (priv->tx_dq.base == NULL) { error("calloc() failed"); goto eth_init_failed_1; } priv->tx_sq.base = calloc(NUMTXDESC, sizeof(struct tx_status)); if (priv->tx_sq.base == NULL) { error("calloc() failed"); goto eth_init_failed_2; } priv->rx_dq.base = calloc(NUMRXDESC, sizeof(struct rx_descriptor)); if (priv->rx_dq.base == NULL) { error("calloc() failed"); goto eth_init_failed_3; } priv->rx_sq.base = calloc(NUMRXDESC, sizeof(struct rx_status)); if (priv->rx_sq.base == NULL) { error("calloc() failed"); goto eth_init_failed_4; } dev = malloc(sizeof *dev); if (dev == NULL) { error("malloc() failed"); goto eth_init_failed_5; } memset(dev, 0, sizeof *dev); dev->iobase = base_addr; dev->priv = priv; dev->init = ep93xx_eth_open; dev->halt = ep93xx_eth_close; dev->send = ep93xx_eth_send_packet; dev->recv = ep93xx_eth_rcv_packet; sprintf(dev->name, "ep93xx_eth-%hu", dev_num); eth_register(dev); /* Done! */ ret = 1; goto eth_init_done; eth_init_failed_5: free(priv->rx_sq.base); /* Fall through */ eth_init_failed_4: free(priv->rx_dq.base); /* Fall through */ eth_init_failed_3: free(priv->tx_sq.base); /* Fall through */ eth_init_failed_2: free(priv->tx_dq.base); /* Fall through */ eth_init_failed_1: free(priv); /* Fall through */ eth_init_failed_0: /* Fall through */ eth_init_done: debug("-ep93xx_eth_initialize %d", ret); return ret; } #if defined(CONFIG_MII) /** * Maximum MII address we support */ #define MII_ADDRESS_MAX 31 /** * Maximum MII register address we support */ #define MII_REGISTER_MAX 31 /** * Read a 16-bit value from an MII register. */ static int ep93xx_miiphy_read(const char * const dev, unsigned char const addr, unsigned char const reg, unsigned short * const value) { struct mac_regs *mac = (struct mac_regs *)MAC_BASE; int ret = -1; uint32_t self_ctl; debug("+ep93xx_miiphy_read"); /* Parameter checks */ BUG_ON(dev == NULL); BUG_ON(addr > MII_ADDRESS_MAX); BUG_ON(reg > MII_REGISTER_MAX); BUG_ON(value == NULL); /* * Save the current SelfCTL register value. Set MAC to suppress * preamble bits. Wait for any previous MII command to complete * before issuing the new command. */ self_ctl = readl(&mac->selfctl); #if defined(CONFIG_MII_SUPPRESS_PREAMBLE) writel(self_ctl & ~(1 << 8), &mac->selfctl); #endif /* defined(CONFIG_MII_SUPPRESS_PREAMBLE) */ while (readl(&mac->miists) & MIISTS_BUSY) ; /* noop */ /* * Issue the MII 'read' command. Wait for the command to complete. * Read the MII data value. */ writel(MIICMD_OPCODE_READ | ((uint32_t)addr << 5) | (uint32_t)reg, &mac->miicmd); while (readl(&mac->miists) & MIISTS_BUSY) ; /* noop */ *value = (unsigned short)readl(&mac->miidata); /* Restore the saved SelfCTL value and return. */ writel(self_ctl, &mac->selfctl); ret = 0; /* Fall through */ debug("-ep93xx_miiphy_read"); return ret; } /** * Write a 16-bit value to an MII register. */ static int ep93xx_miiphy_write(const char * const dev, unsigned char const addr, unsigned char const reg, unsigned short const value) { struct mac_regs *mac = (struct mac_regs *)MAC_BASE; int ret = -1; uint32_t self_ctl; debug("+ep93xx_miiphy_write"); /* Parameter checks */ BUG_ON(dev == NULL); BUG_ON(addr > MII_ADDRESS_MAX); BUG_ON(reg > MII_REGISTER_MAX); /* * Save the current SelfCTL register value. Set MAC to suppress * preamble bits. Wait for any previous MII command to complete * before issuing the new command. */ self_ctl = readl(&mac->selfctl); #if defined(CONFIG_MII_SUPPRESS_PREAMBLE) writel(self_ctl & ~(1 << 8), &mac->selfctl); #endif /* defined(CONFIG_MII_SUPPRESS_PREAMBLE) */ while (readl(&mac->miists) & MIISTS_BUSY) ; /* noop */ /* Issue the MII 'write' command. Wait for the command to complete. */ writel((uint32_t)value, &mac->miidata); writel(MIICMD_OPCODE_WRITE | ((uint32_t)addr << 5) | (uint32_t)reg, &mac->miicmd); while (readl(&mac->miists) & MIISTS_BUSY) ; /* noop */ /* Restore the saved SelfCTL value and return. */ writel(self_ctl, &mac->selfctl); ret = 0; /* Fall through */ debug("-ep93xx_miiphy_write"); return ret; } #endif /* defined(CONFIG_MII) */