up(&hif_sema_driver);
 
        if (result) {
-               PRINT_ER("Failed to set driver handler\n");
+               netdev_err(vif->ndev, "Failed to set driver handler\n");
                return -EINVAL;
        }
 
                up(&hif_sema_driver);
 
        if (result) {
-               PRINT_ER("Failed to set driver handler\n");
+               netdev_err(vif->ndev, "Failed to set driver handler\n");
                return -EINVAL;
        }
 
        host_int_get_ipaddress(vif, firmware_ip_addr, idx);
 
        if (result) {
-               PRINT_ER("Failed to set IP address\n");
+               netdev_err(vif->ndev, "Failed to set IP address\n");
                return -EINVAL;
        }
 
                wilc_setup_ipaddress(vif, set_ip[idx], idx);
 
        if (result != 0) {
-               PRINT_ER("Failed to get IP address\n");
+               netdev_err(vif->ndev, "Failed to get IP address\n");
                return -EINVAL;
        }
 
                                      wilc_get_vif_idx(vif));
 
        if (result) {
-               PRINT_ER("Failed to get mac address\n");
+               netdev_err(vif->ndev, "Failed to get mac address\n");
                result = -EFAULT;
        }
        up(&hif_sema_wait_response);
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.bss_type = (u8)cfg_param_attr->cfg_attr_info.bss_type;
                } else {
-                       PRINT_ER("check value 6 over\n");
+                       netdev_err(vif->ndev, "check value 6 over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.auth_type = (u8)cfg_param_attr->cfg_attr_info.auth_type;
                } else {
-                       PRINT_ER("Impossible value \n");
+                       netdev_err(vif->ndev, "Impossible value \n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.auth_timeout = cfg_param_attr->cfg_attr_info.auth_timeout;
                } else {
-                       PRINT_ER("Range(1 ~ 65535) over\n");
+                       netdev_err(vif->ndev, "Range(1 ~ 65535) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.power_mgmt_mode = (u8)cfg_param_attr->cfg_attr_info.power_mgmt_mode;
                } else {
-                       PRINT_ER("Invalid power mode\n");
+                       netdev_err(vif->ndev, "Invalid power mode\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.short_retry_limit = cfg_param_attr->cfg_attr_info.short_retry_limit;
                } else {
-                       PRINT_ER("Range(1~256) over\n");
+                       netdev_err(vif->ndev, "Range(1~256) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.long_retry_limit = cfg_param_attr->cfg_attr_info.long_retry_limit;
                } else {
-                       PRINT_ER("Range(1~256) over\n");
+                       netdev_err(vif->ndev, "Range(1~256) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.frag_threshold = cfg_param_attr->cfg_attr_info.frag_threshold;
                } else {
-                       PRINT_ER("Threshold Range fail\n");
+                       netdev_err(vif->ndev, "Threshold Range fail\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.rts_threshold = cfg_param_attr->cfg_attr_info.rts_threshold;
                } else {
-                       PRINT_ER("Threshold Range fail\n");
+                       netdev_err(vif->ndev, "Threshold Range fail\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.preamble_type = cfg_param_attr->cfg_attr_info.preamble_type;
                } else {
-                       PRINT_ER("Preamle Range(0~2) over\n");
+                       netdev_err(vif->ndev, "Preamle Range(0~2) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.short_slot_allowed = (u8)cfg_param_attr->cfg_attr_info.short_slot_allowed;
                } else {
-                       PRINT_ER("Short slot(2) over\n");
+                       netdev_err(vif->ndev, "Short slot(2) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.txop_prot_disabled = (u8)cfg_param_attr->cfg_attr_info.txop_prot_disabled;
                } else {
-                       PRINT_ER("TXOP prot disable\n");
+                       netdev_err(vif->ndev, "TXOP prot disable\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.beacon_interval = cfg_param_attr->cfg_attr_info.beacon_interval;
                } else {
-                       PRINT_ER("Beacon interval(1~65535) fail\n");
+                       netdev_err(vif->ndev, "Beacon interval(1~65535)fail\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.dtim_period = cfg_param_attr->cfg_attr_info.dtim_period;
                } else {
-                       PRINT_ER("DTIM range(1~255) fail\n");
+                       netdev_err(vif->ndev, "DTIM range(1~255) fail\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(char);
                        hif_drv->cfg_values.site_survey_enabled = (u8)cfg_param_attr->cfg_attr_info.site_survey_enabled;
                } else {
-                       PRINT_ER("Site survey disable\n");
+                       netdev_err(vif->ndev, "Site survey disable\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.site_survey_scan_time = cfg_param_attr->cfg_attr_info.site_survey_scan_time;
                } else {
-                       PRINT_ER("Site survey scan time(1~65535) over\n");
+                       netdev_err(vif->ndev, "Site scan time(1~65535) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.active_scan_time = cfg_param_attr->cfg_attr_info.active_scan_time;
                } else {
-                       PRINT_ER("Active scan time(1~65535) over\n");
+                       netdev_err(vif->ndev, "Active time(1~65535) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.passive_scan_time = cfg_param_attr->cfg_attr_info.passive_scan_time;
                } else {
-                       PRINT_ER("Passive scan time(1~65535) over\n");
+                       netdev_err(vif->ndev, "Passive time(1~65535) over\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                        wid_list[wid_cnt].size = sizeof(u16);
                        hif_drv->cfg_values.curr_tx_rate = (u8)curr_tx_rate;
                } else {
-                       PRINT_ER("out of TX rate\n");
+                       netdev_err(vif->ndev, "out of TX rate\n");
                        result = -EINVAL;
                        goto ERRORHANDLER;
                }
                                      wid_cnt, wilc_get_vif_idx(vif));
 
        if (result)
-               PRINT_ER("Error in setting CFG params\n");
+               netdev_err(vif->ndev, "Error in setting CFG params\n");
 
 ERRORHANDLER:
        up(&hif_drv->sem_cfg_values);
 
        if ((hif_drv->hif_state >= HOST_IF_SCANNING) &&
            (hif_drv->hif_state < HOST_IF_CONNECTED)) {
-               PRINT_ER("Already scan\n");
+               netdev_err(vif->ndev, "Already scan\n");
                result = -EBUSY;
                goto ERRORHANDLER;
        }
 
        if (wilc_optaining_ip || wilc_connecting) {
-               PRINT_ER("Don't do obss scan\n");
+               netdev_err(vif->ndev, "Don't do obss scan\n");
                result = -EBUSY;
                goto ERRORHANDLER;
        }
                                      wilc_get_vif_idx(vif));
 
        if (result)
-               PRINT_ER("Failed to send scan parameters config packet\n");
+               netdev_err(vif->ndev, "Failed to send scan parameters\n");
 
 ERRORHANDLER:
        if (result) {
                                              wilc_get_vif_idx(vif));
 
                if (result) {
-                       PRINT_ER("Failed to set abort running scan\n");
+                       netdev_err(vif->ndev, "Failed to set abort running\n");
                        result = -EFAULT;
                }
        }
 
        if (!hif_drv) {
-               PRINT_ER("Driver handler is NULL\n");
+               netdev_err(vif->ndev, "Driver handler is NULL\n");
                return result;
        }
 
 
        if (memcmp(pstrHostIFconnectAttr->bssid, wilc_connected_ssid, ETH_ALEN) == 0) {
                result = 0;
-               PRINT_ER("Trying to connect to an already connected AP, Discard connect request\n");
+               netdev_err(vif->ndev, "Discard connect request\n");
                return result;
        }
 
        ptstrJoinBssParam = pstrHostIFconnectAttr->params;
        if (!ptstrJoinBssParam) {
-               PRINT_ER("Required BSSID not found\n");
+               netdev_err(vif->ndev, "Required BSSID not found\n");
                result = -ENOENT;
                goto ERRORHANDLER;
        }
        if ((pstrHostIFconnectAttr->ch >= 1) && (pstrHostIFconnectAttr->ch <= 14)) {
                *(pu8CurrByte++) = pstrHostIFconnectAttr->ch;
        } else {
-               PRINT_ER("Channel out of range\n");
+               netdev_err(vif->ndev, "Channel out of range\n");
                *(pu8CurrByte++) = 0xFF;
        }
        *(pu8CurrByte++)  = (ptstrJoinBssParam->cap_info) & 0xFF;
                                      u32WidsCount,
                                      wilc_get_vif_idx(vif));
        if (result) {
-               PRINT_ER("failed to send config packet\n");
+               netdev_err(vif->ndev, "failed to send config packet\n");
                result = -EFAULT;
                goto ERRORHANDLER;
        } else {
                        strConnectInfo.pu8ReqIEs = NULL;
 
                } else {
-                       PRINT_ER("Connect callback function pointer is NULL\n");
+                       netdev_err(vif->ndev, "Connect callback is NULL\n");
                }
        }
 
                                      u32WidsCount,
                                      wilc_get_vif_idx(join_req_vif));
        if (result) {
-               PRINT_ER("failed to send config packet\n");
+               netdev_err(vif->ndev, "failed to send config packet\n");
                result = -EINVAL;
        }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("Driver handler is NULL\n");
+               netdev_err(vif->ndev, "Driver handler is NULL\n");
                return result;
        }
 
                kfree(strConnectInfo.pu8ReqIEs);
                strConnectInfo.pu8ReqIEs = NULL;
        } else {
-               PRINT_ER("Connect callback function pointer is NULL\n");
+               netdev_err(vif->ndev, "Connect callback is NULL\n");
        }
 
        wid.id = (u16)WID_DISCONNECT;
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send dissconect config packet\n");
+               netdev_err(vif->ndev, "Failed to send dissconect\n");
 
        hif_drv->usr_conn_req.ssid_len = 0;
        kfree(hif_drv->usr_conn_req.ssid);
                wilc_parse_network_info(pstrRcvdNetworkInfo->buffer, &pstrNetworkInfo);
                if ((!pstrNetworkInfo) ||
                    (!hif_drv->usr_scan_req.scan_result)) {
-                       PRINT_ER("driver is null\n");
+                       netdev_err(vif->ndev, "driver is null\n");
                        result = -EINVAL;
                        goto done;
                }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("Driver handler is NULL\n");
+               netdev_err(vif->ndev, "Driver handler is NULL\n");
                return -ENODEV;
        }
 
            hif_drv->usr_scan_req.scan_result) {
                if (!pstrRcvdGnrlAsyncInfo->buffer ||
                    !hif_drv->usr_conn_req.conn_result) {
-                       PRINT_ER("driver is null\n");
+                       netdev_err(vif->ndev, "driver is null\n");
                        return -EINVAL;
                }
 
                u8MsgType = pstrRcvdGnrlAsyncInfo->buffer[0];
 
                if ('I' != u8MsgType) {
-                       PRINT_ER("Received Message format incorrect.\n");
+                       netdev_err(vif->ndev, "Received Message incorrect.\n");
                        return -EFAULT;
                }
 
                                        s32Err = wilc_parse_assoc_resp_info(rcv_assoc_resp, u32RcvdAssocRespInfoLen,
                                                                    &pstrConnectRespInfo);
                                        if (s32Err) {
-                                               PRINT_ER("wilc_parse_assoc_resp_info() returned error %d\n", s32Err);
+                                               netdev_err(vif->ndev, "wilc_parse_assoc_resp_info() returned error %d\n", s32Err);
                                        } else {
                                                strConnectInfo.u16ConnectStatus = pstrConnectRespInfo->status;
 
 
                        if ((u8MacStatus == MAC_CONNECTED) &&
                            (strConnectInfo.u16ConnectStatus != SUCCESSFUL_STATUSCODE)) {
-                               PRINT_ER("Received MAC status is MAC_CONNECTED while the received status code in Asoc Resp is not SUCCESSFUL_STATUSCODE\n");
+                               netdev_err(vif->ndev, "Received MAC status is MAC_CONNECTED while the received status code in Asoc Resp is not SUCCESSFUL_STATUSCODE\n");
                                eth_zero_addr(wilc_connected_ssid);
                        } else if (u8MacStatus == MAC_DISCONNECTED)    {
-                               PRINT_ER("Received MAC status is MAC_DISCONNECTED\n");
+                               netdev_err(vif->ndev, "Received MAC status is MAC_DISCONNECTED\n");
                                eth_zero_addr(wilc_connected_ssid);
                        }
 
                                                                  &strDisconnectNotifInfo,
                                                                  hif_drv->usr_conn_req.arg);
                        } else {
-                               PRINT_ER("Connect result callback function is NULL\n");
+                               netdev_err(vif->ndev, "Connect result NULL\n");
                        }
 
                        eth_zero_addr(hif_drv->assoc_bssid);
                        if (hif_drv->hif_state == HOST_IF_CONNECTED)
                                memcpy(pu8keybuf, hif_drv->assoc_bssid, ETH_ALEN);
                        else
-                               PRINT_ER("Couldn't handle WPARxGtk while state is not HOST_IF_CONNECTED\n");
+                               netdev_err(vif->ndev, "Couldn't handle\n");
 
                        memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->attr.wpa.seq, 8);
                        memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->attr.wpa.index, 1);
                } else if (pstrHostIFkeyAttr->action & ADDKEY) {
                        pu8keybuf = kmalloc(PTK_KEY_MSG_LEN, GFP_KERNEL);
                        if (!pu8keybuf) {
-                               PRINT_ER("No buffer to send PTK Key\n");
+                               netdev_err(vif->ndev, "No buffer send PTK\n");
                                ret = -ENOMEM;
                                goto _WPAPtk_end_case_;
                        }
        case PMKSA:
                pu8keybuf = kmalloc((pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1, GFP_KERNEL);
                if (!pu8keybuf) {
-                       PRINT_ER("No buffer to send PMKSA Key\n");
+                       netdev_err(vif->ndev, "No buffer to send PMKSA Key\n");
                        return -ENOMEM;
                }
 
        }
 
        if (result)
-               PRINT_ER("Failed to send key config packet\n");
+               netdev_err(vif->ndev, "Failed to send key config packet\n");
 
        return result;
 }
                                      wilc_get_vif_idx(vif));
 
        if (result) {
-               PRINT_ER("Failed to send dissconect config packet\n");
+               netdev_err(vif->ndev, "Failed to send dissconect\n");
        } else {
                tstrDisconnectNotifInfo strDisconnectNotifInfo;
 
                                                          &strDisconnectNotifInfo,
                                                          hif_drv->usr_conn_req.arg);
                } else {
-                       PRINT_ER("usr_conn_req.conn_result = NULL\n");
+                       netdev_err(vif->ndev, "conn_result = NULL\n");
                }
 
                scan_while_connected = false;
                                      wilc_get_vif_idx(vif));
 
        if (result) {
-               PRINT_ER("Failed to get channel number\n");
+               netdev_err(vif->ndev, "Failed to get channel number\n");
                result = -EFAULT;
        }
 
        result = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result) {
-               PRINT_ER("Failed to get RSSI value\n");
+               netdev_err(vif->ndev, "Failed to get RSSI value\n");
                result = -EFAULT;
        }
 
        result = wilc_send_config_pkt(vif, GET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result) {
-               PRINT_ER("Failed to get LINKSPEED value\n");
+               netdev_err(vif->ndev, "Failed to get LINKSPEED value\n");
                result = -EFAULT;
        }
 
                                      wilc_get_vif_idx(vif));
 
        if (result)
-               PRINT_ER("Failed to send scan parameters config packet\n");
+               netdev_err(vif->ndev, "Failed to send scan parameters\n");
 
        if (pstrStatistics->link_speed > TCP_ACK_FILTER_LINK_SPEED_THRESH &&
            pstrStatistics->link_speed != DEFAULT_LINK_SPEED)
                                      wilc_get_vif_idx(vif));
 
        if (result) {
-               PRINT_ER("Failed to SET incative time\n");
+               netdev_err(vif->ndev, "Failed to SET incative time\n");
                return -EFAULT;
        }
 
                                      wilc_get_vif_idx(vif));
 
        if (result) {
-               PRINT_ER("Failed to get incative time\n");
+               netdev_err(vif->ndev, "Failed to get incative time\n");
                return -EFAULT;
        }
 
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send add beacon config packet\n");
+               netdev_err(vif->ndev, "Failed to send add beacon\n");
 
 ERRORHANDLER:
        kfree(wid.val);
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send delete beacon config packet\n");
+               netdev_err(vif->ndev, "Failed to send delete beacon\n");
 }
 
 static u32 WILC_HostIf_PackStaParam(u8 *pu8Buffer,
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result != 0)
-               PRINT_ER("Failed to send add station config packet\n");
+               netdev_err(vif->ndev, "Failed to send add station\n");
 
 ERRORHANDLER:
        kfree(pstrStationParam->rates);
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send add station config packet\n");
+               netdev_err(vif->ndev, "Failed to send add station\n");
 
 ERRORHANDLER:
        kfree(wid.val);
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send add station config packet\n");
+               netdev_err(vif->ndev, "Failed to send add station\n");
 
 ERRORHANDLER:
        kfree(wid.val);
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send edit station config packet\n");
+               netdev_err(vif->ndev, "Failed to send edit station\n");
 
 ERRORHANDLER:
        kfree(pstrStationParam->rates);
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result != 0)
-               PRINT_ER("Failed to set remain on channel\n");
+               netdev_err(vif->ndev, "Failed to set remain on channel\n");
 
 ERRORHANDLER:
        {
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result) {
-               PRINT_ER("Failed to frame register config packet\n");
+               netdev_err(vif->ndev, "Failed to frame register\n");
                result = -EINVAL;
        }
 
                wid.val = kmalloc(wid.size, GFP_KERNEL);
 
                if (!wid.val) {
-                       PRINT_ER("Failed to allocate memory\n");
+                       netdev_err(vif->ndev, "Failed to allocate memory\n");
                        return -ENOMEM;
                }
 
                result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                              wilc_get_vif_idx(vif));
                if (result != 0) {
-                       PRINT_ER("Failed to set remain on channel\n");
+                       netdev_err(vif->ndev, "Failed to set remain channel\n");
                        goto _done_;
                }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
 }
 
 static void Handle_PowerManagement(struct wilc_vif *vif,
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send power management config packet\n");
+               netdev_err(vif->ndev, "Failed to send power management\n");
 }
 
 static void Handle_SetMulticastFilter(struct wilc_vif *vif,
        result = wilc_send_config_pkt(vif, SET_CFG, &wid, 1,
                                      wilc_get_vif_idx(vif));
        if (result)
-               PRINT_ER("Failed to send setup multicast config packet\n");
+               netdev_err(vif->ndev, "Failed to send setup multicast\n");
 
 ERRORHANDLER:
        kfree(wid.val);
                        handle_get_tx_pwr(msg.vif, &msg.body.tx_power.tx_pwr);
                        break;
                default:
-                       PRINT_ER("[Host Interface] undefined Received Msg ID\n");
+                       netdev_err(vif->ndev, "[Host Interface] undefined\n");
                        break;
                }
        }
 
        if (!hif_drv) {
                result = -EFAULT;
-               PRINT_ER("Failed to send setup multicast config packet\n");
+               netdev_err(vif->ndev, "Failed to send setup multicast\n");
                return result;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Error in sending message queue : Request to remove WEP key\n");
+               netdev_err(vif->ndev, "Request to remove WEP key\n");
        down(&hif_drv->sem_test_key_block);
 
        return result;
 
        if (!hif_drv) {
                result = -EFAULT;
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return result;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Error in sending message queue : Default key index\n");
+               netdev_err(vif->ndev, "Default key index\n");
        down(&hif_drv->sem_test_key_block);
 
        return result;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Error in sending message queue :WEP Key\n");
+               netdev_err(vif->ndev, "STA - WEP Key\n");
        down(&hif_drv->sem_test_key_block);
 
        return result;
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
 
        if (result)
-               PRINT_ER("Error in sending message queue :WEP Key\n");
+               netdev_err(vif->ndev, "AP - WEP Key\n");
        down(&hif_drv->sem_test_key_block);
 
        return result;
        u8 key_len = ptk_key_len;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
 
        if (result)
-               PRINT_ER("Error in sending message queue:  PTK Key\n");
+               netdev_err(vif->ndev, "PTK Key\n");
 
        down(&hif_drv->sem_test_key_block);
 
        u8 key_len = gtk_key_len;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
        memset(&msg, 0, sizeof(struct host_if_msg));
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Error in sending message queue:  RX GTK\n");
+               netdev_err(vif->ndev, "RX GTK\n");
 
        down(&hif_drv->sem_test_key_block);
 
        int i;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER(" Error in sending messagequeue: PMKID Info\n");
+               netdev_err(vif->ndev, "PMKID Info\n");
 
        return result;
 }
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("Failed to send get mac address\n");
+               netdev_err(vif->ndev, "Failed to send get mac address\n");
                return -EFAULT;
        }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv || !connect_result) {
-               PRINT_ER("Driver is null\n");
+               netdev_err(vif->ndev, "Driver is null\n");
                return -EFAULT;
        }
 
        if (!join_params) {
-               PRINT_ER("Unable to Join - JoinParams is NULL\n");
+               netdev_err(vif->ndev, "Unable to Join - JoinParams is NULL\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("Failed to send message queue: Set join request\n");
+               netdev_err(vif->ndev, "send message: Set join request\n");
                return -EFAULT;
        }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("Driver is null\n");
+               netdev_err(vif->ndev, "Driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Failed to send message queue: disconnect\n");
+               netdev_err(vif->ndev, "Failed to send message: disconnect\n");
 
        down(&hif_drv->sem_test_disconn_block);
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("Driver is null\n");
+               netdev_err(vif->ndev, "Driver is null\n");
                return -EFAULT;
        }
 
                                      wilc_get_vif_idx(vif));
        if (result) {
                *pu32RcvdAssocRespInfoLen = 0;
-               PRINT_ER("Failed to send association response config packet\n");
+               netdev_err(vif->ndev, "Failed to send association response\n");
                return -EINVAL;
        }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("wilc mq send fail\n");
+               netdev_err(vif->ndev, "wilc mq send fail\n");
                return -EINVAL;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("wilc mq send fail\n");
+               netdev_err(vif->ndev, "wilc mq send fail\n");
                result = -EINVAL;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("wilc mq send fail\n");
+               netdev_err(vif->ndev, "wilc mq send fail\n");
                result = -EINVAL;
        }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Failed to send get host channel param's message queue ");
+               netdev_err(vif->ndev, "Failed to send get host ch param\n");
 
        down(&hif_drv->sem_inactive_time);
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("Failed to send get host channel param's message queue ");
+               netdev_err(vif->ndev, "Failed to send get host ch param\n");
                return -EFAULT;
        }
 
        down(&hif_drv->sem_get_rssi);
 
        if (!rssi_level) {
-               PRINT_ER("RSS pointer value is null");
+               netdev_err(vif->ndev, "RSS pointer value is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("Failed to send get host channel param's message queue ");
+               netdev_err(vif->ndev, "Failed to send get host channel\n");
                return -EFAULT;
        }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv || !scan_result) {
-               PRINT_ER("hif_drv or scan_result = NULL\n");
+               netdev_err(vif->ndev, "hif_drv or scan_result = NULL\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result) {
-               PRINT_ER("Error in sending message queue\n");
+               netdev_err(vif->ndev, "Error in sending message queue\n");
                return -EINVAL;
        }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("hif_drv NULL\n");
+               netdev_err(vif->ndev, "hif_drv NULL\n");
                return -EFAULT;
        }
 
        struct wilc_vif *vif = (struct wilc_vif *)arg;
 
        if (!vif->hif_drv) {
-               PRINT_ER("Driver handler is NULL\n");
+               netdev_err(vif->ndev, "Driver handler is NULL\n");
                return;
        }
 
                result = wilc_mq_create(&hif_msg_q);
 
                if (result < 0) {
-                       PRINT_ER("Failed to creat MQ\n");
+                       netdev_err(vif->ndev, "Failed to creat MQ\n");
                        goto _fail_;
                }
 
                                                 "WILC_kthread");
 
                if (IS_ERR(hif_thread_handler)) {
-                       PRINT_ER("Failed to creat Thread\n");
+                       netdev_err(vif->ndev, "Failed to creat Thread\n");
                        result = -EFAULT;
                        goto _fail_mq_;
                }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv)   {
-               PRINT_ER("hif_drv = NULL\n");
+               netdev_err(vif->ndev, "hif_drv = NULL\n");
                return -EFAULT;
        }
 
 
                result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
                if (result != 0)
-                       PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", result);
+                       netdev_err(vif->ndev, "deinit : Error(%d)\n", result);
 
                down(&hif_sema_thread);
 
        hif_drv = vif->hif_drv;
 
        if (!hif_drv || hif_drv == terminated_handle)   {
-               PRINT_ER("NetworkInfo received but driver not init[%p]\n", hif_drv);
+               netdev_err(vif->ndev, "driver not init[%p]\n", hif_drv);
                return;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", result);
+               netdev_err(vif->ndev, "message parameters (%d)\n", result);
 }
 
 void wilc_gnrl_async_info_received(struct wilc *wilc, u8 *pu8Buffer,
        }
 
        if (!hif_drv->usr_conn_req.conn_result) {
-               PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n");
+               netdev_err(vif->ndev, "there is no current Connect Request\n");
                up(&hif_sema_deinit);
                return;
        }
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", result);
+               netdev_err(vif->ndev, "synchronous info (%d)\n", result);
 
        up(&hif_sema_deinit);
 }
 
                result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
                if (result)
-                       PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", result);
+                       netdev_err(vif->ndev, "complete param (%d)\n", result);
        }
 }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc mq send fail\n");
+               netdev_err(vif->ndev, "wilc mq send fail\n");
 
        return result;
 }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc mq send fail\n");
+               netdev_err(vif->ndev, "wilc mq send fail\n");
 
        return result;
 }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc mq send fail\n");
+               netdev_err(vif->ndev, "wilc mq send fail\n");
 
        return result;
 }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc mq send fail\n");
+               netdev_err(vif->ndev, "wilc mq send fail\n");
 
 ERRORHANDLER:
        if (result) {
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
 
        return result;
 }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
        return result;
 }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
        return result;
 }
 
        u8 assoc_sta = 0;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
 
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
 
        down(&hif_sema_wait_response);
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
 
        return result;
 }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
        return result;
 }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
        return result;
 }
 
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
 
        return result;
 }
        struct host_if_drv *hif_drv = vif->hif_drv;
 
        if (!hif_drv) {
-               PRINT_ER("driver is null\n");
+               netdev_err(vif->ndev, "driver is null\n");
                return -EFAULT;
        }
 
 
        result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
        if (result)
-               PRINT_ER("wilc_mq_send fail\n");
+               netdev_err(vif->ndev, "wilc_mq_send fail\n");
 
        return result;
 }