/* Copyright (c) 2003-2011
 * Stefano Ceccherini <stefano.ceccherini@gmail.com>. All rights reserved.
 * This file is released under the MIT license
 */
#include "device.h"
#include "driver.h"
#include "debug.h"
#include "ether_driver.h"
#include "interface.h"
#include "wb840.h"

#include <ByteOrder.h>
#include <KernelExport.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

// MII chip info table
#define PHY_ID0_DAVICOM_DM9101  0x0181
#define PHY_ID1_DAVICOM_DM9101  0xb800
#define MII_HOME        0x0001
#define MII_LAN         0x0002

struct mii_chip_info
{
        const char* name;
        uint16 id0;
        uint16 id1;
        uint8  types;
};


const static struct mii_chip_info
gMIIChips[] = {
        {"DAVICOM_DM9101", PHY_ID0_DAVICOM_DM9101, PHY_ID1_DAVICOM_DM9101, MII_LAN},
        {NULL, 0, 0, 0}
};


static int
mii_readstatus(wb_device* device)
{
        int i = 0;
        int status;

        // status bit has to be retrieved 2 times
        while (i++ < 2)
                status = wb_miibus_readreg(device, device->phy, MII_STATUS);

        return status;
}


static phys_addr_t
physicalAddress(volatile void* addr, uint32 length)
{
        physical_entry table;

        get_memory_map((void*)addr, length, &table, 1);

        return table.address;
}


// Prepares a RX descriptor to be used by the chip
void
wb_put_rx_descriptor(volatile wb_desc* descriptor)
{
        descriptor->wb_status = WB_RXSTAT_OWN;
        descriptor->wb_ctl |= WB_MAX_FRAMELEN | WB_RXCTL_RLINK;
}


void
wb_enable_interrupts(wb_device* device)
{
        write32(device->reg_base + WB_IMR, WB_INTRS);
        write32(device->reg_base + WB_ISR, 0xFFFFFFFF);
}


void
wb_disable_interrupts(wb_device* device)
{
        write32(device->reg_base + WB_IMR, 0L);
        write32(device->reg_base + WB_ISR, 0L);
}


static void
wb_selectPHY(wb_device* device)
{
        uint16 status;

        // ToDo: need to be changed, select PHY in relation to the link mode
        device->currentPHY = device->firstPHY;
        device->phy = device->currentPHY->address;
        status = wb_miibus_readreg(device, device->phy, MII_CONTROL);
        status &= ~MII_CONTROL_ISOLATE;

        wb_miibus_writereg(device, device->phy, MII_CONTROL, status);

        wb_read_mode(device);
}


status_t
wb_initPHYs(wb_device* device)
{
        uint16 phy;
        // search for total of 32 possible MII PHY addresses
        for (phy = 0; phy < 32; phy++) {
                struct mii_phy* mii;
                uint16 status;
                int i = 0;

                status = wb_miibus_readreg(device, phy, MII_STATUS);
                status = wb_miibus_readreg(device, phy, MII_STATUS);

                if (status == 0xffff || status == 0x0000)
                        // this MII is not accessable
                        continue;

                mii = (struct mii_phy*)calloc(1, sizeof(struct mii_phy));
                if (mii == NULL)
                        return B_NO_MEMORY;

                mii->address = phy;
                mii->id0 = wb_miibus_readreg(device, phy, MII_PHY_ID0);
                mii->id1 = wb_miibus_readreg(device, phy, MII_PHY_ID1);
                mii->types = MII_HOME;
                mii->next = device->firstPHY;
                device->firstPHY = mii;

                while (gMIIChips[i].name != NULL) {
                        if (gMIIChips[i].id0 == mii->id0
                                && gMIIChips[i].id1 == (mii->id1 & 0xfff0)) {
                                dprintf("Found MII PHY: %s\n", gMIIChips[i].name);
                                mii->types = gMIIChips[i].types;
                                break;
                        }
                        i++;
                }
                if (gMIIChips[i].name == NULL) {
                        dprintf("Unknown MII PHY transceiver: id = (%x, %x).\n",
                                mii->id0, mii->id1);
                }
        }

        if (device->firstPHY == NULL) {
                dprintf("No MII PHY transceiver found!\n");
                return B_ENTRY_NOT_FOUND;
        }

        wb_selectPHY(device);
        device->link = mii_readstatus(device) & MII_STATUS_LINK;

        return B_OK;
}


void
wb_init(wb_device* device)
{
        LOG((DEVICE_NAME": init()\n"));

        wb_reset(device);

        device->wb_txthresh = WB_TXTHRESH_INIT;

        switch(device->wb_cachesize) {
                case 32:
                        WB_SETBIT(device->reg_base + WB_BUSCTL, WB_CACHEALIGN_32LONG);
                        break;
                case 16:
                        WB_SETBIT(device->reg_base + WB_BUSCTL, WB_CACHEALIGN_16LONG);
                        break;
                case 8:
                        WB_SETBIT(device->reg_base + WB_BUSCTL, WB_CACHEALIGN_8LONG);
                        break;
                case 0:
                default:
                        WB_SETBIT(device->reg_base + WB_BUSCTL, WB_CACHEALIGN_NONE);
                        break;
        }

        write32(device->reg_base + WB_BUSCTL,
                WB_BUSCTL_MUSTBEONE | WB_BUSCTL_ARBITRATION);
        WB_SETBIT(device->reg_base + WB_BUSCTL, WB_BURSTLEN_16LONG);

        write32(device->reg_base + WB_BUSCTL_SKIPLEN, WB_SKIPLEN_4LONG);

        // Disable early TX/RX interrupt, as we can't take advantage
        // from them, at least for now.
        WB_CLRBIT(device->reg_base + WB_NETCFG,
                (WB_NETCFG_TX_EARLY_ON | WB_NETCFG_RX_EARLY_ON));

        wb_set_rx_filter(device);
}


void
wb_reset(wb_device *device)
{
        int i = 0;

        LOG((DEVICE_NAME": reset()\n"));

        write32(device->reg_base + WB_NETCFG, 0L);
        write32(device->reg_base + WB_BUSCTL, 0L);
        write32(device->reg_base + WB_TXADDR, 0L);
        write32(device->reg_base + WB_RXADDR, 0L);

        WB_SETBIT(device->reg_base + WB_BUSCTL, WB_BUSCTL_RESET);
        WB_SETBIT(device->reg_base + WB_BUSCTL, WB_BUSCTL_RESET);

        for (i = 0; i < WB_TIMEOUT; i++) {
                if (!(read32(device->reg_base + WB_BUSCTL) & WB_BUSCTL_RESET))
                        break;
        }

        if (i == WB_TIMEOUT)
                LOG((DEVICE_NAME": reset hasn't completed!!!"));

        /* Wait a bit while the chip reorders his toughts */
        snooze(1000);
}


status_t
wb_stop(wb_device* device)
{
        uint32 cfgAddress = (uint32)device->reg_base + WB_NETCFG;
        int32 i = 0;

        if (read32(cfgAddress) & (WB_NETCFG_TX_ON | WB_NETCFG_RX_ON)) {
                WB_CLRBIT(cfgAddress, (WB_NETCFG_TX_ON | WB_NETCFG_RX_ON));

                for (i = 0; i < WB_TIMEOUT; i++) {
                        if ((read32(device->reg_base + WB_ISR) & WB_ISR_TX_IDLE) &&
                                (read32(device->reg_base + WB_ISR) & WB_ISR_RX_IDLE))
                                break;
                }
        }

        if (i < WB_TIMEOUT)
                return B_OK;

        return B_ERROR;
}


static void
wb_updateLink(wb_device* device)
{
        if (!device->autoNegotiationComplete) {
                int32 mode = wb_read_mode(device);
                if (mode)
                        wb_set_mode(device, mode);

                return;
        }

        if (device->link) {
                uint16 status = mii_readstatus(device);

                // Check if link lost
                if ((status & MII_STATUS_LINK) == 0)
                        device->link = false;
        } else {
                uint16 status;
                wb_selectPHY(device);

                // Check if we have a new link
                status = mii_readstatus(device);
                if (status & MII_STATUS_LINK)
                        device->link = true;
        }
}


int32
wb_tick(timer* arg)
{
        wb_device* device = (wb_device*)arg;

        wb_updateLink(device);

        return B_HANDLED_INTERRUPT;
}


/*
 * Program the rx filter.
 */
void
wb_set_rx_filter(wb_device* device)
{
        // TODO: Basically we just config the filter to accept broadcasts
        // packets. We'll need also to configure it to multicast.
        WB_SETBIT(device->reg_base + WB_NETCFG, WB_NETCFG_RX_BROAD);
}


/***************** Interrupt handling ******************************/
static status_t
wb_rxok(wb_device* device)
{
        uint32 releaseRxSem = 0;
        int16 limit;

        acquire_spinlock(&device->rxSpinlock);

        for (limit = device->rxFree; limit > 0; limit--) {
                if (device->rxDescriptor[device->rxInterruptIndex].wb_status
                        & WB_RXSTAT_OWN) {
                        break;
                }

                releaseRxSem++;
                device->rxInterruptIndex = (device->rxInterruptIndex + 1)
                        & WB_RX_CNT_MASK;
                device->rxFree--;
        }

        // Re-enable receive queue
        write32(device->reg_base + WB_RXSTART, 0xFFFFFFFF);

        release_spinlock(&device->rxSpinlock);

        if (releaseRxSem > 0) {
                release_sem_etc(device->rxSem, releaseRxSem, B_DO_NOT_RESCHEDULE);
                return B_INVOKE_SCHEDULER;
        }

        return B_HANDLED_INTERRUPT;
}


static status_t
wb_tx_nobuf(wb_device* info)
{
        int16 releaseTxSem = 0;
        int16 limit;
        status_t status;

        acquire_spinlock(&info->txSpinlock);

        for (limit = info->txSent; limit > 0; limit--) {
                status = info->txDescriptor[info->txInterruptIndex].wb_status;

                LOG(("wb_tx_nobuf, status: %lx\n", status));
                if (status & WB_TXSTAT_TXERR) {
                        LOG(("TX_STAT_ERR\n"));
                        break;
                } else if (status & WB_UNSENT) {
                        LOG(("TX_STAT_UNSENT\n"));
                        break;
                } else if (status & WB_TXSTAT_OWN) {
                        LOG((DEVICE_NAME": Device still owns the descriptor\n"));
                        break;
                } else
                        info->txDescriptor[info->txInterruptIndex].wb_status = 0;

                releaseTxSem++; // this many buffers are free
                info->txInterruptIndex = (info->txInterruptIndex + 1) & WB_TX_CNT_MASK;
                info->txSent--;

                if (info->txSent < 0 || info->txSent > WB_TX_LIST_CNT)
                        dprintf("ERROR interrupt: txSent = %d\n", info->txSent);
        }

        release_spinlock(&info->txSpinlock);

        if (releaseTxSem) {
                release_sem_etc(info->txSem, releaseTxSem, B_DO_NOT_RESCHEDULE);
                return B_INVOKE_SCHEDULER;
        }

        return B_HANDLED_INTERRUPT;
}


int32
wb_interrupt(void* arg)
{
        wb_device* device = (wb_device*)arg;
        int32 retval = B_UNHANDLED_INTERRUPT;
        uint32 status;

        // TODO: Handle other interrupts

        acquire_spinlock(&device->intLock);

        status = read32(device->reg_base + WB_ISR);

        // Did this card request the interrupt ?
        if (status & WB_INTRS) {
                // Clean all the interrupts bits
                if (status)
                        write32(device->reg_base + WB_ISR, status);

                if (status & WB_ISR_ABNORMAL)
                        LOG((DEVICE_NAME": *** Abnormal Interrupt received ***\n"));
                else
                        LOG((DEVICE_NAME": interrupt received: \n"));

                if (status & WB_ISR_RX_EARLY) {
                        LOG(("WB_ISR_RX_EARLY\n"));
                }

                if (status & WB_ISR_RX_NOBUF) {
                        LOG(("WB_ISR_RX_NOBUF\n"));
                        // Something is screwed
                }

                if (status & WB_ISR_RX_ERR) {
                        LOG(("WB_ISR_RX_ERR\n"));
                        // TODO: Do something useful
                }

                if (status & WB_ISR_RX_OK) {
                        LOG(("WB_ISR_RX_OK\n"));
                        retval = wb_rxok(device);
                }

                if (status & WB_ISR_RX_IDLE) {
                        LOG(("WB_ISR_RX_IDLE\n"));
                        // ???
                }

                if (status & WB_ISR_TX_EARLY) {
                        LOG(("WB_ISR_TX_EARLY\n"));

                }

                if (status & WB_ISR_TX_NOBUF) {
                        LOG(("WB_ISR_TX_NOBUF\n"));
                        retval = wb_tx_nobuf(device);
                }

                if (status & WB_ISR_TX_UNDERRUN) {
                        LOG(("WB_ISR_TX_UNDERRUN\n"));
                        // TODO: Jack up TX Threshold
                }

                if (status & WB_ISR_TX_IDLE) {
                        LOG(("WB_ISR_TX_IDLE\n"));
                }

                if (status & WB_ISR_TX_OK) {
                        LOG(("WB_ISR_TX_OK\n"));
                        // So what ?
                }

                if (status & WB_ISR_BUS_ERR) {
                        LOG(("WB_ISR_BUS_ERROR: %lx\n", (status & WB_ISR_BUSERRTYPE) >> 4));
                        //wb_reset(device);
                }

                if (status & WB_ISR_TIMER_EXPIRED) {
                        LOG(("WB_ISR_TIMER_EXPIRED\n"));
                        // ??
                }
        }

        release_spinlock(&device->intLock);

        return retval;
}


/*
 * Print an ethernet address
 */
void
print_address(ether_address_t* addr)
{
        int i;
        char buf[3 * 6 + 1];

        for (i = 0; i < 5; i++) {
                sprintf(&buf[3 * i], "%02x:", addr->ebyte[i]);
        }
        sprintf(&buf[3 * 5], "%02x", addr->ebyte[5]);
        dprintf("%s\n", buf);
}


status_t
wb_create_semaphores(wb_device* device)
{
        device->rxSem = create_sem(0, "wb840 receive");
        if (device->rxSem < B_OK) {
                LOG(("Couldn't create sem, sem_id %ld\n", device->rxSem));
                return device->rxSem;
        }

        device->txSem = create_sem(WB_TX_LIST_CNT, "wb840 transmit");
        if (device->txSem < B_OK) {
                LOG(("Couldn't create sem, sem_id %ld\n", device->txSem));
                delete_sem(device->rxSem);
                return device->txSem;
        }

        set_sem_owner(device->rxSem, B_SYSTEM_TEAM);
        set_sem_owner(device->txSem, B_SYSTEM_TEAM);

        device->rxLock = 0;
        device->txLock = 0;

        return B_OK;
}


void
wb_delete_semaphores(wb_device* device)
{
        if (device->rxSem >= 0)
                delete_sem(device->rxSem);
        if (device->txSem >= 0)
                delete_sem(device->txSem);
}


status_t
wb_create_rings(wb_device* device)
{
        int i;

        device->rxArea = create_area("wb840 rx buffer",
                (void**)&device->rxBuffer[0], B_ANY_KERNEL_ADDRESS,
                ROUND_TO_PAGE_SIZE(WB_BUFBYTES * WB_RX_LIST_CNT),
                B_32_BIT_FULL_LOCK, B_READ_AREA | B_WRITE_AREA);
        if (device->rxArea < B_OK)
                return device->rxArea;

        for (i = 1; i < WB_RX_LIST_CNT; i++) {
                device->rxBuffer[i] = (void*)(((addr_t)device->rxBuffer[0])
                        + (i * WB_BUFBYTES));
        }

        for (i = 0; i < WB_RX_LIST_CNT; i++) {
                device->rxDescriptor[i].wb_status = 0;
                device->rxDescriptor[i].wb_ctl = WB_RXCTL_RLINK;
                wb_put_rx_descriptor(&device->rxDescriptor[i]);
                device->rxDescriptor[i].wb_data = physicalAddress(
                        device->rxBuffer[i], WB_BUFBYTES);
                device->rxDescriptor[i].wb_next = physicalAddress(
                        &device->rxDescriptor[(i + 1) & WB_RX_CNT_MASK],
                        sizeof(struct wb_desc));
        }

        device->rxFree = WB_RX_LIST_CNT;

        device->txArea = create_area("wb840 tx buffer",
                (void**)&device->txBuffer[0], B_ANY_KERNEL_ADDRESS,
                ROUND_TO_PAGE_SIZE(WB_BUFBYTES * WB_TX_LIST_CNT),
                B_32_BIT_FULL_LOCK, B_READ_AREA | B_WRITE_AREA);

        if (device->txArea < B_OK) {
                delete_area(device->rxArea);
                return device->txArea;
        }

        for (i = 1; i < WB_TX_LIST_CNT; i++) {
                device->txBuffer[i] = (void*)(((addr_t)device->txBuffer[0])
                        + (i * WB_BUFBYTES));
        }

        for (i = 0; i < WB_TX_LIST_CNT; i++) {
                device->txDescriptor[i].wb_status = 0;
                device->txDescriptor[i].wb_ctl = WB_TXCTL_TLINK;
                device->txDescriptor[i].wb_data = physicalAddress(
                        device->txBuffer[i], WB_BUFBYTES);
                device->txDescriptor[i].wb_next = physicalAddress(
                        &device->txDescriptor[(i + 1) & WB_TX_CNT_MASK],
                        sizeof(struct wb_desc));
        }

        if (wb_stop(device) == B_OK) {
                write32(device->reg_base + WB_RXADDR,
                        physicalAddress(&device->rxDescriptor[0], sizeof(struct wb_desc)));
                write32(device->reg_base + WB_TXADDR,
                        physicalAddress(&device->txDescriptor[0], sizeof(struct wb_desc)));
        }

        return B_OK;
}


void
wb_delete_rings(wb_device* device)
{
        delete_area(device->rxArea);
        delete_area(device->txArea);
}


int32
wb_read_mode(wb_device* info)
{
        uint16 autoAdv;
        uint16 autoLinkPartner;
        int32 speed;
        int32 duplex;

        uint16 status = mii_readstatus(info);
        if (!(status & MII_STATUS_LINK)) {
                LOG((DEVICE_NAME ": no link detected (status = %x)\n", status));
                return 0;
        }

        // auto negotiation completed
        autoAdv = wb_miibus_readreg(info, info->phy, MII_AUTONEG_ADV);
        autoLinkPartner = wb_miibus_readreg(info, info->phy,
                MII_AUTONEG_LINK_PARTNER);
        status = autoAdv & autoLinkPartner;

        speed = status & (MII_NWAY_TX | MII_NWAY_TX_FDX)
                ? LINK_SPEED_100_MBIT : LINK_SPEED_10_MBIT;
        duplex = status & (MII_NWAY_TX_FDX | MII_NWAY_T_FDX)
                ? LINK_FULL_DUPLEX : LINK_HALF_DUPLEX;

        info->autoNegotiationComplete = true;

        LOG((DEVICE_NAME ": linked, 10%s MBit, %s duplex\n",
                                speed == LINK_SPEED_100_MBIT ? "0" : "",
                                duplex == LINK_FULL_DUPLEX ? "full" : "half"));

        return speed | duplex;
}


void
wb_set_mode(wb_device* info, int mode)
{
        uint32 cfgAddress = (uint32)info->reg_base + WB_NETCFG;

        uint32 configFlags = 0;
        status_t status;

        info->speed = mode & LINK_SPEED_MASK;
        info->full_duplex = mode & LINK_DUPLEX_MASK;

        status = wb_stop(info);

        if ((mode & LINK_DUPLEX_MASK) == LINK_FULL_DUPLEX)
                configFlags |= WB_NETCFG_FULLDUPLEX;

        if (info->speed == LINK_SPEED_100_MBIT)
                configFlags |= WB_NETCFG_100MBPS;

        write32(cfgAddress, configFlags);

        if (status == B_OK)
                WB_SETBIT(cfgAddress, WB_NETCFG_TX_ON|WB_NETCFG_RX_ON);
}