struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct channel_attr *hif_set_ch = &msg->body.channel_info;
-       int ret = 0;
+       int ret;
        struct wid wid;
 
        wid.id = WID_CURRENT_CHANNEL;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct drv_handler *hif_drv_handler = &msg->body.drv;
-       int ret = 0;
+       int ret;
        struct wid wid;
        u8 *currbyte, *buffer;
-       struct host_if_drv *hif_drv = NULL;
+       struct host_if_drv *hif_drv;
 
        if (!vif->hif_drv || !hif_drv_handler)
                goto free_msg;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct op_mode *hif_op_mode = &msg->body.mode;
-       int ret = 0;
+       int ret;
        struct wid wid;
 
        wid.id = WID_SET_OPERATION_MODE;
        struct wilc_vif *vif = msg->vif;
        u8 *ip_addr = msg->body.ip_info.ip_addr;
        u8 idx = msg->body.ip_info.idx;
-       int ret = 0;
+       int ret;
        struct wid wid;
        char firmware_ip_addr[4] = {0};
 
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        u8 idx = msg->body.ip_info.idx;
-       int ret = 0;
+       int ret;
        struct wid wid;
 
        wid.id = WID_IP_ADDRESS;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct get_mac_addr *get_mac_addr = &msg->body.get_mac_info;
-       int ret = 0;
+       int ret;
        struct wid wid;
 
        wid.id = WID_MAC_ADDR;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct cfg_param_attr *param = &msg->body.cfg_info;
-       int ret = 0;
+       int ret;
        struct wid wid_list[32];
        struct host_if_drv *hif_drv = vif->hif_drv;
        int i = 0;
 {
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
-       s32 result = 0;
+       s32 result;
        struct connect_info info;
        struct wid wid;
        u16 dummy_reason_code = 0;
        u32 i;
        bool found;
        struct network_info *info = NULL;
-       void *params = NULL;
+       void *params;
        struct host_if_drv *hif_drv = vif->hif_drv;
        struct user_scan_req *scan_req = &hif_drv->usr_scan_req;
 
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct rcvd_async_info *rcvd_info = &msg->body.async_info;
-       u8 msg_type = 0;
+       u8 msg_type;
        u8 mac_status;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        struct disconnect_info disconn_info;
        struct user_scan_req *scan_req;
        struct user_conn_req *conn_req;
-       s32 result = 0;
+       s32 result;
        u16 dummy_reason_code = 0;
 
        wid.id = WID_DISCONNECT;
 {
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
 
        wid.id = WID_RSSI;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct wid wid_list[5];
-       u32 wid_cnt = 0, result = 0;
+       u32 wid_cnt = 0, result;
        struct rf_info *stats = (struct rf_info *)msg->body.data;
 
        wid_list[wid_cnt].id = WID_LINKSPEED;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct sta_inactive_t *hif_sta_inactive = &msg->body.mac_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
 
        wid.id = WID_SET_STA_MAC_INACTIVE_TIME;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct beacon_attr *param = &msg->body.beacon_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        u8 *cur_byte;
 
 {
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        u8 del_beacon = 0;
 
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct add_sta_param *param = &msg->body.add_sta_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        u8 *cur_byte;
 
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct del_all_sta *param = &msg->body.del_all_sta_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        u8 *curr_byte;
        u8 i;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct del_sta *param = &msg->body.del_sta_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
 
        wid.id = WID_REMOVE_STA;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct add_sta_param *param = &msg->body.edit_sta_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        u8 *cur_byte;
 
 static int handle_remain_on_chan(struct wilc_vif *vif,
                                 struct remain_ch *hif_remain_ch)
 {
-       s32 result = 0;
+       s32 result;
        u8 remain_on_chan_flag;
        struct wid wid;
        struct host_if_drv *hif_drv = vif->hif_drv;
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct reg_frame *hif_reg_frame = &msg->body.reg_frame;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        u8 *cur_byte;
 
        struct remain_ch *hif_remain_ch = &msg->body.remain_on_ch;
        u8 remain_on_chan_flag;
        struct wid wid;
-       s32 result = 0;
+       s32 result;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (p2p_listen_state) {
        struct host_if_drv *hif_drv = from_timer(hif_drv, t,
                                                      remain_on_ch_timer);
        struct wilc_vif *vif = hif_drv->remain_on_ch_timer_vif;
-       s32 result = 0;
+       s32 result;
        struct host_if_msg *msg;
 
        del_timer(&vif->hif_drv->remain_on_ch_timer);
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct power_mgmt_param *pm_param = &msg->body.pwr_mgmt_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        s8 power_mode;
 
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        struct set_multicast *hif_set_mc = &msg->body.multicast_info;
-       s32 result = 0;
+       s32 result;
        struct wid wid;
        u8 *cur_byte;
 
        struct host_if_msg *msg = container_of(work, struct host_if_msg, work);
        struct wilc_vif *vif = msg->vif;
        u8 *tx_pwr = &msg->body.tx_power.tx_pwr;
-       int ret = 0;
+       int ret;
        struct wid wid;
 
        wid.id = WID_TX_POWER;
 
 int wilc_remove_wep_key(struct wilc_vif *vif, u8 index)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
 
 int wilc_set_wep_default_keyid(struct wilc_vif *vif, u8 index)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
 int wilc_set_pmkid_info(struct wilc_vif *vif,
                        struct host_if_pmkid_attr *pmkid)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        int i;
 
 
 int wilc_get_mac_address(struct wilc_vif *vif, u8 *mac_addr)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_get_mac_address, true);
                      u8 security, enum authtype auth_type,
                      u8 channel, void *join_params)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
 
 int wilc_disconnect(struct wilc_vif *vif, u16 reason_code)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
 int wilc_set_wfi_drv_handler(struct wilc_vif *vif, int index, u8 mode,
                             u8 ifc_id)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_set_wfi_drv_handler, false);
 
 int wilc_set_operation_mode(struct wilc_vif *vif, u32 mode)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg  = wilc_alloc_work(vif, handle_set_operation_mode, false);
 s32 wilc_get_inactive_time(struct wilc_vif *vif, const u8 *mac,
                           u32 *out_val)
 {
-       s32 result = 0;
+       s32 result;
        struct host_if_msg *msg;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
 
 int wilc_get_rssi(struct wilc_vif *vif, s8 *rssi_level)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        if (!rssi_level) {
 int
 wilc_get_statistics(struct wilc_vif *vif, struct rf_info *stats, bool is_sync)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_get_statistics, is_sync);
              size_t ies_len, wilc_scan_result scan_result, void *user_arg,
              struct hidden_network *hidden_network)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct scan_attr *scan_info;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
 void wilc_network_info_received(struct wilc *wilc, u8 *buffer, u32 length)
 {
-       s32 result = 0;
+       s32 result;
        struct host_if_msg *msg;
        int id;
-       struct host_if_drv *hif_drv = NULL;
+       struct host_if_drv *hif_drv;
        struct wilc_vif *vif;
 
        id = buffer[length - 4];
 
 void wilc_gnrl_async_info_received(struct wilc *wilc, u8 *buffer, u32 length)
 {
-       s32 result = 0;
+       s32 result;
        struct host_if_msg *msg;
        int id;
-       struct host_if_drv *hif_drv = NULL;
+       struct host_if_drv *hif_drv;
        struct wilc_vif *vif;
 
        mutex_lock(&hif_deinit_lock);
 
 void wilc_scan_complete_received(struct wilc *wilc, u8 *buffer, u32 length)
 {
-       s32 result = 0;
+       s32 result;
        int id;
-       struct host_if_drv *hif_drv = NULL;
+       struct host_if_drv *hif_drv;
        struct wilc_vif *vif;
 
        id = buffer[length - 4];
                           wilc_remain_on_chan_ready ready,
                           void *user_arg)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_remain_on_chan_work, false);
 
 int wilc_listen_state_expired(struct wilc_vif *vif, u32 session_id)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
 
 int wilc_frame_register(struct wilc_vif *vif, u16 frame_type, bool reg)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_register_frame, false);
 int wilc_add_beacon(struct wilc_vif *vif, u32 interval, u32 dtim_period,
                    u32 head_len, u8 *head, u32 tail_len, u8 *tail)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct beacon_attr *beacon_info;
 
 
 int wilc_del_beacon(struct wilc_vif *vif)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_del_beacon, false);
 
 int wilc_add_station(struct wilc_vif *vif, struct add_sta_param *sta_param)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct add_sta_param *add_sta_info;
 
 
 int wilc_del_station(struct wilc_vif *vif, const u8 *mac_addr)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct del_sta *del_sta_info;
 
 
 int wilc_del_allstation(struct wilc_vif *vif, u8 mac_addr[][ETH_ALEN])
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct del_all_sta *del_all_sta_info;
        u8 zero_addr[ETH_ALEN] = {0};
 int wilc_edit_station(struct wilc_vif *vif,
                      struct add_sta_param *sta_param)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
        struct add_sta_param *add_sta_info;
 
 
 int wilc_set_power_mgmt(struct wilc_vif *vif, bool enabled, u32 timeout)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        if (wilc_wlan_get_num_conn_ifcs(vif->wilc) == 2 && enabled)
 int wilc_setup_multicast_filter(struct wilc_vif *vif, bool enabled,
                                u32 count)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_set_mcast_filter, false);
 
 int wilc_setup_ipaddress(struct wilc_vif *vif, u8 *ip_addr, u8 idx)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_set_ip_address, false);
 
 static int host_int_get_ipaddress(struct wilc_vif *vif, u8 *ip_addr, u8 idx)
 {
-       int result = 0;
+       int result;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_get_ip_address, false);
 
 int wilc_set_tx_power(struct wilc_vif *vif, u8 tx_power)
 {
-       int ret = 0;
+       int ret;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_set_tx_pwr, false);
 
 int wilc_get_tx_power(struct wilc_vif *vif, u8 *tx_power)
 {
-       int ret = 0;
+       int ret;
        struct host_if_msg *msg;
 
        msg = wilc_alloc_work(vif, handle_get_tx_pwr, true);