hgicf/hgic_fmac/cfg.c

#include <linux/version.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/net.h>
#include <linux/etherdevice.h>
#include <linux/wireless.h>

#include "hgicf.h"
#include "cfg.h"

struct hgpriv_set {
    char *name;
    int (*set)(struct net_device *dev, char *args);
};
struct hgpriv_get {
    char *name;
    int (*get)(struct net_device *dev, struct iwreq *wrqin);
};

#define hgicf_pick_values(pick_type, str, array, size) do{\
        char *ptr = NULL;\
        if(str && strlen(str) > 0){\
            while ((ptr = strsep((char **)&str, ",")) != NULL) {\
                if (count >= size) break;\
                array[count++] = (pick_type)simple_strtol(ptr, 0, 10);\
            }\
        }\
    }while(0)

static int hgicf_copyfrom_iwreq(struct iwreq *wrqin, char *buf, int len)
{
    int ret = 0;
    if (len > 0) {
        memset(buf, 0, len);
        if (ACCESS_OK(VERIFY_READ, wrqin->u.data.pointer, wrqin->u.data.length)) {
            ret = copy_from_user(buf, wrqin->u.data.pointer, wrqin->u.data.length);
        } else {
            memcpy(buf, wrqin->u.data.pointer, wrqin->u.data.length);
        }
    }
    return ret;
}

static void hgicf_copyto_iwreq(struct iwreq *wrqin, char *buf, int len)
{
    if (len > 0) {
        if (ACCESS_OK(VERIFY_WRITE, wrqin->u.data.pointer, len)) {
            if (!__copy_to_user(wrqin->u.data.pointer, buf, len)){
                wrqin->u.data.length = (u16)len; 
            }
        } else {
            memset(wrqin->u.data.pointer, 0, len + 1);
            memcpy(wrqin->u.data.pointer, buf, len);
        }
    }
}

static int hgicf_ioctl_set_countryregion(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) {
        return -EINVAL;
    }
    return hgic_fwctrl_set_countryregion(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_ssid(struct net_device *dev, char *args)
{
    int ret = -1;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    ret = hgic_fwctrl_set_ssid(&(vif->hg->ctrl), args);
    if (!ret) {
        strcpy(vif->hw_ssid, args);
    }
    return ret;
}

static int hgicf_ioctl_set_bssid(struct net_device *dev, char *args)
{
    int ret = -1;
    u8  bssid[6];
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL || vif->fwifidx != HGIC_WDEV_ID_STA) {
        return -EINVAL;
    }
    hgic_pick_macaddr(args, bssid);
    ret =  hgic_fwctrl_set_bssid(&(vif->hg->ctrl), bssid);
    if (!ret) {
        memcpy(vif->hw_bssid, args, ETH_ALEN);
    }
    return ret;
}

static int hgicf_ioctl_set_channel(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) {
        return -EINVAL;
    }
    return hgic_fwctrl_set_channel(&(vif->hg->ctrl), simple_strtol(args, 0, 10));
}

static int hgicf_ioctl_set_bssid_filter(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_set_bssid_filter(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_rts_threshold(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) {
        return -EINVAL;
    }
    return hgic_fwctrl_set_rts_threshold(&(vif->hg->ctrl), simple_strtol(args, 0, 10));
}

static int hgicf_ioctl_set_frag_threshold(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) {
        return -EINVAL;
    }
    return hgic_fwctrl_set_frag_threshold(&(vif->hg->ctrl), simple_strtol(args, 0, 10));
}

static int hgicf_ioctl_set_key_mgmt(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_set_key_mgmt(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_wpa_psk(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_set_wpa_psk(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_reset_counter(struct net_device *dev, char *args)
{
    //struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    hgic_dbg("%s\r\n", args);
    return 0;
}

static int hgicf_ioctl_set_freq_range(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u32 vals[3] = {0, 0, 0};
    int count = 0;

    if (args == NULL || strlen(args) == 0) {
        return -EINVAL;
    }
    hgicf_pick_values(u32, args, vals, 3);
    if ((vals[0] < 7200 || vals[0] > 9300) ||
        (vals[1] < vals[0] || vals[1] > 9300) ||
        (vals[2] < 1 || vals[2] > 8)) {
        return -EINVAL;
    }
    return hgic_fwctrl_set_freq_range(&(vif->hg->ctrl), vals[0], vals[1], vals[2]);
}

static int hgicf_ioctl_set_bss_bw(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u8 bss_bw = (u8)simple_strtol(args, 0, 10);
    if (bss_bw != 1 && bss_bw != 2 && bss_bw != 4 && bss_bw != 8) {
        bss_bw = 8;
    }
    return hgic_fwctrl_set_bss_bw(&(vif->hg->ctrl), bss_bw);
}

static int hgicf_ioctl_set_tx_bw(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u8 tx_bw = (u8)simple_strtol(args, 0, 10);
    if (tx_bw != 1 && tx_bw != 2 && tx_bw != 4 && tx_bw != 8) {
        tx_bw = 0;
    }
    return hgic_fwctrl_set_tx_bw(&(vif->hg->ctrl), tx_bw);
}

static int hgicf_ioctl_set_tx_mcs(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u8 tx_mcs = (u8)simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_tx_mcs(&(vif->hg->ctrl), tx_mcs);
}

static int hgicf_ioctl_set_acs(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u16 vals[2] = {0, 0};
    int count = 0;

    if (args == NULL || strlen(args) == 0) {
        return -EINVAL;
    }
    hgicf_pick_values(u16, args, vals, 2);
    return hgic_fwctrl_set_acs(&(vif->hg->ctrl), vals[0], vals[1]);
}

static int hgicf_ioctl_set_bgrssi(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u8 rssi = (u8)simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_bgrssi(&(vif->hg->ctrl), rssi);
}

static int hgicf_ioctl_set_chan_list(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u16 vals[32] = {0};
    int count = 0;

    if (args == NULL || strlen(args) == 0) {
        return -EINVAL;
    }
    hgicf_pick_values(u16, args, vals, 32);
    return hgic_fwctrl_set_chan_list(&(vif->hg->ctrl), vals, count);
}

static int hgicf_ioctl_set_mode(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) {
        return -EINVAL;
    }
    return hgic_fwctrl_set_mode(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_paired_stas(struct net_device *dev, char *args)
{
    u8 *buf = NULL;
    int len = 0;
    int ret = 0, i = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL || strlen(args) == 0) {
        return -EINVAL;
    }
    len = ALIGN(strlen(args), 17);
    buf = kzalloc(len, GFP_KERNEL);
    if (buf == NULL) {
        return -ENOMEM;
    }
    while ((i + 1) * 17 <= len) {
        if (hgic_pick_macaddr(args + i * 17, buf + i * 6)) {
            i++;
        } else {
            break;
        }
    }
    //hgic_dbg("set paired stas:%s\r\n", args);
    ret = hgic_fwctrl_set_paired_stas(&(vif->hg->ctrl), buf, i * 6);
    kfree(buf);
    return ret;
}

static int hgicf_ioctl_set_pairing(struct net_device *dev, char *args)
{
    u8 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    enable = simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_pairing(&(vif->hg->ctrl), enable);
}

static int hgicf_ioctl_set_beacon_int(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u8 beacon_int = (u8)simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_beacon_int(&(vif->hg->ctrl), beacon_int);
}

static int hgicf_ioctl_set_radio_off(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    vif->hg->radio_off = (u8)simple_strtol(args, 0, 10);
    return hgic_fwctrl_radio_onoff(&(vif->hg->ctrl), !vif->hg->radio_off);    
}

static int hgicf_ioctl_join_group(struct net_device *dev, char *args)
{
    u8  addr[6];
    u32 aid = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    hgic_pick_macaddr(args, addr);
    aid = simple_strtol(args + 18, 0, 10);
    return  hgic_fwctrl_join_group(&(vif->hg->ctrl), addr, aid);
}

static int hgicf_ioctl_set_ethertype(struct net_device *dev, char *args)
{
    u16 type = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    type = simple_strtol(args, 0, 16);
    return  hgic_fwctrl_set_ethertype(&(vif->hg->ctrl), type);
}

static int hgicf_ioctl_set_txpower(struct net_device *dev, char *args)
{
    u16 type = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    type = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_txpower(&(vif->hg->ctrl), type);
}

static int hgicf_ioctl_set_aggcnt(struct net_device *dev, char *args)
{
    u8 aggcnt = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    aggcnt = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_agg_cnt(&(vif->hg->ctrl), aggcnt);
}
static int hgicf_ioctl_set_ps_connect(struct net_device *dev, char *args)
{
    int count = 0;
    u8 vals[2];
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    hgicf_pick_values(u8, args, vals, 2);
    return  hgic_fwctrl_set_ps_connect(&(vif->hg->ctrl), vals[0], vals[1]);
}

static int hgicf_ioctl_set_bss_max_idle(struct net_device *dev, char *args)
{
    u32 max_idle = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    max_idle = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_bss_max_idle(&(vif->hg->ctrl), max_idle);
}

static int hgicf_ioctl_set_dtim_period(struct net_device *dev, char *args)
{
    u32 period = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    period = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_dtim_period(&(vif->hg->ctrl), period);
}

static int hgicf_ioctl_set_wkio_mode(struct net_device *dev, char *args)
{
    u32 mode = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    mode = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_wkio_mode(&(vif->hg->ctrl), mode);
}

static int hgicf_ioctl_set_load_def(struct net_device *dev, char *args)
{
    u32 rst = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) {
        return -EINVAL;
    }
    rst = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_load_def(&(vif->hg->ctrl), rst);
}

static int hgicf_ioctl_set_disassoc_sta(struct net_device *dev, char *args)
{
    u8  addr[6];
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    hgic_pick_macaddr(args, addr);
    return  hgic_fwctrl_disassoc_sta(&(vif->hg->ctrl), addr);
}

static int hgicf_ioctl_set_ps_mode(struct net_device *dev, char *args)
{
    u32 mode = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    mode = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_ps_mode(&(vif->hg->ctrl), mode);
}

static int hgicf_ioctl_set_aplost_time(struct net_device *dev, char *args)
{
    u32 time = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    time = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_aplost_time(&(vif->hg->ctrl), time);
}

static int hgicf_ioctl_set_unpair(struct net_device *dev, char *args)
{
    u8  addr[6];
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    hgic_pick_macaddr(args, addr);
    return  hgic_fwctrl_unpair(&(vif->hg->ctrl), addr);
}

static int hgicf_ioctl_set_auto_chswitch(struct net_device *dev, char *args)
{
    u32 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    enable = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_auto_chswitch(&(vif->hg->ctrl), enable == 1);
}

static int hgicf_ioctl_set_mcast_key(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) {
        return -EINVAL;
    }
    return hgic_fwctrl_set_mcast_key(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_reassoc_wkhost(struct net_device *dev, char *args)
{
    u32 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    enable = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_reassoc_wkhost(&(vif->hg->ctrl), enable == 1);
}

static int hgicf_ioctl_set_wakeup_io(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u8 vals[2] = {0, 0};
    int count = 0;

    hgicf_pick_values(u8, args, vals, 2);
    return hgic_fwctrl_set_wakeup_io(&(vif->hg->ctrl), vals[0], vals[1]);
}

static int hgicf_ioctl_set_dbginfo_output(struct net_device *dev, char *args)
{
    u32 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args) {
        enable = simple_strtol(args, 0, 10);
    }
    return  hgic_fwctrl_set_dbginfo_output(&(vif->hg->ctrl), enable == 1);
}

static int hgicf_ioctl_set_sysdbg(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    if (args == NULL) { 
        return -EINVAL; 
    }
    return  hgic_fwctrl_set_sysdbg(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_primary_chan(struct net_device *dev, char *args)
{
    u32 chan = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    chan = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_primary_chan(&(vif->hg->ctrl), chan);
}

static int hgicf_ioctl_set_autosleep_time(struct net_device *dev, char *args)
{
    u32 time = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    time = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_autosleep_time(&(vif->hg->ctrl), time);
}

static int hgicf_ioctl_set_supper_pwr(struct net_device *dev, char *args)
{
    u32 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    enable = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_supper_pwr(&(vif->hg->ctrl), enable);
}

static int hgicf_ioctl_set_repeater_ssid(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_set_repeater_ssid(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_repeater_psk(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_set_repeater_psk(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_auto_save(struct net_device *dev, char *args)
{
    u32 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    enable = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_auto_save(&(vif->hg->ctrl), enable);
}
static int hgicf_ioctl_set_pair_autostop(struct net_device *dev, char *args)
{
    u32 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    enable = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_pair_autostop(&(vif->hg->ctrl), enable);
}
static int hgicf_ioctl_set_dcdc13v(struct net_device *dev, char *args)
{
    u32 enable = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    enable = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_dcdc13v(&(vif->hg->ctrl), enable);
}
static int hgicf_ioctl_set_acktmo(struct net_device *dev, char *args)
{
    u32 tmo = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    tmo = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_acktmo(&(vif->hg->ctrl), tmo);
}
static int hgicf_ioctl_set_pa_pwrctl_dis(struct net_device *dev, char *args)
{
    u32 dis = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    dis = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_pa_pwrctl_dis(&(vif->hg->ctrl), dis);
}
static int hgicf_ioctl_set_dhcpc(struct net_device *dev, char *args)
{
    u32 en = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    en = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_dhcpc(&(vif->hg->ctrl), en);
}
static int hgicf_ioctl_set_wkdata_save(struct net_device *dev, char *args)
{
    u32 en = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    en = simple_strtol(args, 0, 10);
    return  hgic_fwctrl_set_wkdata_save(&(vif->hg->ctrl), en);
}
static int hgicf_ioctl_set_mcast_txparam(struct net_device *dev, char *args)
{
    struct hgic_mcast_txparam txparam;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    u8 *vals = (u8 *)&txparam;
    int count = 0;

    if (args == NULL) {
        return -EINVAL;
    }
    hgicf_pick_values(u8, args, vals, 4);
    return hgic_fwctrl_set_mcast_txparam(&(vif->hg->ctrl), &txparam);
}

static int hgicf_ioctl_set_resetsta(struct net_device *dev, char *args)
{
    u8  addr[6];
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL || vif->fwifidx != HGIC_WDEV_ID_STA) {
        return -EINVAL;
    }
    hgic_pick_macaddr(args, addr);
    return hgic_fwctrl_reset_sta(&(vif->hg->ctrl), addr);
}

static int hgicf_ioctl_set_ant_auto(struct net_device *dev, char *args)
{
    u32 en = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    en = simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_ant_auto(&(vif->hg->ctrl), en);
}
static int hgicf_ioctl_select_ant(struct net_device *dev, char *args)
{
    u32 ant = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    ant = simple_strtol(args, 0, 10);
    return hgic_fwctrl_select_ant(&(vif->hg->ctrl), ant);
}
static int hgicf_ioctl_set_wkhost_reasons(struct net_device *dev, char *args)
{
    int count = 0;
    u8  reasons[33];
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    memset(reasons, 0, sizeof(reasons));
    hgicf_pick_values(u8, args, reasons, 32);
    return hgic_fwctrl_set_wkhost_reasons(&(vif->hg->ctrl), reasons, count + 1);
}

static int hgicf_ioctl_set_mac_filter(struct net_device *dev, char *args)
{
    u32 en = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    en = simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_mac_filter(&(vif->hg->ctrl), en);
}

static int hgicf_ioctl_set_atcmd(struct net_device *dev, char *args)
{
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_set_atcmd(&(vif->hg->ctrl), args);
}

static int hgicf_ioctl_set_roaming(struct net_device *dev, char *args)
{
    int count = 0;
    u8 vals[2];
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    hgicf_pick_values(u8, args, vals, 2);
    return hgic_fwctrl_set_roaming(&(vif->hg->ctrl), vals[0], vals[2]);
}

static int hgicf_ioctl_set_ap_hide(struct net_device *dev, char *args)
{
    u32 hide = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    hide = simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_ap_hide(&(vif->hg->ctrl), hide);
}

static int hgicf_ioctl_set_max_txcnt(struct net_device *dev, char *args)
{
    u32 txcnt = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    txcnt = simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_frm_tx_maxcnt(&(vif->hg->ctrl), txcnt);
}
static int hgicf_ioctl_set_assert_holdup(struct net_device *dev, char *args)
{
    u32 holdup = 0;
    struct hgicf_vif *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (args == NULL) {
        return -EINVAL;
    }
    holdup = simple_strtol(args, 0, 10);
    return hgic_fwctrl_set_assert_holdup(&(vif->hg->ctrl), holdup);
}

static struct hgpriv_set hgpriv_sets[] = {
    {"country_region",              hgicf_ioctl_set_countryregion},
    {"ssid",                        hgicf_ioctl_set_ssid},
    {"bssid",                       hgicf_ioctl_set_bssid},
    {"channel",                     hgicf_ioctl_set_channel},
    {"rts_threshold",               hgicf_ioctl_set_rts_threshold},
    {"frag_threshold",              hgicf_ioctl_set_frag_threshold},
    {"key_mgmt",                    hgicf_ioctl_set_key_mgmt},
    {"wpa_psk",                     hgicf_ioctl_set_wpa_psk},
    {"reset_counter",               hgicf_ioctl_reset_counter},
    {"bssid_filter",                hgicf_ioctl_set_bssid_filter},
    {"freq_range",                  hgicf_ioctl_set_freq_range},
    {"bss_bw",                      hgicf_ioctl_set_bss_bw},
    {"tx_bw",                       hgicf_ioctl_set_tx_bw},
    {"tx_mcs",                      hgicf_ioctl_set_tx_mcs},
    {"acs",                         hgicf_ioctl_set_acs},
    {"bgrssi",                      hgicf_ioctl_set_bgrssi},
    {"chan_list",                   hgicf_ioctl_set_chan_list},
    {"mode",                        hgicf_ioctl_set_mode},
    {"paired_stas",                 hgicf_ioctl_set_paired_stas},
    {"pairing",                     hgicf_ioctl_set_pairing},
    {"beacon_int",                  hgicf_ioctl_set_beacon_int},
    {"radio_off",                   hgicf_ioctl_set_radio_off},
    {"join_group",                  hgicf_ioctl_join_group},
    {"ether_type",                  hgicf_ioctl_set_ethertype},
    {"txpower",                     hgicf_ioctl_set_txpower},
    {"agg_cnt",                     hgicf_ioctl_set_aggcnt},
    {"ps_connect",                  hgicf_ioctl_set_ps_connect},
    {"bss_max_idle",                hgicf_ioctl_set_bss_max_idle},
    {"wkio_mode",                   hgicf_ioctl_set_wkio_mode},
    {"loaddef",                     hgicf_ioctl_set_load_def},
    {"disassoc_sta",                hgicf_ioctl_set_disassoc_sta},
    {"dtim_period",                 hgicf_ioctl_set_dtim_period},
    {"ps_mode",                     hgicf_ioctl_set_ps_mode},
    {"aplost_time",                 hgicf_ioctl_set_aplost_time},
    {"unpair",                      hgicf_ioctl_set_unpair},
    {"auto_chswitch",               hgicf_ioctl_set_auto_chswitch},
    {"mcast_key",                   hgicf_ioctl_set_mcast_key},
    {"reassoc_wkhost",              hgicf_ioctl_set_reassoc_wkhost},
    {"wakeup_io",                   hgicf_ioctl_set_wakeup_io},
    {"dbginfo",                     hgicf_ioctl_set_dbginfo_output},
    {"sysdbg",                      hgicf_ioctl_set_sysdbg},
    {"primary_chan",                hgicf_ioctl_set_primary_chan},
    {"autosleep_time",              hgicf_ioctl_set_autosleep_time},
    {"supper_pwr",                  hgicf_ioctl_set_supper_pwr},
    {"r_ssid",                      hgicf_ioctl_set_repeater_ssid},
    {"r_psk",                       hgicf_ioctl_set_repeater_psk},
    {"auto_save",                   hgicf_ioctl_set_auto_save},
    {"pair_autostop",               hgicf_ioctl_set_pair_autostop},
    {"dcdc13",                      hgicf_ioctl_set_dcdc13v},
    {"acktmo",                      hgicf_ioctl_set_acktmo},
    {"pa_pwrctl_dis",               hgicf_ioctl_set_pa_pwrctl_dis},
    {"dhcpc",                       hgicf_ioctl_set_dhcpc},
    {"wkdata_save",                 hgicf_ioctl_set_wkdata_save},
    {"mcast_txparam",               hgicf_ioctl_set_mcast_txparam},
    {"reset_sta",                   hgicf_ioctl_set_resetsta},
    {"ant_auto",                    hgicf_ioctl_set_ant_auto},
    {"ant_sel",                     hgicf_ioctl_select_ant},
    {"wkhost_reason",               hgicf_ioctl_set_wkhost_reasons},
    {"macfilter",                   hgicf_ioctl_set_mac_filter},
    {"atcmd",                       hgicf_ioctl_set_atcmd},
    {"roaming",                     hgicf_ioctl_set_roaming},
    {"ap_hide",                     hgicf_ioctl_set_ap_hide},
    {"max_txcnt",                   hgicf_ioctl_set_max_txcnt},
    {"assert_holdup",               hgicf_ioctl_set_assert_holdup},
    {NULL,}
};

int hgicf_ioctl_set_proc(struct net_device *dev, struct iwreq *wrqin)
{
    int ret = 0;
    char *field, *val;
    struct hgpriv_set *set = NULL;
    u8 *cmd = kmalloc(wrqin->u.data.length + 1, GFP_KERNEL);

    if (cmd == NULL){ 
        return -ENOMEM; 
    }

    ret = hgicf_copyfrom_iwreq(wrqin, cmd, wrqin->u.data.length + 1);
    //hgic_dbg("%s\r\n", cmd);
    while (!ret && (field = strsep((char **)&cmd, ";")) != NULL) {
        if (!*field) {
            continue;
        }

        if ((val = strchr(field, '=')) != NULL) {
            *val++ = 0;
        }

        for (set = hgpriv_sets; val && set->name; set++) {
            if (strcmp(field, set->name) == 0) {
                //printk("set [%s=%s]\r\n", set->name, val);
                ret = set->set(dev, val);
                break;
            }
        }

        if (set->name == NULL) {
            hgic_dbg("not support:%s=%s\r\n", field, val);
            ret = -1;
            break;
        }
    }

    kfree(cmd);
    return ret;
}

static int hgicf_ioctl_get_scan_list(struct net_device *dev, struct iwreq *wrqin)
{
    int ret = 0;
    int i = 0;
    int count = 0;
    int len = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    struct hgic_bss_info *bss = NULL;
    char *buf = kzalloc(1024, GFP_ATOMIC);
    char *print_buf = kzalloc(4096, GFP_ATOMIC);

    if (buf == NULL || print_buf == NULL) {
        if (buf) { kfree(buf); }
        if (print_buf) { kfree(print_buf); }
        return -ENOMEM;
    }

    ret = hgic_fwctrl_get_scan_list(&(vif->hg->ctrl), buf, 1024);
    if (ret > 0) {
        bss = (struct hgic_bss_info *)buf;
        count = ret / sizeof(struct hgic_bss_info);
        len += sprintf(print_buf + len, "\r\nBSSID            \tSSID      \tEncryption\tFrequence\tSignal\r\n");
        for (i = 0; i < count; i++) {
            len += sprintf(print_buf + len, "%pM\t%s\t%10s\t%10d\t%d\r\n",
                           bss[i].bssid, bss[i].ssid,
                           bss[i].encrypt ? (bss[i].encrypt == 1 ? "WPA" : "WPA2") : "NONE",
                           bss[i].freq, bss[i].signal);
        }
        wrqin->u.data.length = (u16)len;
    } else {
        len = 2;
    }
    hgicf_copyto_iwreq(wrqin, print_buf, len);
    kfree(buf);
    kfree(print_buf);
    return (0);
}

static int hgicf_ioctl_get_sta_list(struct net_device *dev, struct iwreq *wrqin)
{
    //int i = 0;
    int count = 0;
    int len = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    char *buf = kzalloc(1024, GFP_ATOMIC);
    char *print_buf = kzalloc(4096, GFP_ATOMIC);
    //char *ptr = buf;
    struct hgic_sta_info *sta = (struct hgic_sta_info *)buf;

    if (buf == NULL || print_buf == NULL) {
        if (buf) { kfree(buf); }
        if (print_buf) { kfree(print_buf); }
        return -ENOMEM;
    }

    count = hgic_fwctrl_get_sta_list(&(vif->hg->ctrl), (struct hgic_sta_info *)buf, (1024 / sizeof(struct hgic_sta_info)));
    if (count > 0) {
        len += sprintf(print_buf, "%d sta:\r\n", count);
        while (count-- > 0) {
            len += sprintf(print_buf + len, "aid:%d, %pM, ps:%d, rssi:%d, evm:%d\r\n", sta->aid, sta->addr, sta->ps, (s8)sta->rssi, (s8)sta->evm);
            sta++;
        }
        wrqin->u.data.length = (u16)len;
    } else {
        len = 2;
    }
    hgicf_copyto_iwreq(wrqin, print_buf, len);
    kfree(buf);
    kfree(print_buf);
    return (0);
}

static int hgicf_ioctl_get_ssid(struct net_device *dev, struct iwreq *wrqin)
{
    int len = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    char *buf = kzalloc(40, GFP_ATOMIC);

    if (buf == NULL) {
        return -ENOMEM;
    }
    len = hgic_fwctrl_get_ssid(&(vif->hg->ctrl), buf, 32);
    hgicf_copyto_iwreq(wrqin, buf, len);
    kfree(buf);
    return (0);
}

static int hgicf_ioctl_get_bssid(struct net_device *dev, struct iwreq *wrqin)
{
    int len = 0;
    char buf[24] = {0};
    char bssid[6];
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);

    len = hgic_fwctrl_get_bssid(&(vif->hg->ctrl), bssid);
    if (len == 6) { sprintf(buf, "%pM", bssid); }
    len = strlen(buf);
    hgicf_copyto_iwreq(wrqin, buf, len);
    return (0);
}

static int hgicf_ioctl_get_wpa_psk(struct net_device *dev, struct iwreq *wrqin)
{
    int len = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    char *buf = kzalloc(80, GFP_ATOMIC);

    if (buf == NULL) {
        return -ENOMEM;
    }
    len = hgic_fwctrl_get_wpapsk(&(vif->hg->ctrl), buf, 64);
    hgicf_copyto_iwreq(wrqin, buf, len);
    kfree(buf);
    return (0);
}

static int hgicf_ioctl_get_txpower(struct net_device *dev, struct iwreq *wrqin)
{
    char str[4];
    int txpower = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    txpower = hgic_fwctrl_get_txpower(&(vif->hg->ctrl));
    sprintf(str, "%d", txpower);
    hgicf_copyto_iwreq(wrqin, str, strlen(str));
    return (0);
}

static int hgicf_ioctl_get_bss_bw(struct net_device *dev, struct iwreq *wrqin)
{
    char str[4];
    int bss_bw = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    bss_bw = hgic_fwctrl_get_bss_bw(&(vif->hg->ctrl));
    sprintf(str, "%d", bss_bw);
    hgicf_copyto_iwreq(wrqin, str, strlen(str));
    return (0);
}

static int hgicf_ioctl_get_aggcnt(struct net_device *dev, struct iwreq *wrqin)
{
    char str[4];
    int aggcnt = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    aggcnt = hgic_fwctrl_get_agg_cnt(&(vif->hg->ctrl));
    sprintf(str, "%d", aggcnt);
    hgicf_copyto_iwreq(wrqin, str, strlen(str));
    return (0);
}

static int hgicf_ioctl_get_chan_list(struct net_device *dev, struct iwreq *wrqin)
{
    int cnt = 0, i = 0;
    int len = 0;
    u16  chan_list[16];
    char *buf = kzalloc(128, GFP_KERNEL);
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);

    if (buf) {
        cnt = hgic_fwctrl_get_chan_list(&(vif->hg->ctrl), chan_list, 16);
        for (i = 0; i < cnt; i++) {
            len += sprintf(buf + len, "%d,", chan_list[i]);
        }
        if (len > 0) {
            len--;
            buf[len] = 0;
            hgicf_copyto_iwreq(wrqin, buf, len);
        }
        kfree(buf);
    }
    return (0);
}

static int hgicf_ioctl_get_freq_range(struct net_device *dev, struct iwreq *wrqin)
{
    char str[32] = {0};
    int ret;
    u32 vals[3];
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);

    ret = hgic_fwctrl_get_freq_range(&(vif->hg->ctrl), &vals[0], &vals[1], &vals[2]);
    if (ret) {
        sprintf(str, "%d,%d,%d", vals[0], vals[1], vals[2]);
    }
    hgicf_copyto_iwreq(wrqin, str, strlen(str));
    return (0);
}

static int hgicf_ioctl_get_key_mgmt(struct net_device *dev, struct iwreq *wrqin)
{
    int len = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    char *buf = kzalloc(40, GFP_ATOMIC);

    if (buf == NULL) {
        return -ENOMEM;
    }
    len = hgic_fwctrl_get_key_mgmt(&(vif->hg->ctrl), buf, 32);
    hgicf_copyto_iwreq(wrqin, buf, len);
    kfree(buf);
    return (0);
}

static int hgicf_ioctl_get_battery_level(struct net_device *dev, struct iwreq *wrqin)
{
    char str[4];
    int val = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);

    val = hgic_fwctrl_get_battery_level(&(vif->hg->ctrl));
    sprintf(str, "%d", val);
    hgicf_copyto_iwreq(wrqin, str, strlen(str));
    return (0);
}

static int hgicf_ioctl_get_module_type(struct net_device *dev, struct iwreq *wrqin)
{
    u16 type = 0;
    char str[12];
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);

    type = (u16)hgic_fwctrl_get_module_type(&(vif->hg->ctrl));
    if (type) {
        sprintf(str, "%d", type);
        hgicf_copyto_iwreq(wrqin, str, strlen(str));
    }
    return (0);
}

static int hgicf_ioctl_get_disassoc_reason(struct net_device *dev, struct iwreq *wrqin)
{
    char str[12];
    int reason = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);

    reason = hgic_fwctrl_get_disassoc_reason(&(vif->hg->ctrl));
    sprintf(str, "%d", reason);
    hgicf_copyto_iwreq(wrqin, str, strlen(str));
    return (0);
}

static int hgicf_ioctl_get_ant_sel(struct net_device *dev, struct iwreq *wrqin)
{
    char str[12];
    int ant = 0;
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);

    ant = hgic_fwctrl_get_ant_sel(&(vif->hg->ctrl));
    sprintf(str, "%d", ant);
    hgicf_copyto_iwreq(wrqin, str, strlen(str));
    return (0);
}

static struct hgpriv_get hgpriv_gets[] = {
    {"sta_list",                    hgicf_ioctl_get_sta_list},
    {"scan_list",                   hgicf_ioctl_get_scan_list},
    {"ssid",                        hgicf_ioctl_get_ssid},
    {"bssid",                       hgicf_ioctl_get_bssid},
    {"wpa_psk",                     hgicf_ioctl_get_wpa_psk},
    {"txpower",                     hgicf_ioctl_get_txpower},
    {"agg_cnt",                     hgicf_ioctl_get_aggcnt},
    {"bss_bw",                      hgicf_ioctl_get_bss_bw},
    {"chan_list",                   hgicf_ioctl_get_chan_list},
    {"freq_range",                  hgicf_ioctl_get_freq_range},
    {"key_mgmt",                    hgicf_ioctl_get_key_mgmt},
    {"battery_level",               hgicf_ioctl_get_battery_level},
    {"module_type",                 hgicf_ioctl_get_module_type},
    {"disassoc_reason",             hgicf_ioctl_get_disassoc_reason},
    {"ant_sel",                     hgicf_ioctl_get_ant_sel},
    {NULL,}
};

int hgicf_ioctl_get_proc(struct net_device *dev, struct iwreq *wrqin)
{
    int ret = 0;
    char field[64];
    struct hgpriv_get *get = NULL;

    ret = hgicf_copyfrom_iwreq(wrqin, field, 64);
    for (get = hgpriv_gets; !ret && get->name; get++) {
        if (strcmp(field, get->name) == 0) {
            return get->get(dev, wrqin);
        }
    }
    hgic_dbg("not support:%s\r\n", field);
    return -ENOTSUPP;
}

int hgicf_ioctl_stat(struct net_device *dev, struct iwreq *wrqin)
{
    //struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    return 0;
}

int hgicf_ioctl_e2p(struct net_device *dev, struct iwreq *wrqin)
{
    //struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    return 0;
}

int hgicf_ioctl_savecfg(struct net_device *dev, struct iwreq *wrqin)
{
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_save_cfg(&(vif->hg->ctrl));
}

int hgicf_ioctl_scan(struct net_device *dev, struct iwreq *wrqin)
{
    struct hgicf_vif  *vif = (struct hgicf_vif *)netdev_priv(dev);
    return hgic_fwctrl_scan(&(vif->hg->ctrl));
}