/* Copyright (c) 2014 Broadcom Corporation
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "flowring.h"

#include <threads.h>

#include "brcmu_utils.h"
#include "bus.h"
#include "common.h"
#include "core.h"
#include "debug.h"
#include "device.h"
#include "linuxisms.h"
#include "msgbuf.h"
#include "netbuf.h"
#include "proto.h"

#define BRCMF_FLOWRING_HIGH 1024
#define BRCMF_FLOWRING_LOW (BRCMF_FLOWRING_HIGH - 256)
#define BRCMF_FLOWRING_INVALID_IFIDX 0xff

#define BRCMF_FLOWRING_HASH_AP(da, fifo, ifidx) (da[5] * 2 + fifo + ifidx * 16)
#define BRCMF_FLOWRING_HASH_STA(fifo, ifidx) (fifo + ifidx * 16)

static const uint8_t brcmf_flowring_prio2fifo[] = {1, 0, 0, 1, 2, 2, 3, 3};

static bool brcmf_flowring_is_tdls_mac(struct brcmf_flowring* flow, uint8_t mac[ETH_ALEN]) {
    struct brcmf_flowring_tdls_entry* search;

    search = flow->tdls_entry;

    while (search) {
        if (memcmp(search->mac, mac, ETH_ALEN) == 0) {
            return true;
        }
        search = search->next;
    }

    return false;
}

uint32_t brcmf_flowring_lookup(struct brcmf_flowring* flow, uint8_t da[ETH_ALEN], uint8_t prio,
                               uint8_t ifidx) {
    struct brcmf_flowring_hash* hash;
    uint16_t hash_idx;
    uint32_t i;
    bool found;
    bool sta;
    uint8_t fifo;
    uint8_t* mac;

    fifo = brcmf_flowring_prio2fifo[prio];
    sta = (flow->addr_mode[ifidx] == ADDR_INDIRECT);
    mac = da;
    if ((!sta) && (address_is_multicast(da))) {
        mac = (uint8_t*)ALLFFMAC;
        fifo = 0;
    }
    if ((sta) && (flow->tdls_active) && (brcmf_flowring_is_tdls_mac(flow, da))) {
        sta = false;
    }
    hash_idx =
        sta ? BRCMF_FLOWRING_HASH_STA(fifo, ifidx) : BRCMF_FLOWRING_HASH_AP(mac, fifo, ifidx);
    hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
    found = false;
    hash = flow->hash;
    for (i = 0; i < BRCMF_FLOWRING_HASHSIZE; i++) {
        if ((sta || (memcmp(hash[hash_idx].mac, mac, ETH_ALEN) == 0)) &&
                (hash[hash_idx].fifo == fifo) && (hash[hash_idx].ifidx == ifidx)) {
            found = true;
            break;
        }
        hash_idx++;
        hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
    }
    if (found) {
        return hash[hash_idx].flowid;
    }

    return BRCMF_FLOWRING_INVALID_ID;
}

zx_status_t brcmf_flowring_create(struct brcmf_flowring* flow, uint8_t da[ETH_ALEN], uint8_t prio,
                                  uint8_t ifidx) {
    struct brcmf_flowring_ring* ring;
    struct brcmf_flowring_hash* hash;
    uint16_t hash_idx;
    uint32_t i;
    bool found;
    uint8_t fifo;
    bool sta;
    uint8_t* mac;

    fifo = brcmf_flowring_prio2fifo[prio];
    sta = (flow->addr_mode[ifidx] == ADDR_INDIRECT);
    mac = da;
    if ((!sta) && (address_is_multicast(da))) {
        mac = (uint8_t*)ALLFFMAC;
        fifo = 0;
    }
    if ((sta) && (flow->tdls_active) && (brcmf_flowring_is_tdls_mac(flow, da))) {
        sta = false;
    }
    hash_idx =
        sta ? BRCMF_FLOWRING_HASH_STA(fifo, ifidx) : BRCMF_FLOWRING_HASH_AP(mac, fifo, ifidx);
    hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
    found = false;
    hash = flow->hash;
    for (i = 0; i < BRCMF_FLOWRING_HASHSIZE; i++) {
        if ((hash[hash_idx].ifidx == BRCMF_FLOWRING_INVALID_IFIDX) &&
                (address_is_zero(hash[hash_idx].mac))) {
            found = true;
            break;
        }
        hash_idx++;
        hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
    }
    if (found) {
        for (i = 0; i < flow->nrofrings; i++) {
            if (flow->rings[i] == NULL) {
                break;
            }
        }
        if (i == flow->nrofrings) {
            return ZX_ERR_NO_MEMORY;
        }

        ring = calloc(1, sizeof(*ring));
        if (!ring) {
            return ZX_ERR_NO_MEMORY;
        }

        memcpy(hash[hash_idx].mac, mac, ETH_ALEN);
        hash[hash_idx].fifo = fifo;
        hash[hash_idx].ifidx = ifidx;
        hash[hash_idx].flowid = i;

        ring->hash_id = hash_idx;
        ring->status = RING_CLOSED;
        brcmf_netbuf_list_init(&ring->netbuf_list);
        flow->rings[i] = ring;

        return i;
    }
    return BRCMF_FLOWRING_INVALID_ID;
}

uint8_t brcmf_flowring_tid(struct brcmf_flowring* flow, uint16_t flowid) {
    struct brcmf_flowring_ring* ring;

    ring = flow->rings[flowid];

    return flow->hash[ring->hash_id].fifo;
}

static void brcmf_flowring_block(struct brcmf_flowring* flow, uint16_t flowid, bool blocked) {
    struct brcmf_flowring_ring* ring;
    struct brcmf_bus* bus_if;
    struct brcmf_pub* drvr;
    struct brcmf_if* ifp;
    bool currently_blocked;
    int i;
    uint8_t ifidx;

    //spin_lock_irqsave(&flow->block_lock, flags);
    pthread_mutex_lock(&irq_callback_lock);

    ring = flow->rings[flowid];
    if (ring->blocked == blocked) {
        //spin_unlock_irqrestore(&flow->block_lock, flags);
        pthread_mutex_unlock(&irq_callback_lock);
        return;
    }
    ifidx = brcmf_flowring_ifidx_get(flow, flowid);

    currently_blocked = false;
    for (i = 0; i < flow->nrofrings; i++) {
        if ((flow->rings[i]) && (i != flowid)) {
            ring = flow->rings[i];
            if ((ring->status == RING_OPEN) && (brcmf_flowring_ifidx_get(flow, i) == ifidx)) {
                if (ring->blocked) {
                    currently_blocked = true;
                    break;
                }
            }
        }
    }
    flow->rings[flowid]->blocked = blocked;
    if (currently_blocked) {
        //spin_unlock_irqrestore(&flow->block_lock, flags);
        pthread_mutex_unlock(&irq_callback_lock);
        return;
    }

    bus_if = dev_to_bus(flow->dev);
    drvr = bus_if->drvr;
    ifp = brcmf_get_ifp(drvr, ifidx);
    brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_FLOW, blocked);

    //spin_unlock_irqrestore(&flow->block_lock, flags);
    pthread_mutex_unlock(&irq_callback_lock);
}

void brcmf_flowring_delete(struct brcmf_flowring* flow, uint16_t flowid) {
    struct brcmf_bus* bus_if = dev_to_bus(flow->dev);
    struct brcmf_flowring_ring* ring;
    struct brcmf_if* ifp;
    uint16_t hash_idx;
    uint8_t ifidx;
    struct brcmf_netbuf* netbuf;

    ring = flow->rings[flowid];
    if (!ring) {
        return;
    }

    ifidx = brcmf_flowring_ifidx_get(flow, flowid);
    ifp = brcmf_get_ifp(bus_if->drvr, ifidx);

    brcmf_flowring_block(flow, flowid, false);
    hash_idx = ring->hash_id;
    flow->hash[hash_idx].ifidx = BRCMF_FLOWRING_INVALID_IFIDX;
    fill_with_zero_addr(flow->hash[hash_idx].mac);
    flow->rings[flowid] = NULL;

    netbuf = brcmf_netbuf_list_remove_head(&ring->netbuf_list);
    while (netbuf) {
        brcmf_txfinalize(ifp, netbuf, false);
        netbuf = brcmf_netbuf_list_remove_head(&ring->netbuf_list);
    }

    free(ring);
}

uint32_t brcmf_flowring_enqueue(struct brcmf_flowring* flow, uint16_t flowid,
                                struct brcmf_netbuf* netbuf) {
    struct brcmf_flowring_ring* ring;

    ring = flow->rings[flowid];

    brcmf_netbuf_list_add_tail(&ring->netbuf_list, netbuf);

    if (!ring->blocked && (brcmf_netbuf_list_length(&ring->netbuf_list) > BRCMF_FLOWRING_HIGH)) {
        brcmf_flowring_block(flow, flowid, true);
        brcmf_dbg(MSGBUF, "Flowcontrol: BLOCK for ring %d\n", flowid);
        /* To prevent (work around) possible race condition, check
         * queue len again. It is also possible to use locking to
         * protect, but that is undesirable for every enqueue and
         * dequeue. This simple check will solve a possible race
         * condition if it occurs.
         */
        if (brcmf_netbuf_list_length(&ring->netbuf_list) < BRCMF_FLOWRING_LOW) {
            brcmf_flowring_block(flow, flowid, false);
        }
    }
    return brcmf_netbuf_list_length(&ring->netbuf_list);
}

struct brcmf_netbuf* brcmf_flowring_dequeue(struct brcmf_flowring* flow, uint16_t flowid) {
    struct brcmf_flowring_ring* ring;
    struct brcmf_netbuf* netbuf;

    ring = flow->rings[flowid];
    if (ring->status != RING_OPEN) {
        return NULL;
    }

    netbuf = brcmf_netbuf_list_remove_head(&ring->netbuf_list);

    if (ring->blocked && (brcmf_netbuf_list_length(&ring->netbuf_list) < BRCMF_FLOWRING_LOW)) {
        brcmf_flowring_block(flow, flowid, false);
        brcmf_dbg(MSGBUF, "Flowcontrol: OPEN for ring %d\n", flowid);
    }

    return netbuf;
}

void brcmf_flowring_reinsert(struct brcmf_flowring* flow, uint16_t flowid,
                             struct brcmf_netbuf* netbuf) {
    struct brcmf_flowring_ring* ring;

    ring = flow->rings[flowid];

    brcmf_netbuf_list_add_head(&ring->netbuf_list, netbuf);
}

uint32_t brcmf_flowring_qlen(struct brcmf_flowring* flow, uint16_t flowid) {
    struct brcmf_flowring_ring* ring;

    ring = flow->rings[flowid];
    if (!ring) {
        return 0;
    }

    if (ring->status != RING_OPEN) {
        return 0;
    }

    return brcmf_netbuf_list_length(&ring->netbuf_list);
}

void brcmf_flowring_open(struct brcmf_flowring* flow, uint16_t flowid) {
    struct brcmf_flowring_ring* ring;

    ring = flow->rings[flowid];
    if (!ring) {
        brcmf_err("Ring NULL, for flowid %d\n", flowid);
        return;
    }

    ring->status = RING_OPEN;
}

uint8_t brcmf_flowring_ifidx_get(struct brcmf_flowring* flow, uint16_t flowid) {
    struct brcmf_flowring_ring* ring;
    uint16_t hash_idx;

    ring = flow->rings[flowid];
    hash_idx = ring->hash_id;

    return flow->hash[hash_idx].ifidx;
}

struct brcmf_flowring* brcmf_flowring_attach(struct brcmf_device* dev, uint16_t nrofrings) {
    struct brcmf_flowring* flow;
    uint32_t i;

    flow = calloc(1, sizeof(*flow));
    if (flow) {
        flow->dev = dev;
        flow->nrofrings = nrofrings;
        //spin_lock_init(&flow->block_lock);
        for (i = 0; i < countof(flow->addr_mode); i++) {
            flow->addr_mode[i] = ADDR_INDIRECT;
        }
        for (i = 0; i < countof(flow->hash); i++) {
            flow->hash[i].ifidx = BRCMF_FLOWRING_INVALID_IFIDX;
        }
        flow->rings = calloc(nrofrings, sizeof(*flow->rings));
        if (!flow->rings) {
            free(flow);
            flow = NULL;
        }
    }

    return flow;
}

void brcmf_flowring_detach(struct brcmf_flowring* flow) {
    struct brcmf_bus* bus_if = dev_to_bus(flow->dev);
    struct brcmf_pub* drvr = bus_if->drvr;
    struct brcmf_flowring_tdls_entry* search;
    struct brcmf_flowring_tdls_entry* remove;
    uint16_t flowid;

    for (flowid = 0; flowid < flow->nrofrings; flowid++) {
        if (flow->rings[flowid]) {
            brcmf_msgbuf_delete_flowring(drvr, flowid);
        }
    }

    search = flow->tdls_entry;
    while (search) {
        remove = search;
        search = search->next;
        free(remove);
    }
    free(flow->rings);
    free(flow);
}

void brcmf_flowring_configure_addr_mode(struct brcmf_flowring* flow, int ifidx,
                                        enum proto_addr_mode addr_mode) {
    struct brcmf_bus* bus_if = dev_to_bus(flow->dev);
    struct brcmf_pub* drvr = bus_if->drvr;
    uint32_t i;
    uint16_t flowid;

    if (flow->addr_mode[ifidx] != addr_mode) {
        for (i = 0; i < countof(flow->hash); i++) {
            if (flow->hash[i].ifidx == ifidx) {
                flowid = flow->hash[i].flowid;
                if (flow->rings[flowid]->status != RING_OPEN) {
                    continue;
                }
                flow->rings[flowid]->status = RING_CLOSING;
                brcmf_msgbuf_delete_flowring(drvr, flowid);
            }
        }
        flow->addr_mode[ifidx] = addr_mode;
    }
}

void brcmf_flowring_delete_peer(struct brcmf_flowring* flow, int ifidx, uint8_t peer[ETH_ALEN]) {
    struct brcmf_bus* bus_if = dev_to_bus(flow->dev);
    struct brcmf_pub* drvr = bus_if->drvr;
    struct brcmf_flowring_hash* hash;
    struct brcmf_flowring_tdls_entry* prev;
    struct brcmf_flowring_tdls_entry* search;
    uint32_t i;
    uint16_t flowid;
    bool sta;

    sta = (flow->addr_mode[ifidx] == ADDR_INDIRECT);

    search = flow->tdls_entry;
    prev = NULL;
    while (search) {
        if (memcmp(search->mac, peer, ETH_ALEN) == 0) {
            sta = false;
            break;
        }
        prev = search;
        search = search->next;
    }

    hash = flow->hash;
    for (i = 0; i < BRCMF_FLOWRING_HASHSIZE; i++) {
        if ((sta || (memcmp(hash[i].mac, peer, ETH_ALEN) == 0)) && (hash[i].ifidx == ifidx)) {
            flowid = flow->hash[i].flowid;
            if (flow->rings[flowid]->status == RING_OPEN) {
                flow->rings[flowid]->status = RING_CLOSING;
                brcmf_msgbuf_delete_flowring(drvr, flowid);
            }
        }
    }

    if (search) {
        if (prev) {
            prev->next = search->next;
        } else {
            flow->tdls_entry = search->next;
        }
        free(search);
        if (flow->tdls_entry == NULL) {
            flow->tdls_active = false;
        }
    }
}

void brcmf_flowring_add_tdls_peer(struct brcmf_flowring* flow, int ifidx, uint8_t peer[ETH_ALEN]) {
    struct brcmf_flowring_tdls_entry* tdls_entry;
    struct brcmf_flowring_tdls_entry* search;

    tdls_entry = calloc(1, sizeof(*tdls_entry));
    if (tdls_entry == NULL) {
        return;
    }

    memcpy(tdls_entry->mac, peer, ETH_ALEN);
    tdls_entry->next = NULL;
    if (flow->tdls_entry == NULL) {
        flow->tdls_entry = tdls_entry;
    } else {
        search = flow->tdls_entry;
        if (memcmp(search->mac, peer, ETH_ALEN) == 0) {
            goto free_entry;
        }
        while (search->next) {
            search = search->next;
            if (memcmp(search->mac, peer, ETH_ALEN) == 0) {
                goto free_entry;
            }
        }
        search->next = tdls_entry;
    }

    flow->tdls_active = true;
    return;

free_entry:
    free(tdls_entry);
}