Sun8iEmac.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Niek Linnenbank
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef __SERVER_NETWORK_SUN8I_SUN8IEMAC_H
#define __SERVER_NETWORK_SUN8I_SUN8IEMAC_H
 
#include <FreeNOS/System.h>
#include <Types.h>
#include <Index.h>
#include <Queue.h>
#include <NetworkDevice.h>
#include <Ethernet.h>
#include <arm/sunxi/SunxiClockControl.h>
#include <arm/sunxi/SunxiSystemControl.h>
 
class Sun8iEmac : public NetworkDevice
{
  public:
 
    static const Size InterruptNumber = 114;
 
  private:
 
    static const Address MemoryAddress = 0x01c30000;
 
    static const u8 PhyMdioAddress = 0x1;
 
    static const Size MaximumMiiPoll = 100000;
 
    static const Size MaximumResetPoll = 100000;
 
    enum Registers
    {
        BasicCtl0        = 0x0000, 
        BasicCtl1        = 0x0004, 
        IntStatus        = 0x0008, 
        IntEnable        = 0x000C, 
        TransmitCtl0     = 0x0010, 
        TransmitCtl1     = 0x0014, 
        TransmitFlowCtl  = 0x001C, 
        TransmitDescList = 0x0020, 
        ReceiveCtl0      = 0x0024, 
        ReceiveCtl1      = 0x0028, 
        ReceiveDescList  = 0x0034, 
        ReceiveFrmFilter = 0x0038, 
        ReceiveHash0     = 0x0040, 
        ReceiveHash1     = 0x0044, 
        MiiCmd           = 0x0048, 
        MiiData          = 0x004C, 
        AddrHigh         = 0x0050, 
        AddrLow          = 0x0054, 
        TransmitStatus   = 0x00B0, 
        TransmitCurDesc  = 0x00B4, 
        TransmitCurBuf   = 0x00B8, 
        ReceiveStatus    = 0x00C0, 
        ReceiveCurDesc   = 0x00C4, 
        ReceiveCurBuf    = 0x00C8, 
        RgmiiStatus      = 0x00D0, 
    };
 
    enum BasicCtl0Flags
    {
        BasicCtl0FullDup   = (1 << 0),
        BasicCtl0SpeedMask = ((1 << 2) | (1 << 3)),
        BasicCtl0Speed100  = (0x3 << 2)
    };
 
    enum BasicCtl1Flags
    {
        BasicCtl1Reset      = (1 << 0),
        BasicCtl1BurstShift = 24
    };
 
    enum IntStatusFlags
    {
        IntStatusReceive  = (1 << 8),
        IntStatusTransmit = (1 << 0)
    };
 
    enum IntEnableFlags
    {
        IntEnableReceive  = (1 << 8),
        IntEnableTransmit = (1 << 0)
    };
 
    enum MiiCmdFlags
    {
        MiiCmdPhyAddrShift = 12,
        MiiCmdPhyAddrMask  = 0xf000,
        MiiCmdPhyRegShift  = 4,
        MiiCmdPhyRegMask   = 0xf0,
        MiiCmdPhyCsrDiv128 = 0x3,
        MiiCmdPhyCsrShift  = 20,
        MiiCmdPhyWrite     = (1 << 1),
        MiiCmdPhyBusy      = (1 << 0)
    };
 
    enum MiiRegisters
    {
        MiiRegControl = (0x0), 
        MiiRegStatus  = (0x1), 
        MiiRegIdHigh  = (0x2), 
        MiiRegIdLow   = (0x3), 
        MiiRegAdv     = (0x4), 
        MiiRegLink    = (0x5), 
    };
 
    enum MiiControlFlags
    {
        MiiControlFullDuplex  = 0x0100,
        MiiControlAutoRestart = 0x0200,
        MiiControlAutoEnable  = 0x1000,
        MiiControlSpeed100    = 0x2000,
        MiiControlReset       = 0x8000,
    };
 
    enum MiiStatusFlags
    {
        MiiStatusExt          = 0x0001,
        MiiStatusLink         = 0x0004,
        MiiStatusAutoCap      = 0x0008,
        MiiStatusAutoCompl    = 0x0020
    };
 
    enum MiiAdvFlags
    {
        MiiAdvSpeed10Full  = 0x0040,
        MiiAdvSpeed100Full = 0x0100
    };
 
    enum TransmitCtl0Flags
    {
        TransmitCtl0Enable = (1 << 31)
    };
 
    enum TransmitCtl1Flags
    {
        TransmitCtl1DmaStart  = (1 << 31),
        TransmitCtl1DmaEnable = (1 << 30),
        TransmitCtl1NextFrame = (1 << 2),
        TransmitCtl1FullFrame = (1 << 1)
    };
 
    enum ReceiveCtl0Flags
    {
        ReceiveCtl0Enable = (1 << 31)
    };
 
    enum ReceiveCtl1Flags
    {
        ReceiveCtl1DmaStart   = (1 << 31),
        ReceiveCtl1DmaEnable  = (1 << 30),
        ReceiveCtl1ErrorFrame = (1 << 3),
        ReceiveCtl1UnderFrame = (1 << 2),
        ReceiveCtl1FullFrame  = (1 << 1)
    };
 
    struct FrameDescriptor
    {
        u32 status;
        u32 bufsize;
        u32 bufaddr;
        u32 next;
    };
 
    enum FrameDescriptorFlags
    {
        FrameDescriptorCtl   = (1 << 31),
        TransmitDescRaiseInt = (1 << 31),
        TransmitDescFirst    = (1 << 29),
        TransmitDescLast     = (1 << 30),
        TransmitDescChained  = (1 << 24),
        ReceiveDescLast      = (1 << 8),
        ReceiveDescFrmShift  = 16,
        ReceiveDescFrmMask   = (0x3fff)
    };
 
  public:
 
    Sun8iEmac(const u32 inode,
              NetworkServer &server);
 
    virtual ~Sun8iEmac();
 
    virtual FileSystem::Result initialize();
 
    virtual FileSystem::Result getAddress(Ethernet::Address *address);
 
    virtual FileSystem::Result setAddress(const Ethernet::Address *address);
 
    virtual FileSystem::Result interrupt(const Size vector);
 
    virtual FileSystem::Result transmit(NetworkQueue::Packet *pkt);
 
    virtual FileSystem::Result startDMA();
 
  private:
 
    FileSystem::Result receive();
 
    bool miiBusyWait() const;
 
    u32 miiRead(const u8 phyAddr,
                const u8 regAddr);
 
    void miiWrite(const u8 phyAddr,
                  const u8 regAddr,
                  const u32 data);
 
    FileSystem::Result configPhy();
 
    FileSystem::Result resetPhy();
 
    FileSystem::Result resetReceive();
 
    FileSystem::Result resetTransmit();
 
    FileSystem::Result reset();
 
    void printRx();
 
    void printTx();
 
  private:
 
    Arch::IO m_io;
 
    SunxiClockControl m_ccu;
 
    SunxiSystemControl m_syscon;
 
    Memory::Range m_receiveDescRange;
 
    Index<FrameDescriptor, NetworkQueue::MaxPackets> m_receiveDesc;
 
    Index<NetworkQueue::Packet, NetworkQueue::MaxPackets> m_receivePackets;
 
    Size m_receiveIndex;
 
    Memory::Range m_transmitDescRange;
 
    Index<FrameDescriptor, NetworkQueue::MaxPackets> m_transmitDesc;
 
    Queue<NetworkQueue::Packet *, NetworkQueue::MaxPackets> m_transmitPending;
 
    Queue<NetworkQueue::Packet *, NetworkQueue::MaxPackets> m_transmitPackets;
 
    Size m_transmitIndex;
};
 
#endif /* __SERVER_NETWORK_SUN8I_SUN8IEMAC_H */