relms/hgicf
0
0
Fork 0
Code Activity
hgicf/utils/fwctrl.c

1160 lines
35 KiB
C
Raw Normal View History

Initial driver upload
2023-05-16 09:13:19 +00:00
#ifdef __RTOS__
#include <linux/module.h>
#include <linux/types.h>
#include <asm/unaligned.h>
#include <linux/skbuff.h>
#include <linux/completion.h>
#else
#include <linux/version.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/net.h>
#include <linux/slab.h>
#include <linux/firmware.h>
#include <linux/etherdevice.h>
#endif
#include "../hgic_def.h"
#include "fwdl.h"
#include "fwctrl.h"
#include "utils.h"
#define ARG_DUP(arg,len) if(ctrl->param.arg != (void *)arg){ \
if(ctrl->param.arg) kfree(ctrl->param.arg); \
ctrl->param.arg = hgic_strdup(arg,len);\
}
#define ARG_FREE(arg) do{\
if(ctrl->param.arg) kfree(ctrl->param.arg);\
ctrl->param.arg = NULL;\
} while (0)
#define STR_LEN(s) ((s)?strlen(s):0)
static void *hgic_strdup(void *arg, u32 len)
{
int s = 0;
u8 *ptr = NULL;
if (arg) {
s = (len > 0) ? (len) : (strlen((char *)arg) + 1);
ptr = kzalloc(s, GFP_KERNEL);
if (ptr) {
if (len > 0) { memcpy(ptr, arg, len); }
else { strcpy(ptr, (char *)arg); }
}
}
return ptr;
}
u16 hgic_ctrl_cookie(struct hgic_fwctrl *ctrl)
{
unsigned long flags;
uint16_t cookie = 0;
spin_lock_irqsave(&ctrl->lock, flags);
cookie = ctrl->cookie++;
ctrl->cookie &= HGIC_TX_COOKIE_MASK;
spin_unlock_irqrestore(&ctrl->lock, flags);
return cookie;
}
static struct sk_buff *hgic_alloc_ctrl_skb(u32 size)
{
struct sk_buff *skb = dev_alloc_skb(sizeof(struct hgic_ctrl_hdr) + size + 4);
if (!skb) {
return skb;
}
memset(skb->data, 0, sizeof(struct hgic_ctrl_hdr) + size);
skb_reserve(skb, sizeof(struct hgic_ctrl_hdr));
skb_put(skb, size);
return skb;
}
static struct sk_buff *hgic_fwctrl_send_cmd(struct hgic_fwctrl *ctrl, u32 cmd_id, struct sk_buff *skb, bool sync)
{
struct hgic_ctrl_hdr *hdr = NULL;
struct hgic_cmd_response resp;
u16 id = cmd_id - HGIC_CMD_START;
hdr = (struct hgic_ctrl_hdr *)skb_push(skb, sizeof(struct hgic_ctrl_hdr));
hdr->hdr.magic = HGIC_HDR_TX_MAGIC;
hdr->hdr.length = skb->len;
hdr->hdr.ifidx = 1;
hdr->hdr.cookie = hgic_ctrl_cookie(ctrl);
if (id > 255) {
hdr->hdr.type = HGIC_HDR_TYPE_CMD2;
hdr->cmd2.cmd_id = id;
hdr->cmd2.status = 0;
} else {
hdr->hdr.type = HGIC_HDR_TYPE_CMD;
hdr->cmd.cmd_id = id;
hdr->cmd.status = 0;
}
memset(&resp, 0, sizeof(resp));
resp.cookie = hdr->hdr.cookie;
return hgic_fwctrl_send_data(ctrl, skb, &resp, HGIC_CMD_TIMEOUT);
}
static int hgic_fwctrl_set_byte(struct hgic_fwctrl *ctrl, u32 cmd_id, u8 val)
{
int ret = -1;
struct sk_buff *skb = NULL;
struct sk_buff *resp = NULL;
struct hgic_ctrl_hdr *hdr = NULL;
skb = hgic_alloc_ctrl_skb(1);
if (skb) {
skb->data[0] = val;
resp = hgic_fwctrl_send_cmd(ctrl, cmd_id, skb, true);
if (resp) {
hdr = (struct hgic_ctrl_hdr *)resp->data;
ret = hdr->cmd.status;
dev_kfree_skb_any(resp);
}
}
if (ret) {
hgic_dbg("cmd:%d, ret:%d (%s)\r\n", cmd_id, ret, resp ? "Responsed" : "No Response");
}
return ret;
}
static int hgic_fwctrl_set_int_val(struct hgic_fwctrl *ctrl, u32 cmd_id, u32 val)
{
int ret = -1;
struct sk_buff *skb = NULL;
struct sk_buff *resp = NULL;
struct hgic_ctrl_hdr *hdr = NULL;
skb = hgic_alloc_ctrl_skb(4);
if (skb) {
put_unaligned_le32(val, skb->data);
resp = hgic_fwctrl_send_cmd(ctrl, cmd_id, skb, true);
if (resp) {
hdr = (struct hgic_ctrl_hdr *)resp->data;
ret = hdr->cmd.status;
dev_kfree_skb_any(resp);
}
}
if (ret) {
hgic_dbg("cmd:%d, ret:%d (%s)\r\n", cmd_id, ret, resp ? "Responsed" : "No Response");
}
return ret;
}
static short hgic_fwctrl_get_short_val(struct hgic_fwctrl *ctrl, u32 cmd_id)
{
short ret = -1;
struct sk_buff *skb = NULL;
struct sk_buff *resp = NULL;
struct hgic_ctrl_hdr *hdr = NULL;
skb = hgic_alloc_ctrl_skb(0);
if (skb) {
resp = hgic_fwctrl_send_cmd(ctrl, cmd_id, skb, true);
if (resp) {
hdr = (struct hgic_ctrl_hdr *)resp->data;
ret = hdr->cmd.status;
dev_kfree_skb_any(resp);
}
}
return ret;
}
static int hgic_fwctrl_set_bytes(struct hgic_fwctrl *ctrl, u32 cmd_id, u8 *data, u32 len)
{
int ret = -1;
struct sk_buff *skb = NULL;
struct sk_buff *resp = NULL;
struct hgic_ctrl_hdr *hdr = NULL;
skb = hgic_alloc_ctrl_skb(len);
if (skb) {
if (data && len > 0) {
memcpy(skb->data, data, len);
skb->data[len] = 0;
}
resp = hgic_fwctrl_send_cmd(ctrl, cmd_id, skb, true);
if (resp) {
hdr = (struct hgic_ctrl_hdr *)resp->data;
ret = hdr->cmd.status;
dev_kfree_skb_any(resp);
}
if (ret) {
hgic_dbg("cmd:%d, ret:%d (%s)\r\n", cmd_id, ret, resp ? "Responsed" : "No Response");
}
}
return ret;
}
static int hgic_fwctrl_get_bytes(struct hgic_fwctrl *ctrl, u32 cmd_id, u8 *buff, u32 len)
{
int ret = -1;
struct sk_buff *skb = NULL;
struct sk_buff *resp = NULL;
struct hgic_ctrl_hdr *hdr = NULL;
skb = hgic_alloc_ctrl_skb(0);
if (skb) {
resp = hgic_fwctrl_send_cmd(ctrl, cmd_id, skb, true);
if (resp) {
hdr = (struct hgic_ctrl_hdr *)resp->data;
ret = hdr->cmd.status;
if (ret > 0 && len > 0) {
ret = ret > len ? len : ret;
memcpy(buff, (char *)(hdr + 1), ret);
}
dev_kfree_skb_any(resp);
}
}
if (ret < 0) {
hgic_dbg("get string: cmd:%d, ret:%d (%s)\r\n", cmd_id, ret, resp ? "Responsed" : "No Response");
}
return ret;
}
static int hgic_fwctrl_do_cmd(struct hgic_fwctrl *ctrl, u32 cmd_id, u8 *data, u32 len, u8 *buff, u32 size)
{
int ret = -1;
struct sk_buff *skb = NULL;
struct sk_buff *resp = NULL;
struct hgic_ctrl_hdr *hdr = NULL;
skb = hgic_alloc_ctrl_skb(len);
if (skb) {
if (data && len > 0) {
memcpy(skb->data, data, len);
skb->data[len] = 0;
}
resp = hgic_fwctrl_send_cmd(ctrl, cmd_id, skb, true);
if (resp) {
hdr = (struct hgic_ctrl_hdr *)resp->data;
ret = hdr->cmd.status;
if (ret > 0 && buff) {
memcpy(buff, (char *)(hdr + 1), ret > size ? size : ret);
}
dev_kfree_skb_any(resp);
}
if (ret < 0) {
hgic_dbg("cmd:%d, ret:%d (%s)\r\n", cmd_id, ret, resp ? "Responsed" : "No Response");
}
}
return ret;
}
static int hgic_fwctrl_rx_response(struct hgic_fwctrl *ctrl, struct sk_buff *skb)
{
int find = 0;
unsigned long flags;
struct hgic_cmd_response *resp = NULL;
struct hgic_ctrl_hdr *cmd = (struct hgic_ctrl_hdr *)skb->data;;
spin_lock_irqsave(&ctrl->lock, flags);
list_for_each_entry(resp, &ctrl->pd_list, list) {
if (resp->cookie == cmd->hdr.cookie) {
resp->skb = skb;
complete(&resp->cmpl);
find = 1;
break;
}
}
spin_unlock_irqrestore(&ctrl->lock, flags);
if (!find) {
dev_kfree_skb_any(skb);
}
return 0;
}
static void hgic_fwctrl_clear_pdlist(struct hgic_fwctrl *ctrl)
{
unsigned long flags;
struct hgic_cmd_response *sync = NULL;
spin_lock_irqsave(&ctrl->lock, flags);
list_for_each_entry(sync, &ctrl->pd_list, list) {
complete(&sync->cmpl);
}
spin_unlock_irqrestore(&ctrl->lock, flags);
}
static void hgic_fwctrl_work(struct work_struct *work)
{
struct hgic_fwctrl *ctrl = NULL;
struct sk_buff *skb = NULL;
struct hgic_ctrl_hdr *hdr = NULL;
ctrl = container_of(work, struct hgic_fwctrl, work);
while (!skb_queue_empty(&ctrl->rxq)) {
skb = skb_dequeue(&ctrl->rxq);
hdr = (struct hgic_ctrl_hdr *)skb->data;
switch (hdr->hdr.type) {
case HGIC_HDR_TYPE_CMD:
case HGIC_HDR_TYPE_CMD2:
case HGIC_HDR_TYPE_BOOTDL:
case HGIC_HDR_TYPE_OTA:
hgic_fwctrl_rx_response(ctrl, skb);
break;
case HGIC_HDR_TYPE_EVENT:
case HGIC_HDR_TYPE_EVENT2:
hgic_rx_fw_event(ctrl, skb);
break;
default:
dev_kfree_skb(skb);
break;
}
}
}
static void hgic_fwctrl_flush_work(struct work_struct *work)
{
struct hgic_fwctrl *ctrl = container_of(work, struct hgic_fwctrl, flush_work);
hgic_fwctrl_flush_param(ctrl);
}
struct sk_buff *hgic_fwctrl_send_data(struct hgic_fwctrl *ctrl, struct sk_buff *skb, struct hgic_cmd_response *resp, u32 timeout)
{
unsigned long flags;
init_completion(&resp->cmpl);
spin_lock_irqsave(&ctrl->lock, flags);
list_add(&resp->list, &ctrl->pd_list);
spin_unlock_irqrestore(&ctrl->lock, flags);
skb_queue_tail(&ctrl->txq, skb);
hgic_schedule(ctrl);
if (timeout) {
wait_for_completion_timeout(&resp->cmpl, msecs_to_jiffies(timeout));
}
spin_lock_irqsave(&ctrl->lock, flags);
list_del(&resp->list);
spin_unlock_irqrestore(&ctrl->lock, flags);
#ifdef __RTOS__
deinit_completion(&resp->cmpl);
#endif
return resp->skb;
}
void hgic_fwctrl_rx(struct hgic_fwctrl *ctrl, struct sk_buff *skb)
{
skb_queue_tail(&ctrl->rxq, skb);
if (ctrl->wq) {
queue_work(ctrl->wq, &ctrl->work);
} else {
hgic_err("fwctrl workqueue is NULL\r\n");
}
}
void hgic_fwctrl_init(struct hgic_fwctrl *ctrl, void *dev)
{
memset(ctrl, 0, sizeof(struct hgic_fwctrl));
ctrl->dev = dev;
ctrl->param.acs = 0x3;
ctrl->param.tx_mcs = 0xff;
ctrl->param.ps_mode = 0xff;
ctrl->param.wkio_mode = 0xff;
spin_lock_init(&ctrl->lock);
INIT_LIST_HEAD(&ctrl->pd_list);
skb_queue_head_init(&ctrl->rxq);
skb_queue_head_init(&ctrl->txq);
INIT_WORK(&ctrl->flush_work, hgic_fwctrl_flush_work);
INIT_WORK(&ctrl->work, hgic_fwctrl_work);
ctrl->wq = ALLOC_ORDERED_WORKQUEUE("fwctrl", 0);
}
void hgic_fwctrl_release(struct hgic_fwctrl *ctrl)
{
cancel_work_sync(&ctrl->work);
cancel_work_sync(&ctrl->flush_work);
hgic_fwctrl_clear_pdlist(ctrl);
hgic_clear_queue(&ctrl->txq);
hgic_clear_queue(&ctrl->rxq);
#ifdef __RTOS__
skb_queue_head_deinit(&ctrl->rxq);
skb_queue_head_deinit(&ctrl->txq);
spin_lock_deinit(&ctrl->lock);
#endif
if (ctrl->wq) {
flush_workqueue(ctrl->wq);
destroy_workqueue(ctrl->wq);
}
ARG_FREE(country_code);
ARG_FREE(ssid);
ARG_FREE(bssid);
ARG_FREE(bssid_filter);
ARG_FREE(key_mgmt);
ARG_FREE(wpa_psk);
ARG_FREE(mode);
ARG_FREE(mac_addr);
ARG_FREE(chan_list);
ARG_FREE(paired_stas);
ARG_FREE(mcast_key);
}
void hgic_fwctrl_flush_param(struct hgic_fwctrl *ctrl)
{
//int retry = 0;
if (ctrl->param.bss_bw) {
hgic_fwctrl_set_bss_bw(ctrl, ctrl->param.bss_bw);
}
if (ctrl->param.chan_list) {
hgic_fwctrl_set_chan_list(ctrl, (u16 *)ctrl->param.chan_list, ctrl->param.chan_cnt);
}
if (ctrl->param.freq_start) {
hgic_fwctrl_set_freq_range(ctrl, ctrl->param.freq_start, ctrl->param.freq_end, ctrl->param.chan_bw);
}
if (ctrl->param.country_code) {
hgic_fwctrl_set_countryregion(ctrl, ctrl->param.country_code);
}
if (ctrl->param.ssid) {
hgic_fwctrl_set_ssid(ctrl, ctrl->param.ssid);
}
if (ctrl->param.bssid) {
hgic_fwctrl_set_bssid(ctrl, ctrl->param.bssid);
}
if (ctrl->param.bssid_filter) {
hgic_fwctrl_set_bssid_filter(ctrl, ctrl->param.bssid_filter);
}
if (ctrl->param.key_mgmt) {
hgic_fwctrl_set_key_mgmt(ctrl, ctrl->param.key_mgmt);
}
if (ctrl->param.wpa_psk) {
hgic_fwctrl_set_wpa_psk(ctrl, ctrl->param.wpa_psk);
}
if (ctrl->param.mcast_key) {
hgic_fwctrl_set_mcast_key(ctrl, ctrl->param.mcast_key);
}
if (ctrl->param.mac_addr) {
hgic_fwctrl_set_mac(ctrl, ctrl->param.mac_addr);
}
if (ctrl->param.channel) {
hgic_fwctrl_set_channel(ctrl, ctrl->param.channel);
}
if (ctrl->param.rts_threshold) {
hgic_fwctrl_set_rts_threshold(ctrl, ctrl->param.rts_threshold);
}
if (ctrl->param.frag_threshold) {
hgic_fwctrl_set_frag_threshold(ctrl, ctrl->param.frag_threshold);
}
if (ctrl->param.listen_interval) {
hgic_fwctrl_set_listen_interval(ctrl, ctrl->param.listen_interval);
}
if (ctrl->param.center_freq) {
hgic_fwctrl_set_center_freq(ctrl, ctrl->param.center_freq);
}
if (ctrl->param.beacon_int) {
hgic_fwctrl_set_beacon_int(ctrl, ctrl->param.beacon_int);
}
if (ctrl->param.ethertype) {
hgic_fwctrl_set_ethertype(ctrl, ctrl->param.ethertype);
}
if (ctrl->param.txpower) {
hgic_fwctrl_set_txpower(ctrl, ctrl->param.txpower);
}
if (ctrl->param.primary_chan) {
hgic_fwctrl_set_primary_chan(ctrl, ctrl->param.primary_chan);
}
if (ctrl->param.mode) {
hgic_fwctrl_set_mode(ctrl, ctrl->param.mode);
}
if (ctrl->param.acs != 0x3) {
hgic_fwctrl_set_acs(ctrl, ctrl->param.acs, ctrl->param.acs_tmo);
}
if (ctrl->param.bss_max_idle) {
hgic_fwctrl_set_bss_max_idle(ctrl, ctrl->param.bss_max_idle);
}
if (ctrl->param.dtim_period) {
hgic_fwctrl_set_dtim_period(ctrl, ctrl->param.dtim_period);
}
if (ctrl->param.ps_connect) {
hgic_fwctrl_set_ps_connect(ctrl, ctrl->param.ps_connect, ctrl->param.ps_connect_roundup);
}
if (ctrl->param.agg_cnt) {
hgic_fwctrl_set_agg_cnt(ctrl, ctrl->param.agg_cnt);
}
if (ctrl->param.wkio_mode != 0xff) {
hgic_fwctrl_set_wkio_mode(ctrl, ctrl->param.wkio_mode);
}
if (ctrl->param.ps_mode != 0xff) {
hgic_fwctrl_set_ps_mode(ctrl, ctrl->param.ps_mode);
}
if (ctrl->param.aplost_time) {
hgic_fwctrl_set_aplost_time(ctrl, ctrl->param.aplost_time);
}
if (ctrl->param.tx_mcs != 0xff) {
hgic_fwctrl_set_tx_mcs(ctrl, ctrl->param.tx_mcs);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
int hgic_fwctrl_testmode_cmd(struct hgic_fwctrl *ctrl, u8 *cmd, u32 size)
{
int ret = 0;
ret = hgic_fwctrl_do_cmd(ctrl, HGIC_CMD_TESTMODE_CMD, cmd, STR_LEN(cmd), cmd, size);
if (ret < 0) {
strcpy(cmd, "failed");
} else {
cmd[ret] = 0;
}
return ret;
}
int hgic_fwctrl_get_status(struct hgic_fwctrl *ctrl, u8 *buff, u32 len)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_STATUS, buff, len);
}
int hgic_fwctrl_get_conn_state(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_do_cmd(ctrl, HGIC_CMD_GET_CONN_STATE, NULL, 0, NULL, 0);
}
int hgic_fwctrl_get_fwinfo(struct hgic_fwctrl *ctrl, struct hgic_fw_info *info)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_FW_INFO, (u8 *)info, sizeof(struct hgic_fw_info));
}
int hgic_fwctrl_set_countryregion(struct hgic_fwctrl *ctrl, u8 *country_code)
{
ARG_DUP(country_code, 0);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_COUNTERY, country_code, STR_LEN(country_code));
}
int hgic_fwctrl_set_ssid(struct hgic_fwctrl *ctrl, u8 *ssid)
{
ARG_DUP(ssid, 0);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_SSID, ssid, STR_LEN(ssid));
}
int hgic_fwctrl_set_bssid(struct hgic_fwctrl *ctrl, u8 *bssid)
{
ARG_DUP(bssid, 6);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_BSSID, bssid, 6);
}
int hgic_fwctrl_set_channel(struct hgic_fwctrl *ctrl, u32 channel)
{
ctrl->param.acs = 0;
ctrl->param.channel = channel;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_CHANNEL, channel);
}
int hgic_fwctrl_set_bssid_filter(struct hgic_fwctrl *ctrl, u8 *bssid_filter)
{
ARG_DUP(bssid_filter, 0);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_BSSID_FILTER, bssid_filter, STR_LEN(bssid_filter));
}
int hgic_fwctrl_set_rts_threshold(struct hgic_fwctrl *ctrl, u32 rts_threshold)
{
ctrl->param.rts_threshold = rts_threshold;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_RTS_THRESHOLD, rts_threshold);
}
int hgic_fwctrl_set_frag_threshold(struct hgic_fwctrl *ctrl, u32 frag_threshold)
{
ctrl->param.frag_threshold = frag_threshold;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_FRG_THRESHOLD, frag_threshold);
}
int hgic_fwctrl_set_key_mgmt(struct hgic_fwctrl *ctrl, u8 *key_mgmt)
{
ARG_DUP(key_mgmt, 0);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_KEY_MGMT, key_mgmt, STR_LEN(key_mgmt));
}
int hgic_fwctrl_set_wpa_psk(struct hgic_fwctrl *ctrl, u8 *wpa_psk)
{
ARG_DUP(wpa_psk, 0);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_WPA_PSK, wpa_psk, STR_LEN(wpa_psk));
}
int hgic_fwctrl_set_wbnat(struct hgic_fwctrl *ctrl, u32 enable)
{
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_WBNAT, enable);
}
int hgic_fwctrl_set_freq_range(struct hgic_fwctrl *ctrl, u32 freq_start, u32 freq_end, u32 bss_bw)
{
u8 data[12];
put_unaligned_le32(freq_start, data);
put_unaligned_le32(freq_end, data + 4);
put_unaligned_le32(bss_bw, data + 8);
ctrl->param.freq_start = freq_start;
ctrl->param.freq_end = freq_end;
ctrl->param.chan_bw = bss_bw;
ARG_FREE(chan_list);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_FREQ_RANGE, data, 12);
}
int hgic_fwctrl_set_bss_bw(struct hgic_fwctrl *ctrl, u8 bss_bw)
{
ctrl->param.bss_bw = bss_bw;
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_BSS_BW, bss_bw);
}
int hgic_fwctrl_set_tx_bw(struct hgic_fwctrl *ctrl, u8 tx_bw)
{
ctrl->param.tx_bw = tx_bw;
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_TX_BW, tx_bw);
}
int hgic_fwctrl_set_tx_mcs(struct hgic_fwctrl *ctrl, u8 tx_mcs)
{
ctrl->param.tx_mcs = tx_mcs;
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_TX_MCS, tx_mcs);
}
int hgic_fwctrl_set_acs(struct hgic_fwctrl *ctrl, u8 acs, u8 acs_tmo)
{
u8 data[2] = {acs, acs_tmo};
ctrl->param.acs = acs;
ctrl->param.acs_tmo = acs_tmo;
if (acs) {
ctrl->param.channel = 0;
ctrl->param.center_freq = 0;
}
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_ACS_ENABLE, data, 2);
}
int hgic_fwctrl_set_bgrssi(struct hgic_fwctrl *ctrl, u8 bgrssi)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_BG_RSSI, bgrssi);
}
int hgic_fwctrl_set_chan_list(struct hgic_fwctrl *ctrl, u16 *chan_list, u32 cnt)
{
int ret = -1;
int i = 0;
u8 *buf = kzalloc((1 + cnt) * sizeof(u16), GFP_KERNEL);
ARG_DUP(chan_list, cnt * sizeof(u16));
ctrl->param.chan_cnt = cnt;
ctrl->param.freq_start = 0;
if (buf) {
put_unaligned_le16(cnt, buf);
for (i = 0; i < cnt; i++) {
put_unaligned_le16(chan_list[i], buf + (i + 1) * sizeof(u16));
}
ret = hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_CHAN_LIST, buf, (1 + cnt) * sizeof(u16));
kfree(buf);
}
return ret;
}
int hgic_fwctrl_set_mode(struct hgic_fwctrl *ctrl, u8 *mode)
{
ARG_DUP(mode, 0);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_WORK_MODE, mode, STR_LEN(mode));
}
int hgic_fwctrl_set_paired_stas(struct hgic_fwctrl *ctrl, u8 *paired_stas, u32 len)
{
ARG_DUP(paired_stas, len);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_PAIRED_STATIONS, paired_stas, len);
}
int hgic_fwctrl_set_pairing(struct hgic_fwctrl *ctrl, u8 start)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_PAIRING, start);
}
int hgic_fwctrl_open_dev(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_do_cmd(ctrl, HGIC_CMD_DEV_OPEN, 0, 0, 0, 0);
}
int hgic_fwctrl_close_dev(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_do_cmd(ctrl, HGIC_CMD_DEV_CLOSE, 0, 0, 0, 0);
}
int hgic_fwctrl_set_txpower(struct hgic_fwctrl *ctrl, u32 tx_power)
{
ctrl->param.txpower = tx_power;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_TX_POWER, tx_power);
}
int hgic_fwctrl_get_txpower(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_TX_POWER);
}
int hgic_fwctrl_set_listen_interval(struct hgic_fwctrl *ctrl, u32 listen_interval)
{
ctrl->param.listen_interval = listen_interval;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_LISTEN_INTERVAL, listen_interval);
}
int hgic_fwctrl_set_center_freq(struct hgic_fwctrl *ctrl, u32 center_freq)
{
ctrl->param.acs = 0;
ctrl->param.center_freq = center_freq;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_CENTER_FREQ, center_freq);
}
int hgic_fwctrl_set_tx_count(struct hgic_fwctrl *ctrl, u32 short_frm_tx_count, u32 long_frm_tx_count)
{
u8 data[8];
put_unaligned_le32(short_frm_tx_count, data);
put_unaligned_le32(long_frm_tx_count, data + 4);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_TX_LCOUNT, data, 8);
}
int hgic_fwctrl_set_key(struct hgic_fwctrl *ctrl, u8 cmd, u16 aid, u8 *key, u8 len)
{
int ret = -ENOMEM;
u8 *buff = kmalloc(len + 4, GFP_KERNEL);
if (buff) {
buff[0] = cmd;
put_unaligned_le16(aid, buff + 1);
buff[3] = len;
memcpy(buff + 4, key, len);
ret = hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_KEY, buff, len + 4);
kfree(buff);
}
return ret;
}
int hgic_fwctrl_add_sta(struct hgic_fwctrl *ctrl, u16 aid, u8 *addr)
{
uint8_t sta_info[8];
put_unaligned_le16(aid, sta_info);
memcpy(sta_info + 2, addr, 6);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_ADD_STA, sta_info, 8);
}
int hgic_fwctrl_del_sta(struct hgic_fwctrl *ctrl, u32 aid)
{
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_REMOVE_STA, aid);
}
int hgic_fwctrl_set_primary_chan(struct hgic_fwctrl *ctrl, u8 primary_chan)
{
ctrl->param.primary_chan = primary_chan;
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_PRIMARY_CHAN, primary_chan);
}
int hgic_fwctrl_set_aid(struct hgic_fwctrl *ctrl, u32 aid)
{
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_AID, aid);
}
int hgic_fwctrl_set_mac(struct hgic_fwctrl *ctrl, u8 *mac_addr)
{
ARG_DUP(mac_addr, 6);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_MAC, mac_addr, 6);
}
int hgic_fwctrl_get_scan_list(struct hgic_fwctrl *ctrl, u8 *buff, u32 size)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_SCAN_LIST, buff, size);
}
int hgic_fwctrl_scan(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SCAN, 1);
}
int hgic_fwctrl_set_txq_param(struct hgic_fwctrl *ctrl, u8 *txq, u32 size)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_TXQ_PARAM, txq, size);
}
int hgic_fwctrl_get_temperature(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_TEMPERATURE);
}
int hgic_fwctrl_enter_sleep(struct hgic_fwctrl *ctrl, u8 sleep)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_ENTER_SLEEP, sleep);
}
int hgic_fwctrl_get_sta_list(struct hgic_fwctrl *ctrl, struct hgic_sta_info *sta_list, u32 size)
{
int ret = hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_STA_LIST, (u8 *)sta_list, size * sizeof(struct hgic_sta_info));
return ret > 0 ? (ret / sizeof(struct hgic_sta_info)) : ret;
}
int hgic_fwctrl_set_beacon_int(struct hgic_fwctrl *ctrl, u32 beacon_int)
{
ctrl->param.beacon_int = beacon_int;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_BEACON_INT, beacon_int);
}
int hgic_fwctrl_get_ssid(struct hgic_fwctrl *ctrl, u8 *ssid, u32 size)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_SSID, ssid, size);
}
int hgic_fwctrl_get_bssid(struct hgic_fwctrl *ctrl, u8 *bssid)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_BSSID, bssid, 6);
}
int hgic_fwctrl_get_wpapsk(struct hgic_fwctrl *ctrl, u8 *psk, u32 size)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_WPA_PSK, psk, size);
}
int hgic_fwctrl_save_cfg(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_do_cmd(ctrl, HGIC_CMD_SAVE_CFG, 0, 0, 0, 0);
}
int hgic_fwctrl_join_group(struct hgic_fwctrl *ctrl, u8 *addr, u8 aid)
{
u8 val[7];
memcpy(val, addr, 6);
val[6] = aid;
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_JOIN_GROUP, val, 7);
}
int hgic_fwctrl_set_ethertype(struct hgic_fwctrl *ctrl, u16 ethertype)
{
u8 vals[2];
ctrl->param.ethertype = ethertype;
put_unaligned_le16(ethertype, vals);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_ETHER_TYPE, vals, 2);
}
int hgic_fwctrl_get_sta_count(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_do_cmd(ctrl, HGIC_CMD_GET_STA_COUNT, 0, 0, 0, 0);
}
int hgic_fwctrl_get_agg_cnt(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_AGG_CNT);
}
int hgic_fwctrl_set_agg_cnt(struct hgic_fwctrl *ctrl, u8 agg_cnt)
{
ctrl->param.agg_cnt = agg_cnt;
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_AGG_CNT, agg_cnt);
}
int hgic_fwctrl_get_bss_bw(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_BSS_BW);
}
int hgic_fwctrl_get_freq_range(struct hgic_fwctrl *ctrl, u32 *freq_start, u32 *freq_end, u32 *bss_bw)
{
int ret = 0;
u32 vals[3];
ret = hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_FREQ_RANGE, (u8 *)&vals, sizeof(vals));
if (ret == 12) {
*freq_start = vals[0];
*freq_end = vals[1];
*bss_bw = vals[2];
}
return (ret == 12);
}
int hgic_fwctrl_get_chan_list(struct hgic_fwctrl *ctrl, u16 *chan_list, u16 count)
{
int ret = hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_CHAN_LIST, (u8 *)chan_list, count * sizeof(u16));
return ret > 0 ? ret / sizeof(u16) : 0;
}
int hgic_fwctrl_wakeup_sta(struct hgic_fwctrl *ctrl, u8 *addr)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_WAKEUP_STA, addr, 6);
}
int hgic_fwctrl_set_ps_heartbeat(struct hgic_fwctrl *ctrl, u32 ipaddr, u32 dport, u32 period, u32 hb_tmo)
{
u8 val[16];
put_unaligned_le32(ipaddr, val);
put_unaligned_le32(dport, val + 4);
put_unaligned_le32(period, val + 8);
put_unaligned_le32(hb_tmo, val + 12);
hgic_dbg("ip:%x, port:%d, period:%d, hb_tmo:%d\r\n", ipaddr, dport, period, hb_tmo);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_PS_HEARTBEAT, val, 16);
}
int hgic_fwctrl_set_ps_heartbeat_resp(struct hgic_fwctrl *ctrl, u8 *data, u32 size)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_PS_HEARTBEAT_RESP, data, size);
}
int hgic_fwctrl_set_ps_wakeup_data(struct hgic_fwctrl *ctrl, u8 *data, u32 size)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_PS_WAKEUP_DATA, data, size);
}
int hgic_fwctrl_set_ps_connect(struct hgic_fwctrl *ctrl, u8 period, u8 roundup)
{
u8 val[2] = {period, roundup};
ctrl->param.ps_connect = period;
ctrl->param.ps_connect_roundup = roundup;
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_PS_CONNECT, val, 2);
}
int hgic_fwctrl_radio_onoff(struct hgic_fwctrl *ctrl, u8 onoff)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_RADIO_ONOFF, onoff);
}
int hgic_fwctrl_set_bss_max_idle(struct hgic_fwctrl *ctrl, u32 max_idle)
{
ctrl->param.bss_max_idle = max_idle;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_BSS_MAX_IDLE, max_idle);
}
int hgic_fwctrl_set_wkio_mode(struct hgic_fwctrl *ctrl, u8 mode)
{
ctrl->param.wkio_mode = mode;
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_WKIO_MODE, mode);
}
int hgic_fwctrl_set_dtim_period(struct hgic_fwctrl *ctrl, u32 period)
{
ctrl->param.dtim_period = period;
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_DTIM_PERIOD, period);
}
int hgic_fwctrl_set_ps_mode(struct hgic_fwctrl *ctrl, u8 mode)
{
ctrl->param.ps_mode = mode;
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_PS_MODE, mode);
}
int hgic_fwctrl_set_load_def(struct hgic_fwctrl *ctrl, u8 rst)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_LOAD_DEF, rst);
}
int hgic_fwctrl_disassoc_sta(struct hgic_fwctrl *ctrl, u8 *addr)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_DISASSOC_STA, addr, 6);
}
int hgic_fwctrl_set_aplost_time(struct hgic_fwctrl *ctrl, u32 aplost_time)
{
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_APLOST_TIME, aplost_time);
}
int hgic_fwctrl_get_wkreason(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_do_cmd(ctrl, HGIC_CMD_GET_WAKEUP_REASON, 0, 0, 0, 0);
}
int hgic_fwctrl_unpair(struct hgic_fwctrl *ctrl, u8 *addr)
{
ARG_FREE(ssid);
ARG_FREE(bssid);
ARG_FREE(bssid_filter);
ARG_FREE(key_mgmt);
ARG_FREE(wpa_psk);
ARG_FREE(paired_stas);
ARG_FREE(mcast_key);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_UNPAIR, addr, 6);
}
int hgic_fwctrl_set_auto_chswitch(struct hgic_fwctrl *ctrl, u8 enable)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_AUTO_CHAN_SWITCH, enable);
}
int hgic_fwctrl_set_mcast_key(struct hgic_fwctrl *ctrl, u8 *mcast_key)
{
ARG_DUP(mcast_key, 0);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_MCAST_KEY, mcast_key, STR_LEN(mcast_key));
}
int hgic_fwctrl_set_reassoc_wkhost(struct hgic_fwctrl *ctrl, u8 enable)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_REASSOC_WKHOST, enable);
}
int hgic_fwctrl_set_wakeup_io(struct hgic_fwctrl *ctrl, u8 io, u8 edge)
{
u8 val[2] = {io, edge};
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_WAKEUP_IO, val, 2);
}
int hgic_fwctrl_set_dbginfo_output(struct hgic_fwctrl *ctrl, u8 enable)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_DBGINFO_OUTPUT, enable);
}
int hgic_fwctrl_set_sysdbg(struct hgic_fwctrl *ctrl, u8 *cmd)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_SYSDBG, cmd, STR_LEN(cmd));
}
int hgic_fwctrl_set_autosleep_time(struct hgic_fwctrl *ctrl, u8 time)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_AUTO_SLEEP_TIME, time);
}
int hgic_fwctrl_get_key_mgmt(struct hgic_fwctrl *ctrl, u8 *ssid, u32 size)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_KEY_MGMT, ssid, size);
}
int hgic_fwctrl_set_supper_pwr(struct hgic_fwctrl *ctrl, u8 enable)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_SUPPER_PWR, enable);
}
int hgic_fwctrl_set_repeater_ssid(struct hgic_fwctrl *ctrl, u8 *ssid)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_REPEATER_SSID, ssid, STR_LEN(ssid));
}
int hgic_fwctrl_set_repeater_psk(struct hgic_fwctrl *ctrl, u8 *wpa_psk)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_REPEATER_PSK, wpa_psk, STR_LEN(wpa_psk));
}
int hgic_fwctrl_set_auto_save(struct hgic_fwctrl *ctrl, u8 enable)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_CFG_AUTO_SAVE, enable);
}
int hgic_fwctrl_set_pair_autostop(struct hgic_fwctrl *ctrl, u8 enable)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_PAIR_AUTOSTOP, enable);
}
int hgic_fwctrl_send_cust_mgmt(struct hgic_fwctrl *ctrl, u8 *data, u32 len)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SEND_CUST_MGMT, data, len);
}
int hgic_fwctrl_get_battery_level(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_BATTERY_LEVEL);
}
int hgic_fwctrl_set_dcdc13v(struct hgic_fwctrl *ctrl, u8 enable)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_DCDC13, enable);
}
int hgic_fwctrl_set_acktmo(struct hgic_fwctrl *ctrl, u32 tmo)
{
return hgic_fwctrl_set_int_val(ctrl, HGIC_CMD_SET_ACKTMO, tmo);
}
int hgic_fwctrl_get_module_type(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_MODULETYPE);
}
int hgic_fwctrl_set_pa_pwrctl_dis(struct hgic_fwctrl *ctrl, u8 dis)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_PA_PWRCTRL_DIS, dis);
}
int hgic_fwctrl_set_dhcpc(struct hgic_fwctrl *ctrl, u8 en)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_DHCPC, en);
}
int hgic_fwctrl_get_dhcpc_result(struct hgic_fwctrl *ctrl, u8 *buff, int len)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_DHCPC_RESULT, buff, len);
}
int hgic_fwctrl_set_wkdata_mask(struct hgic_fwctrl *ctrl, u16 offset, u8 *mask, u8 mask_len)
{
u8 data[128];
if(mask_len > 16) mask_len = 16;
memset(data, 0, sizeof(data));
put_unaligned_le16(offset, data);
memcpy(data + 2, mask, mask_len);
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_WKUPDATA_MASK, data, mask_len + 2);
}
int hgic_fwctrl_get_wkdata_buff(struct hgic_fwctrl *ctrl, u8 *buff, int len)
{
return hgic_fwctrl_get_bytes(ctrl, HGIC_CMD_GET_WKDATA_BUFF, buff, len);
}
int hgic_fwctrl_get_disassoc_reason(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_DISASSOC_REASON);
}
int hgic_fwctrl_set_wkdata_save(struct hgic_fwctrl *ctrl, u8 save)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_WKUPDATA_SAVEEN, save);
}
int hgic_fwctrl_set_cust_driver_data(struct hgic_fwctrl *ctrl, u8 *data, u32 len)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_CUST_DRIVER_DATA, data, len);
}
int hgic_fwctrl_set_mcast_txparam(struct hgic_fwctrl *ctrl, struct hgic_mcast_txparam *param)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_MCAST_TXPARAM, (u8 *)param, sizeof(struct hgic_mcast_txparam));
}
int hgic_fwctrl_set_freqinfo(struct hgic_fwctrl *ctrl, u8 *data, u32 len)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_STA_FREQINFO, data, len);
}
int hgic_fwctrl_reset_sta(struct hgic_fwctrl *ctrl, u8 *addr)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_RESET_STA, addr, 6);
}
int hgic_fwctrl_set_ant_auto(struct hgic_fwctrl *ctrl, u8 en)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_ANT_AUTO, en);
}
int hgic_fwctrl_select_ant(struct hgic_fwctrl *ctrl, u8 ant)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_ANT_SEL, ant);
}
int hgic_fwctrl_get_ant_sel(struct hgic_fwctrl *ctrl)
{
return hgic_fwctrl_get_short_val(ctrl, HGIC_CMD_GET_ANT_SEL);
}
int hgic_fwctrl_set_wkhost_reasons(struct hgic_fwctrl *ctrl, u8 *reasons, u8 count)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_WKUP_HOST_REASON, reasons, count);
}
int hgic_fwctrl_set_mac_filter(struct hgic_fwctrl *ctrl, u8 en)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_MAC_FILTER_EN, en);
}
int hgic_fwctrl_set_atcmd(struct hgic_fwctrl *ctrl, char *atcmd)
{
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_ATCMD, atcmd, strlen(atcmd));
}
int hgic_fwctrl_set_roaming(struct hgic_fwctrl *ctrl, u8 en, u8 same_freq)
{
u8 vals[2] = {en, same_freq};
return hgic_fwctrl_set_bytes(ctrl, HGIC_CMD_SET_ROAMING, vals, 2);
}
int hgic_fwctrl_set_ap_hide(struct hgic_fwctrl *ctrl, u8 hide)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_AP_HIDE, hide);
}
int hgic_fwctrl_set_frm_tx_maxcnt(struct hgic_fwctrl *ctrl, u8 txcnt)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_MAX_TCNT, txcnt);
}
int hgic_fwctrl_set_assert_holdup(struct hgic_fwctrl *ctrl, u8 holdup)
{
return hgic_fwctrl_set_byte(ctrl, HGIC_CMD_SET_ASSERT_HOLDUP, holdup);
}
Copy permalink