#ifdef __RTOS__
#include <linux/types.h>
#include <linux/unaligned.h>
#include <linux/bitops.h>
#include <linux/jiffies.h>
#include <linux/string.h>
#include <linux/mutex.h>
#include <linux/spinlock.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/completion.h>
#include <linux/rcu.h>
#include <linux/semaphore.h>
#include <linux/timer.h>

#else
#include <linux/version.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/firmware.h>
#include <linux/workqueue.h>
#include <linux/wireless.h>
#include <linux/etherdevice.h>
#include <linux/version.h>
#include <linux/rtnetlink.h>
#endif

#include "hgicf.h"
#include "ctrl.h"
#include "cfg.h"
#include "event.h"

static int txq_size = 1024;
static char *conf_file = "/etc/hgicf.conf";
static char *fw_file = "hgicf.bin";
static int if_test = 0;
static int soft_fc = 1;
static int no_bootdl = 0;
static int qc_mode = 0;
static char *ifname =  "hg%d";
static hgic_init_cb  init_cb = NULL;
#ifdef __RTOS__
static hgic_event_cb event_cb = NULL;
#endif

#define TXWND_INIT_VAL (2)
#define MATCH_NDEV(fwidx,hg) ((fwidx) == HGIC_WDEV_ID_STA ? (hg->sta ? hg->sta->ndev : NULL) : \
                              (hg->ap ? hg->ap->ndev : NULL))

#ifdef __RTOS__
static int   iface_cnt  = 1;
void dev_queue_xmit(struct sk_buff *skb)
{
    struct net_device *ndev = skb->dev;
    if (ndev) {
        ndev->netdev_ops->ndo_start_xmit(skb, ndev);
    } else {
        kfree_skb(skb);
    }
}
#endif

u16 hgicf_data_cookie(struct hgicf_wdev *hg)
{
    unsigned long flags;
    uint16_t cookie = 0;

    spin_lock_irqsave(&hg->lock, flags);
    cookie = hg->data_cookie++;
    spin_unlock_irqrestore(&hg->lock, flags);
    return cookie;
}

void hgicf_load_config(struct hgicf_wdev *hg)
{
#ifndef __RTOS__
    struct file *fp = NULL;
    struct iwreq wrqin;
    struct net_device *ndev = NULL;
    ssize_t ret = 0;
    unsigned long long __maybe_unused offset = 0 ;
    char *conf = kzalloc(2048, GFP_KERNEL);
    char *ptr, *str;

    if (hg->sta) {ndev = hg->sta->ndev; }
    else if (hg->ap) {ndev = hg->ap->ndev; }
    else {
        hgic_err("No netdev!! \r\n");
        goto __out;
    }

    fp = filp_open(conf_file, O_RDONLY, 0);
    if (!IS_ERR(fp) && conf) {
        ret = _KERNEL_READ(fp, conf, 2048, &offset);
        str = conf;

        hgic_fwctrl_close_dev(&(hg->ctrl));
        while (str) {
            ptr = strstr(str, "\r\n");
            if (ptr) {
                *ptr = 0;
                ptr += 2;
            } else {
                ptr = strstr(str, "\n");
                if (ptr) { *ptr++ = 0;}
            }
            wrqin.u.data.length = strlen(str);
            if (wrqin.u.data.length > 0) {
                hgic_dbg("param: [%s]\r\n", str);
                wrqin.u.data.pointer = str;
                ret = hgicf_ioctl_set_proc(ndev, &wrqin);
                if (ret < 0) {
                    hgic_err("invalid param:[%s]\r\n", str);
                }
            }
            str = ptr;
        }
        hgic_fwctrl_open_dev(&(hg->ctrl));
    }

__out:
    if (!IS_ERR(fp)) { filp_close(fp, NULL); }
    if (conf) { kfree(conf); }
#endif
}

static int hgicf_netif_open(struct net_device *dev)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (!test_bit(HGICF_DEV_FLAGS_RUNNING, &vif->hg->flags)) {
        return 0;
    }
    vif->hg->radio_off = 0;
    return hgic_fwctrl_open_dev(&(vif->hg->ctrl));
}

static int hgicf_netif_stop(struct net_device *dev)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (!test_bit(HGICF_DEV_FLAGS_RUNNING, &vif->hg->flags)) {
        return 0;
    }
    vif->hg->radio_off = 1;
    return hgic_fwctrl_close_dev(&(vif->hg->ctrl));
}

static void hgicf_netif_uninit(struct net_device *dev)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (!test_bit(HGICF_DEV_FLAGS_RUNNING, &vif->hg->flags)) {
        return;
    }
}

static netdev_tx_t hgicf_netif_xmit(struct sk_buff *skb, struct net_device *dev)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    struct hgic_frm_hdr2 *hdr = NULL;
    u8 pad = ((ulong)skb->data & 0x3) ? (4 - ((ulong)skb->data & 0x3)) : 0;

    if (!test_bit(HGICF_DEV_FLAGS_RUNNING, &vif->hg->flags) ||
        (vif->hg->tx_dataq.qlen > txq_size) ||
        test_bit(HGIC_BUS_FLAGS_SLEEP, &vif->hg->bus->flags)) {
        dev_kfree_skb(skb);
        return NETDEV_TX_OK;
    }

#ifndef __RTOS__
    if (skb_headroom(skb) < sizeof(struct hgic_frm_hdr2)) {
        struct sk_buff *nskb = skb_copy_expand(skb, skb->dev->needed_headroom,
                                               skb->dev->needed_tailroom, GFP_KERNEL);
        dev_kfree_skb(skb);
        if (nskb == NULL) {
            return NETDEV_TX_OK;
        }
        skb = nskb;
        pad = ((ulong)skb->data & 0x3) ? (4 - ((ulong)skb->data & 0x3)) : 0;
    }
#endif

    hdr = (struct hgic_frm_hdr2 *)skb_push(skb, sizeof(struct hgic_frm_hdr2) + pad);
    hdr->hdr.ifidx  = vif->fwifidx;
    hdr->hdr.length = skb->len;
    hdr->hdr.magic  = HGIC_HDR_TX_MAGIC;
    hdr->hdr.type   = HGIC_HDR_TYPE_FRM2;
    hdr->hdr.flags  = pad;
    hdr->hdr.cookie = hgicf_data_cookie(vif->hg);
    skb_queue_tail(&vif->hg->tx_dataq, skb);
    queue_work(vif->hg->tx_wq, &vif->hg->tx_work);
    return NETDEV_TX_OK;
}

static int hgicf_netif_change_mac(struct net_device *dev, void *addr)
{
    int ret = 0;
#ifdef __RTOS__
    ret = hgicf_ioctl(dev, HGIC_CMD_SET_MAC, addr, 0);
#else
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    struct sockaddr  *sa  = (struct sockaddr *)addr;

    if (!test_bit(HGICF_DEV_FLAGS_RUNNING, &vif->hg->flags)) {
        return 0;
    }
    ret = hgic_fwctrl_set_mac(&(vif->hg->ctrl), sa->sa_data);
    if (!ret) {
        ret = eth_mac_addr(dev, addr);
    }
#endif
    return ret;
}

static void hgicf_netif_set_multicast_list(struct net_device *dev)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (!test_bit(HGICF_DEV_FLAGS_RUNNING, &vif->hg->flags)) {
        return;
    }
}

#ifdef __RTOS__
static int hgicf_netif_ioctl(struct net_device *dev, u32 cmd, u32 param1, u32 param2)
{
    return hgicf_ioctl(dev, cmd, param1, param2);
}
int hgicf_cmd(char *ifname, unsigned int cmd, unsigned int param1, unsigned int param2)
{
    struct net_device *ndev = net_device_get_by_name(ifname);
    if (ndev == NULL) {
        return -ENODEV;
    }
    return hgicf_netif_ioctl(ndev, cmd, param1, param2);
}
#else
static int hgicf_netif_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (!test_bit(HGICF_DEV_FLAGS_RUNNING, &vif->hg->flags)) {
        return 0;
    }
    return hgicf_ioctl(dev, ifr, cmd);
}
#endif

static const struct net_device_ops hgicf_netif_ops = {
    .ndo_open            = hgicf_netif_open,
    .ndo_stop            = hgicf_netif_stop,
    .ndo_uninit          = hgicf_netif_uninit,
    .ndo_start_xmit      = hgicf_netif_xmit,
    .ndo_set_rx_mode     = hgicf_netif_set_multicast_list,
    .ndo_set_mac_address = hgicf_netif_change_mac,
    .ndo_do_ioctl        = hgicf_netif_ioctl,
};

static void hgicf_netif_setup(struct net_device *dev)
{
#ifdef __RTOS__
    dev->netdev_ops = &hgicf_netif_ops;
#else
    ether_setup(dev);
    dev->netdev_ops = &hgicf_netif_ops;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,15,0)
    dev->priv_destructor = free_netdev;
#else
    dev->destructor = free_netdev;
#endif
#endif
}

static int hgicf_request_txwnd(struct hgic_bus *bus)
{
    struct hgic_hdr *hdr = NULL;
    struct sk_buff *skb = dev_alloc_skb(sizeof(struct hgic_hdr) + 2);

    if (skb == NULL) { return -ENOMEM; }
    hdr = (struct hgic_hdr *)skb->data;
    hdr->magic = HGIC_HDR_TX_MAGIC;
    hdr->type  = HGIC_HDR_TYPE_SOFTFC;
    hdr->length = sizeof(struct hgic_hdr) + 2;
    hdr->ifidx = 0;
    hdr->flags = 0;
    hdr->cookie = 0;
    skb_put(skb, sizeof(struct hgic_hdr) + 2);
    return bus->tx_packet(bus, skb);
}

static int hgicf_check_txwnd(struct hgicf_wdev *hg)
{
    int err = 0;

    if (!hg->soft_fc || test_bit(HGIC_BUS_FLAGS_INBOOT, &hg->bus->flags)) {
        return 0;
    }

    while (hg->soft_fc && atomic_read(&hg->txwnd) < TXWND_INIT_VAL &&
           test_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags) &&
          !test_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags) &&
          !test_bit(HGICF_DEV_FLAGS_SUSPEND, &hg->flags) &&
          !test_bit(HGIC_BUS_FLAGS_INBOOT, &hg->bus->flags)) {

        err = hgicf_request_txwnd(hg->bus);
        if (!err) {
            wait_for_completion_timeout(&hg->txwnd_cp, msecs_to_jiffies(100));
        }
        
        if(atomic_read(&hg->txwnd) < TXWND_INIT_VAL) 
            msleep(10);
    }

    if (!hg->soft_fc || test_bit(HGIC_BUS_FLAGS_INBOOT, &hg->bus->flags)) {
        return 0;
    }

    if (atomic_read(&hg->txwnd) < TXWND_INIT_VAL) {
        return -1;
    } else {
        atomic_dec(&hg->txwnd);
    }

    return 0;
}

static void hgicf_test_work(struct work_struct *work)
{
    int ret    = 0;
    u32 diff_jiff = 0;
    struct hgicf_wdev *hg  = NULL;
    struct sk_buff    *skb = NULL;
    struct hgic_frm_hdr *frmhdr = NULL;

    printk("start if test ...\r\n");
    hg = container_of(work, struct hgicf_wdev, test_work);
    hg->test_jiff = jiffies;

    //set_bit(HGIC_BUS_FLAGS_DISABLE_REINIT, &hg->bus->flags);
    while (test_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags)) {
        if (time_after(jiffies, hg->test_jiff + msecs_to_jiffies(5000))) {
            diff_jiff = jiffies_to_msecs(jiffies - hg->test_jiff);
            diff_jiff /= 1000;
            if (diff_jiff == 0) { diff_jiff = 0xffff; }
            printk("HGIC IF TEST: tx:%d KB/s, rx:%d KB/s (%d %d %d)\r\n",
                   (hg->test_tx_len / 1024) / diff_jiff,
                   (hg->test_rx_len / 1024) / diff_jiff,
                   hg->test_tx_len, hg->test_rx_len, diff_jiff);
            hg->test_rx_len = 0;
            hg->test_tx_len = 0;
            hg->test_jiff = jiffies;
        }

        skb = dev_alloc_skb(1500 + hg->bus->drv_tx_headroom);
        if (skb) {
            skb_reserve(skb, hg->bus->drv_tx_headroom);
            frmhdr = (struct hgic_frm_hdr *)skb->data;
            frmhdr->hdr.magic  = HGIC_HDR_TX_MAGIC;
            frmhdr->hdr.type   = (hg->if_test == 1 ? HGIC_HDR_TYPE_TEST : HGIC_HDR_TYPE_TEST2);
            frmhdr->hdr.length = 1500;
            frmhdr->hdr.ifidx  = 0;
            frmhdr->hdr.cookie = hgicf_data_cookie(hg);
            if(hg->if_test == 3) memset(skb->data+8, 0xAA, 1500-8);
            skb_put(skb, 1500);
            while (test_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags) && hgicf_check_txwnd(hg)) {
                msleep(10);
            }
            ret = hg->bus->tx_packet(hg->bus, skb);
            if (ret) {
                msleep(10);
            }
        } else {
            msleep(10);
        }
    }
    printk("if test stop!\r\n");
}

static void hgicf_tx_work(struct work_struct *work)
{
    struct sk_buff    *skb = NULL;
    struct hgicf_wdev *hg  = container_of(work, struct hgicf_wdev, tx_work);
    struct hgic_hdr   *hdr = NULL;

    //hgic_dbg("Enter\n");
_CTRLQ_TX:
    while (!skb_queue_empty(&hg->ctrl.txq)) {
        if (test_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags) ||
           !test_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags)) {
            hgic_clear_queue(&hg->ctrl.txq);
            goto _CTRLQ_TX;
        }

        if (hgicf_check_txwnd(hg)) {
            msleep(10);
            continue;
        }

        skb = skb_dequeue(&hg->ctrl.txq);
        if(skb){
            hdr = (struct hgic_hdr *)skb->data;
            switch(hdr->type){
                case HGIC_HDR_TYPE_BOOTDL:
                    break;
                case HGIC_HDR_TYPE_BOOTDL_DATA:
                    skb_pull(skb, sizeof(struct hgic_bootdl_cmd_hdr));
                    break;
                default:
                    if(test_bit(HGIC_BUS_FLAGS_INBOOT, &hg->bus->flags)){
                        kfree_skb(skb);
                        skb = NULL;
                    }
                    break;
            }
        }

        if(skb){
            hg->bus->tx_packet(hg->bus, skb);
        }
    }

    while (!skb_queue_empty(&hg->tx_dataq) && 
            test_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags) &&
           !test_bit(HGICF_DEV_FLAGS_SUSPEND, &hg->flags)) {
           
        if (test_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags) || 
            test_bit(HGIC_BUS_FLAGS_INBOOT, &hg->bus->flags)) {
            hgic_clear_queue(&hg->tx_dataq);
            goto _CTRLQ_TX;
        }

        if (hgicf_check_txwnd(hg)) {
            msleep(10);
            goto _CTRLQ_TX;
        }

        skb = skb_dequeue(&hg->tx_dataq);
        hg->bus->tx_packet(hg->bus, skb);
        if (!skb_queue_empty(&hg->ctrl.txq)) {
            goto _CTRLQ_TX;
        }
    }
    //hgic_dbg("Leave\n");
}

static struct hgicf_vif *hgicf_create_iface(struct hgicf_wdev *hg)
{
    int ret = 0;
    struct net_device *ndev = NULL;
    struct hgicf_vif  *vif  = NULL;

    hgic_dbg("Enter\n");
    ndev = ALLOC_NETDEV_MQS(sizeof(struct hgicf_vif), ifname, hgicf_netif_setup, 1, 1);
    if (!ndev) {
        hgic_err("%s: alloc_netdev_mqs failed\n", __func__);
        return NULL;
    }
    vif = (struct hgicf_vif *)netdev_priv(ndev);
    vif->ndev  = ndev;
    vif->hg    = hg;
    vif->state = 0;
    ndev->needed_headroom += (hg->bus->drv_tx_headroom + sizeof(struct hgic_frm_hdr2));
    memcpy(ndev->dev_addr, hg->fwinfo.mac, ETH_ALEN);
    ret = register_netdev(ndev);
    if (ret) {
        free_netdev(ndev);
        return NULL;
    }
#ifndef __RTOS__
    rtnl_lock();
    DEV_OPEN(ndev);
    rtnl_unlock();
#endif
    return vif;
}

static int hgicf_rx_data(void *hgobj, struct sk_buff *skb, int len)
{
    int i = 0;
    struct hgic_frm_hdr2  *hdr = NULL;
    struct hgicf_wdev     *hg  = hgobj;

    hgic_skip_padding(skb);
    hdr = (struct hgic_frm_hdr2 *) skb->data;
    skb->dev = MATCH_NDEV(hdr->hdr.ifidx, hg);
    if (hdr->hdr.magic != HGIC_HDR_RX_MAGIC) {
        hgic_err("invalid magic unmber:%x\r\n", hdr->hdr.magic);
        hgic_print_hex(skb->data, 16);
        dev_kfree_skb_any(skb);
        return -1;
    }

    if (hdr->hdr.type != HGIC_HDR_TYPE_BOOTDL) {
        if (len < hdr->hdr.length) {
            hgic_err("invalid data length: %x/%x,cookie:%d\r\n", len, hdr->hdr.length, hdr->hdr.cookie);
            dev_kfree_skb_any(skb);
            return -1;
        }
    }

    skb_put(skb, len > hdr->hdr.length ? hdr->hdr.length : len);
    switch (hdr->hdr.type) {
        case HGIC_HDR_TYPE_FRM2:
            hg->last_rx = jiffies;
            if (skb->dev == NULL || hg->if_test) {
                dev_kfree_skb_any(skb);
                break;
            }
            skb_pull(skb, sizeof(struct hgic_frm_hdr2));
            skb->protocol = eth_type_trans(skb, skb->dev);
            if (in_interrupt()) {
                netif_rx(skb);
            } else {
                netif_rx_ni(skb);
            }
            break;
        case HGIC_HDR_TYPE_CMD:
        case HGIC_HDR_TYPE_CMD2:
        case HGIC_HDR_TYPE_EVENT:
        case HGIC_HDR_TYPE_EVENT2:
        case HGIC_HDR_TYPE_OTA:
        case HGIC_HDR_TYPE_BOOTDL:
            if (hg->if_test) {
                dev_kfree_skb_any(skb);
                break;
            }
            hgic_fwctrl_rx(&hg->ctrl, skb);
            break;
        case HGIC_HDR_TYPE_TEST2:
            hg->last_rx = jiffies;
            hg->test_rx_len += len;
            if (hg->if_test == 3) {
                for (i = 8; i < 1500; i++) {
                    if (skb->data[i] != 0xAA) {
                        printk("data verify fail\r\n");
                        break;
                    }
                }
            }
            dev_kfree_skb(skb);
            break;
        case HGIC_HDR_TYPE_SOFTFC:
            hg->last_rx = jiffies;
            atomic_set(&hg->txwnd, hdr->hdr.cookie);
            complete(&hg->txwnd_cp);
            dev_kfree_skb_any(skb);
            break;
        default:
            hgic_err("invalid data:%d\r\n", hdr->hdr.type);
            dev_kfree_skb_any(skb);
            break;
    }
    return 0;
}

static void hgicf_tx_complete(void *hgobj, struct sk_buff *skb, int success)
{
    struct hgicf_wdev *hg = hgobj;

    if (hg->if_test) {
        hg->test_tx_len += skb->len;
    }
    dev_kfree_skb_any(skb);
    if (!success) {
        hgic_err("tx failed\r\n");
    }
}

static int hgicf_download_fw(struct hgicf_wdev *hg)
{
    int err = -1;
    int retry = 10;
    int status  = -1;

    hgic_dbg("Enter\n");
    if (no_bootdl || qc_mode) { status = STATE_FW; }

    set_bit(HGIC_BUS_FLAGS_INBOOT, &hg->bus->flags);
    while (status != STATE_FW && retry-- > 0 && err) {
        status = hgic_bootdl_cmd_enter(&hg->bootdl);
        if (status == STATE_BOOT) {
            err = hgic_bootdl_download(&hg->bootdl, fw_file);
        }
    }
    clear_bit(HGIC_BUS_FLAGS_INBOOT, &hg->bus->flags);

    if (status == STATE_BOOT && !err) {
        set_bit(HGICF_DEV_FLAGS_BOOTDL, &hg->flags);
        if (hg->bus->reinit && test_bit(HGIC_BUS_FLAGS_NOPOLL, &hg->bus->flags)) {
            msleep(100);
            retry = 4;
            if (test_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags) && !hg->bus->reinit(hg->bus)) {
                while (retry-- > 0 && (STATE_FW != status)) {
                    status = hgic_bootdl_cmd_enter(&hg->bootdl);
                }
            }
        }
    }

    if(!no_bootdl && hg->bus->reinit){
        mod_timer(&hg->alive_tmr, jiffies + msecs_to_jiffies(HGIC_ALIVE_TIMER*4));
    }
    return (status == STATE_FW);
}

static void hgicf_delay_init(struct work_struct *work)
{
    int ret = 0;
    u8  retry = 0;
    int conn_stat = 0;
    struct hgicf_wdev *hg  = container_of(work, struct hgicf_wdev, delay_init);

    hgic_dbg("Enter\n");
    while(!test_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags) && test_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags)){
        if((retry & 0xf) == 0){
            ret = hgicf_download_fw(hg);
            if(ret) break;
        }
        msleep(10);
        retry++;
    }

    if (ret) {
		clear_bit(HGICF_DEV_FLAGS_SUSPEND, &hg->flags);
        hg->last_rx = jiffies;
        hg->soft_fc = soft_fc;
        conn_stat = hgic_fwctrl_get_conn_state(&hg->ctrl);
#ifndef __RTOS__        
        hgic_fwctrl_get_dhcpc_result(&hg->ctrl, (u8 *)&hg->dhcpc, sizeof(hg->dhcpc));
#endif
        hgic_fwctrl_get_fwinfo(&hg->ctrl, &hg->fwinfo);
        printk("hgic fw info:%d.%d.%d.%d, svn version:%d, %pM, conn_state:%d\r\n",
               (hg->fwinfo.version >> 24) & 0xff, (hg->fwinfo.version >> 16) & 0xff,
               (hg->fwinfo.version >> 8) & 0xff, (hg->fwinfo.version & 0xff),
               hg->fwinfo.svn_version, hg->fwinfo.mac, conn_stat);
        if (!test_bit(HGICF_DEV_FLAGS_INITED, &hg->flags)) {
            hg->sta = hgicf_create_iface(hg);
            if (!hg->sta) {
                hgic_err("create iface fail, ret:%d\r\n", ret);
                return;
            }
            hg->sta->fwifidx  = HGIC_WDEV_ID_STA;
            hg->sta->hw_state = conn_stat;
            hgicf_create_procfs(hg);
            if (init_cb) { init_cb(0); }
            if (if_test) {
                hg->if_test = if_test;
                queue_work(hg->tx_wq, &hg->test_work);
            }
            set_bit(HGICF_DEV_FLAGS_INITED, &hg->flags);
        }
        if ((test_bit(HGICF_DEV_FLAGS_BOOTDL, &hg->flags) || conn_stat != HGICF_HW_CONNECTED) && !qc_mode) {
            hgicf_load_config(hg);
        }
    }
    hgic_dbg("Leave, ret=%d\n", ret);
}

static void hgicf_alive_work(struct work_struct *work)
{
    int retry  = 4;
    int status = -1;
    struct hgicf_wdev *hg  = container_of(work, struct hgicf_wdev, alive_work);
    
	//hgic_dbg("SLEEP:%d\r\n", test_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags));
    if(!test_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags)){
        if(time_after(jiffies, hg->last_rx + msecs_to_jiffies(HGIC_ALIVE_TIMER))){
			//hgic_dbg("detect device status ...\r\n");
            while(retry-- > 0 && status != STATE_FW){
                status = hgic_bootdl_cmd_enter(&hg->bootdl);
            }
            if (status != STATE_FW) {
                hgic_dbg("need reload firmware ...\r\n");
                hg->soft_fc = 0;
                set_bit(HGICF_DEV_FLAGS_SUSPEND, &hg->flags);
                hgic_clear_queue(&hg->ctrl.txq);
                hgic_clear_queue(&hg->tx_dataq);
                hg->bus->reinit(hg->bus);
                schedule_work(&hg->delay_init);
            }
        }
    }
	//hgic_dbg("next detect after %d sec.\r\n", HGIC_ALIVE_TIMER);
    mod_timer(&hg->alive_tmr, jiffies + msecs_to_jiffies(HGIC_ALIVE_TIMER));
}

#ifdef __RTOS__
static void hgicf_alive_timer(unsigned long arg)
{
    struct hgicf_wdev *hg = (struct hgicf_wdev *) arg;
    schedule_work(&hg->alive_work);
}
#else
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0)
static void hgicf_alive_timer(struct timer_list *t)
{
    struct hgicf_wdev *hg = from_timer(hg, t, alive_tmr);
    schedule_work(&hg->alive_work);
}
#else
static void hgicf_alive_timer(unsigned long arg)
{
    struct hgicf_wdev *hg = (struct hgicf_wdev *) arg;
    schedule_work(&hg->alive_work);
}
#endif
#endif

void hgic_schedule(struct hgic_fwctrl *ctrl)
{
    struct hgicf_wdev *hg = container_of(ctrl, struct hgicf_wdev, ctrl);
    queue_work(hg->tx_wq, &hg->tx_work);
}

void hgic_rx_fw_event(struct hgic_fwctrl *ctrl, struct sk_buff *skb)
{
    struct hgicf_wdev *hg = container_of(ctrl, struct hgicf_wdev, ctrl);
    hgicf_rx_fw_event(hg, skb);
}

int hgic_core_remove(void *hgobj)
{
    struct hgicf_wdev *hg = hgobj;

    if (hg) {
        hgic_dbg("Enter\n");
        clear_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags);

        del_timer_sync(&hg->alive_tmr);
        cancel_work_sync(&hg->alive_work);
        cancel_work_sync(&hg->delay_init);
        hgic_dbg(" trace ...\r\n");
        if (hg->ap) {
            netif_stop_queue(hg->ap->ndev);
        }
        if (hg->sta) {
            netif_stop_queue(hg->sta->ndev);
        }
        hgicf_delete_procfs(hg);
        hgic_fwctrl_release(&hg->ctrl);
        hgic_dbg(" trace ...\r\n");
        hgic_ota_release(&hg->ota);
        hgic_dbg(" trace ...\r\n");
        hgic_bootdl_release(&hg->bootdl, 0);
        hgic_dbg(" trace ...\r\n");
        //while (!test_bit(HGICF_DEV_FLAGS_STOP, &hg->flags));
        cancel_work_sync(&hg->tx_work);
        hgic_dbg(" trace ...\r\n");
        cancel_work_sync(&hg->test_work);
        hgic_dbg(" trace ... %p\r\n", hg->ap);
        if (hg->ap) {
            unregister_netdev(hg->ap->ndev);
        }
        hgic_dbg(" trace ... %p\r\n", hg->sta);
        if (hg->sta) {
            unregister_netdev(hg->sta->ndev);
        }
        hgic_dbg(" trace ...\r\n");
        hgic_clear_queue(&hg->tx_dataq);
        hgic_dbg(" trace ...\r\n");
#ifdef __RTOS__
        skb_queue_head_deinit(&hg->tx_dataq);
#else
        hgic_clear_queue(&hg->custmgmt_q);
        hgic_clear_queue(&hg->dbginfo_q);
        hgic_clear_queue(&hg->cust_driverdata_q);
#endif
        hgic_dbg(" trace ...\r\n");
        if (hg->tx_wq) {
            flush_workqueue(hg->tx_wq);
            destroy_workqueue(hg->tx_wq);
        }
        hgic_dbg(" trace ...\r\n");
#ifdef __RTOS__
        deinit_completion(&hg->txwnd_cp);
        spin_lock_deinit(&hg->lock);
#endif
        if(hg->paired_stas)
            kfree(hg->paired_stas);
        kfree(hg);
        hgic_dbg("Leave\n");
    }
    return 0;
}
EXPORT_SYMBOL(hgic_core_remove);

int hgic_core_probe(void *dev, struct hgic_bus *bus)
{
    struct hgicf_wdev *hg = NULL;

    hgic_dbg("Enter,qc_mode=%d, no_bootdl=%d\n", qc_mode, no_bootdl);
    hg = kzalloc(sizeof(struct hgicf_wdev), GFP_KERNEL);
    if (hg) {
        memset(hg, 0, sizeof(struct hgicf_wdev));
        hg->ctrl.qc_mode = qc_mode;
        hg->bus = bus;
        hg->dev = dev;
        hg->dev_id = bus->dev_id;
        hgic_fwctrl_init(&hg->ctrl, dev);
        hgic_ota_init(&hg->ota, &hg->ctrl, &hg->fwinfo);
        spin_lock_init(&hg->lock);
        INIT_WORK(&hg->tx_work, hgicf_tx_work);
        INIT_WORK(&hg->delay_init, hgicf_delay_init);
        INIT_WORK(&hg->alive_work, hgicf_alive_work);
        INIT_WORK(&hg->test_work, hgicf_test_work);
        init_timer(&hg->alive_tmr);
        setup_timer(&hg->alive_tmr, hgicf_alive_timer, (unsigned long)hg);
        skb_queue_head_init(&hg->tx_dataq);
        init_completion(&hg->txwnd_cp);
        hgic_bootdl_init(&hg->bootdl, hg->bus, &hg->ctrl);
#ifndef __RTOS__
        skb_queue_head_init(&hg->custmgmt_q);
        skb_queue_head_init(&hg->dbginfo_q);
        skb_queue_head_init(&hg->cust_driverdata_q);
        sema_init(&hg->evtq.sema, 0);
#endif
        atomic_set(&hg->txwnd, TXWND_INIT_VAL);
        bus->rx_packet = hgicf_rx_data;
        bus->tx_complete = hgicf_tx_complete;
        bus->bus_priv = hg;
        hg->tx_wq = ALLOC_ORDERED_WORKQUEUE("hgicf_tx", 4096);
        if (!hg->tx_wq) {
            goto __failed;
        }
        set_bit(HGICF_DEV_FLAGS_RUNNING, &hg->flags);
        hgic_dbg("ok\n");
        return 0;
    }

__failed:
    bus->rx_packet = NULL;
    bus->tx_complete = NULL;
    bus->bus_priv = NULL;
    hgic_core_remove(hg);
    hgic_dbg("fail\n");
    return -1;
}
EXPORT_SYMBOL(hgic_core_probe);

#ifdef CONFIG_PM
int hgic_core_suspend(void *hgobj)
{
    int err = 0;
    struct hgicf_wdev *hg = (struct hgicf_wdev *)hgobj;
    err = hgic_fwctrl_enter_sleep(&hg->ctrl, 1);
    set_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags);
    return err;
}
EXPORT_SYMBOL(hgic_core_suspend);

int hgic_core_resume(void *hgobj)
{
    int err = 0;
    struct hgicf_wdev *hg = (struct hgicf_wdev *)hgobj;
    clear_bit(HGIC_BUS_FLAGS_SLEEP, &hg->bus->flags);
    if (hg->bus->reinit) {
        hg->bus->reinit(hg->bus);
    }
    err = hgic_fwctrl_enter_sleep(&hg->ctrl, 0);
    if(err) 
        hgic_err("exit sleep fail, ret=%d\r\n", err);
	schedule_work(&hg->alive_work);	
    return err;
}
EXPORT_SYMBOL(hgic_core_resume);
#endif

void hgic_core_probe_post(void *priv)
{
    struct hgicf_wdev *hg  = (struct hgicf_wdev *)priv;
    schedule_work(&hg->delay_init);
}
EXPORT_SYMBOL(hgic_core_probe_post);

#ifdef __RTOS__
int hgic_ifbus_reinit(const char *ifname)
{
    struct hgicf_vif *vif = NULL;
    struct net_device *ndev = net_device_get_by_name(ifname);
    if (ndev) {
        vif = (struct hgicf_vif *)netdev_priv(ndev);
        if (vif->hg->bus->reinit) {
            return vif->hg->bus->reinit(vif->hg->bus);
        }
    }
    return 0;
}
struct hgic_ota *hgic_devota(struct net_device *dev)
{
    struct hgicf_vif *vif = NULL;

    if (dev == NULL) {
        return NULL;
    }
    vif = (struct hgicf_vif *)netdev_priv(dev);
    return &(vif->hg->ota);
}
#endif

int __init hgicf_init(void)
{
    VERSOIN_SHOW("fmac");
#ifdef __RTOS__
    rcu_init();
    tasklet_core_init();
    net_device_init();
#else
#ifdef CONFIG_HGIC_USBIN
    hgic_usb_init();
#endif
#ifdef CONFIG_HGIC_SDIOIN
    hgic_sdio_init();
#endif
#endif
    hgic_leave();
    return 0;
}

void __exit hgicf_exit(void)
{
#ifndef __RTOS__
#ifdef CONFIG_HGIC_USBIN
    hgic_usb_exit();
#endif
#ifdef CONFIG_HGIC_SDIOIN
    hgic_sdio_exit();
#endif
#endif

#ifdef __RTOS__
    net_device_exit();
    tasklet_core_exit();
#endif
}

const char *hgic_param_ifname(const char *name)
{
    if (name) ifname = (char *)name;
    return ifname;
}
#ifdef __RTOS__
void hgic_param_iftest(int iftest)
{
    if_test = iftest;
}
char *hgic_param_fwfile(const char *fw)
{
    if (fw) fw_file = fw;
    return fw_file;
}
int hgic_param_ifcount(int count)
{
    if (count) iface_cnt = count;
    return iface_cnt;
}
void hgic_param_initcb(hgic_init_cb cb)
{
    init_cb = cb;
}
void hgic_param_eventcb(hgic_event_cb cb)
{
    event_cb = cb;
}
void hgic_param_bootdl(int enable)
{
    no_bootdl = !enable;
}
#endif

void hgicf_event(struct hgicf_wdev *hg, char *name, int event, int param1, int param2)
{
#ifdef __RTOS__
    if(event_cb)
        event_cb(name, event, param1, param2);
#else
    FWEVTQ_SET(&hg->evtq, event);
    up(&hg->evtq.sema);
#endif
}

module_init(hgicf_init);
module_exit(hgicf_exit);
module_param(txq_size, int, 0);
module_param(fw_file, charp, 0644);
module_param(if_test, int, 0);
module_param(soft_fc, int, 0);
module_param(ifname, charp, 0644);
module_param(conf_file, charp, 0644);
module_param(no_bootdl, int, 0);
module_param(qc_mode, int, 0);
MODULE_DESCRIPTION("HUGE-IC FullMAC Wireless Card Driver");
MODULE_AUTHOR("Dongyun");
MODULE_LICENSE("GPL");