These functions now return void * and no longer need casts.
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(
-               sizeof(struct set_stakey_parm)
-       );
+       psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm));
        if (psetstakey_para == NULL) {
                kfree((u8 *) ph2c);
                res = _FAIL;
 
        /* DBG_871X("%s\n", __func__); */
 
-       pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd == NULL) {
                res = _FAIL;
                goto exit;
        }
-       psetkeyparm = (struct setkey_parm *)rtw_zmalloc(sizeof(struct setkey_parm));
+       psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
        if (psetkeyparm == NULL) {
                kfree((unsigned char *)pcmd);
                res = _FAIL;
 
                rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 1);
        }
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL)
                return _FAIL;
 
-       psurveyPara = (struct sitesurvey_parm *)rtw_zmalloc(sizeof(struct sitesurvey_parm));
+       psurveyPara = rtw_zmalloc(sizeof(struct sitesurvey_parm));
        if (psurveyPara == NULL) {
                kfree((unsigned char *) ph2c);
                return _FAIL;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pbsetdataratepara = (struct setdatarate_parm *)rtw_zmalloc(sizeof(struct setdatarate_parm));
+       pbsetdataratepara = rtw_zmalloc(sizeof(struct setdatarate_parm));
        if (pbsetdataratepara == NULL) {
                kfree((u8 *) ph2c);
                res = _FAIL;
                RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, (" createbss for SSid:%s\n", pmlmepriv->assoc_ssid.Ssid));
        }
 
-       pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd == NULL) {
                res = _FAIL;
                goto exit;
                start_bss_network(padapter, (u8 *)&(padapter->mlmepriv.cur_network.network));
        } else {
                /* need enqueue, prepare cmd_obj and enqueue */
-               pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+               pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
                if (pcmd == NULL) {
                        res = _FAIL;
                        goto exit;
                RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+Join cmd: SSid =[%s]\n", pmlmepriv->assoc_ssid.Ssid));
        }
 
-       pcmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd == NULL) {
                res = _FAIL;
                RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("rtw_joinbss_cmd: memory allocate for cmd_obj fail!!!\n"));
        RT_TRACE(_module_rtl871x_cmd_c_, _drv_notice_, ("+rtw_disassoc_cmd\n"));
 
        /* prepare cmd parameter */
-       param = (struct disconnect_parm *)rtw_zmalloc(sizeof(*param));
+       param = rtw_zmalloc(sizeof(*param));
        if (param == NULL) {
                res = _FAIL;
                goto exit;
 
        if (enqueue) {
                /* need enqueue, prepare cmd_obj and enqueue */
-               cmdobj = (struct cmd_obj *)rtw_zmalloc(sizeof(*cmdobj));
+               cmdobj = rtw_zmalloc(sizeof(*cmdobj));
                if (cmdobj == NULL) {
                        res = _FAIL;
                        kfree((u8 *)param);
        struct  cmd_priv   *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       psetop = (struct setopmode_parm *)rtw_zmalloc(sizeof(struct setopmode_parm));
+       psetop = rtw_zmalloc(sizeof(struct setopmode_parm));
 
        if (psetop == NULL) {
                res = _FAIL;
        psetop->mode = (u8)networktype;
 
        if (enqueue) {
-               ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+               ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
                if (ph2c == NULL) {
                        kfree((u8 *)psetop);
                        res = _FAIL;
        struct security_priv    *psecuritypriv = &padapter->securitypriv;
        u8 res = _SUCCESS;
 
-       psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
+       psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm));
        if (psetstakey_para == NULL) {
                res = _FAIL;
                goto exit;
        padapter->securitypriv.busetkipkey = true;
 
        if (enqueue) {
-               ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+               ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
                if (ph2c == NULL) {
                        kfree((u8 *) psetstakey_para);
                        res = _FAIL;
                        goto exit;
                }
 
-               psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
+               psetstakey_rsp = rtw_zmalloc(sizeof(struct set_stakey_rsp));
                if (psetstakey_rsp == NULL) {
                        kfree((u8 *) ph2c);
                        kfree((u8 *) psetstakey_para);
                        rtw_camid_free(padapter, cam_id);
                }
        } else{
-               ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+               ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
                if (ph2c == NULL) {
                        res = _FAIL;
                        goto exit;
                }
 
-               psetstakey_para = (struct set_stakey_parm *)rtw_zmalloc(sizeof(struct set_stakey_parm));
+               psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm));
                if (psetstakey_para == NULL) {
                        kfree((u8 *) ph2c);
                        res = _FAIL;
                        goto exit;
                }
 
-               psetstakey_rsp = (struct set_stakey_rsp *)rtw_zmalloc(sizeof(struct set_stakey_rsp));
+               psetstakey_rsp = rtw_zmalloc(sizeof(struct set_stakey_rsp));
                if (psetstakey_rsp == NULL) {
                        kfree((u8 *) ph2c);
                        kfree((u8 *) psetstakey_para);
 
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       paddbareq_parm = (struct addBaReq_parm *)rtw_zmalloc(sizeof(struct addBaReq_parm));
+       paddbareq_parm = rtw_zmalloc(sizeof(struct addBaReq_parm));
        if (paddbareq_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
        u8 res = _SUCCESS;
 
        /* only  primary padapter does this cmd */
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
        }
 
        /* prepare cmd parameter */
-       setChannelPlan_param = (struct  SetChannelPlan_param *)rtw_zmalloc(sizeof(struct SetChannelPlan_param));
+       setChannelPlan_param = rtw_zmalloc(sizeof(struct SetChannelPlan_param));
        if (setChannelPlan_param == NULL) {
                res = _FAIL;
                goto exit;
 
        if (enqueue) {
                /* need enqueue, prepare cmd_obj and enqueue */
-               pcmdobj = (struct       cmd_obj *)rtw_zmalloc(sizeof(struct     cmd_obj));
+               pcmdobj = rtw_zmalloc(sizeof(struct cmd_obj));
                if (pcmdobj == NULL) {
                        kfree((u8 *)setChannelPlan_param);
                        res = _FAIL;
        /*      return res; */
 
        if (enqueue) {
-               ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+               ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
                if (ph2c == NULL) {
                        res = _FAIL;
                        goto exit;
                }
 
-               pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+               pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
                if (pdrvextra_cmd_parm == NULL) {
                        kfree((unsigned char *)ph2c);
                        res = _FAIL;
        u8 res = _SUCCESS;
 
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
        u8 res = _SUCCESS;
 
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ppscmd = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ppscmd = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ppscmd == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((unsigned char *)ppscmd);
                res = _FAIL;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((u8 *)ph2c);
                res = _FAIL;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       pdrvextra_cmd_parm = (struct drvextra_cmd_parm *)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
+       pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
        if (pdrvextra_cmd_parm == NULL) {
                kfree((u8 *)ph2c);
                res = _FAIL;
                        /* This C2H event is read, clear it */
                        c2h_evt_clear(adapter);
                } else{
-                       c2h_evt = (u8 *)rtw_malloc(16);
+                       c2h_evt = rtw_malloc(16);
                        if (c2h_evt != NULL) {
                                /* This C2H event is not read, read & clear now */
                                if (rtw_hal_c2h_evt_read(adapter, c2h_evt) != _SUCCESS) {
 
        struct  cmd_priv *pcmdpriv = &(adapter->cmdpriv);
        sint            res = _SUCCESS;
 
-       pcmd = (struct  cmd_obj *)rtw_zmalloc(sizeof(struct     cmd_obj));
+       pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd == NULL) {
                res = _FAIL;  /* try again */
                goto exit;
        }
 
-       psetauthparm = (struct setauth_parm *)rtw_zmalloc(sizeof(struct setauth_parm));
+       psetauthparm = rtw_zmalloc(sizeof(struct setauth_parm));
        if (psetauthparm == NULL) {
                kfree((unsigned char *)pcmd);
                res = _FAIL;
        struct cmd_priv         *pcmdpriv = &(adapter->cmdpriv);
        sint    res = _SUCCESS;
 
-       psetkeyparm = (struct setkey_parm *)rtw_zmalloc(sizeof(struct setkey_parm));
+       psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
        if (psetkeyparm == NULL) {
                res = _FAIL;
                goto exit;
 
 
        if (enqueue) {
-               pcmd = (struct  cmd_obj *)rtw_zmalloc(sizeof(struct     cmd_obj));
+               pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
                if (pcmd == NULL) {
                        kfree((unsigned char *)psetkeyparm);
                        res = _FAIL;  /* try again */
 
        if (!memcmp(GetAddr3Ptr(pframe), get_my_bssid(&pmlmeinfo->network), ETH_ALEN)) {
                if (pmlmeinfo->state & WIFI_FW_AUTH_NULL) {
                        /* we should update current network before auth, or some IE is wrong */
-                       pbss = (struct wlan_bssid_ex *)rtw_malloc(sizeof(struct wlan_bssid_ex));
+                       pbss = rtw_malloc(sizeof(struct wlan_bssid_ex));
                        if (pbss) {
                                if (collect_bss_info(padapter, precv_frame, pbss) == _SUCCESS) {
                                        update_network(&(pmlmepriv->cur_network.network), pbss, padapter, true);
        pmlmeext = &padapter->mlmeextpriv;
        pcmdpriv = &padapter->cmdpriv;
 
-       pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd_obj == NULL)
                return;
 
        cmdsz = (sizeof(struct survey_event) + sizeof(struct C2HEvent_Header));
-       pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
+       pevtcmd = rtw_zmalloc(cmdsz);
        if (pevtcmd == NULL) {
                kfree((u8 *)pcmd_obj);
                return;
        struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 
-       pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd_obj == NULL)
                return;
 
        cmdsz = (sizeof(struct surveydone_event) + sizeof(struct C2HEvent_Header));
-       pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
+       pevtcmd = rtw_zmalloc(cmdsz);
        if (pevtcmd == NULL) {
                kfree((u8 *)pcmd_obj);
                return;
        struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 
-       pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd_obj == NULL)
                return;
 
        cmdsz = (sizeof(struct joinbss_event) + sizeof(struct C2HEvent_Header));
-       pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
+       pevtcmd = rtw_zmalloc(cmdsz);
        if (pevtcmd == NULL) {
                kfree((u8 *)pcmd_obj);
                return;
        struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 
-       pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd_obj == NULL)
                return;
 
        cmdsz = (sizeof(struct wmm_event) + sizeof(struct C2HEvent_Header));
-       pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
+       pevtcmd = rtw_zmalloc(cmdsz);
        if (pevtcmd == NULL) {
                kfree((u8 *)pcmd_obj);
                return;
        struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 
-       pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd_obj == NULL) {
                return;
        }
 
        cmdsz = (sizeof(struct stadel_event) + sizeof(struct C2HEvent_Header));
-       pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
+       pevtcmd = rtw_zmalloc(cmdsz);
        if (pevtcmd == NULL) {
                kfree((u8 *)pcmd_obj);
                return;
        struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
        struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
 
-       pcmd_obj = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj));
        if (pcmd_obj == NULL)
                return;
 
        cmdsz = (sizeof(struct stassoc_event) + sizeof(struct C2HEvent_Header));
-       pevtcmd = (u8 *)rtw_zmalloc(cmdsz);
+       pevtcmd = rtw_zmalloc(cmdsz);
        if (pevtcmd == NULL) {
                kfree((u8 *)pcmd_obj);
                return;
                        pmlmeext->scan_abort = false;/* reset */
                }
 
-               ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+               ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
                if (ph2c == NULL) {
                        goto exit_survey_timer_hdl;
                }
 
-               psurveyPara = (struct sitesurvey_parm *)rtw_zmalloc(sizeof(struct sitesurvey_parm));
+               psurveyPara = rtw_zmalloc(sizeof(struct sitesurvey_parm));
                if (psurveyPara == NULL) {
                        kfree((unsigned char *)ph2c);
                        goto exit_survey_timer_hdl;
        struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
        u8 res = _SUCCESS;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        u8 res = _SUCCESS;
        int len_diff = 0;
 
-       ph2c = (struct cmd_obj *)rtw_zmalloc(sizeof(struct cmd_obj));
+       ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
        if (ph2c == NULL) {
                res = _FAIL;
                goto exit;
        }
 
-       ptxBeacon_parm = (struct Tx_Beacon_param *)rtw_zmalloc(sizeof(struct Tx_Beacon_param));
+       ptxBeacon_parm = rtw_zmalloc(sizeof(struct Tx_Beacon_param));
        if (ptxBeacon_parm == NULL) {
                kfree((unsigned char *)ph2c);
                res = _FAIL;
 
        u32 *rk;
        if (len != 16)
                return NULL;
-       rk = (u32 *)rtw_malloc(AES_PRIV_SIZE);
+       rk = rtw_malloc(AES_PRIV_SIZE);
        if (rk == NULL)
                return NULL;
        rijndaelKeySetupEnc(rk, key);
 
                return true;
        }
 
-       bssid = (struct wlan_bssid_ex *)rtw_zmalloc(sizeof(struct wlan_bssid_ex));
+       bssid = rtw_zmalloc(sizeof(struct wlan_bssid_ex));
        if (bssid == NULL) {
                DBG_871X("%s rtw_zmalloc fail !!!\n", __func__);
                return true;
 
 
        pxmitpriv->hwxmits = NULL;
 
-       pxmitpriv->hwxmits = (struct hw_xmit *)rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry);
+       pxmitpriv->hwxmits = rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry);
 
        if (pxmitpriv->hwxmits == NULL) {
                DBG_871X("alloc hwxmits fail!...\n");
 
                return;
        }
 
-       efuseTbl = (u8 *)rtw_malloc(EFUSE_MAX_MAP_LEN);
+       efuseTbl = rtw_malloc(EFUSE_MAX_MAP_LEN);
        if (efuseTbl == NULL) {
                DBG_8192C("%s: alloc efuseTbl fail!\n", __func__);
                return;
 
        } else {
                u8 *ptmpbuf;
 
-               ptmpbuf = (u8 *)rtw_malloc(8);
+               ptmpbuf = rtw_malloc(8);
                if (NULL == ptmpbuf) {
                        DBG_8192C(KERN_ERR "%s: Allocate memory FAIL!(size =8) addr = 0x%x\n", __func__, addr);
                        return SDIO_ERR_VAL32;
        }
 
        n = RND4(cnt);
-       ptmpbuf = (u8 *)rtw_malloc(n);
+       ptmpbuf = rtw_malloc(n);
        if (!ptmpbuf)
                return (-1);
 
        }
 
        n = RND4(cnt);
-       ptmpbuf = (u8 *)rtw_malloc(n);
+       ptmpbuf = rtw_malloc(n);
        if (!ptmpbuf)
                return (-1);
 
                return err;
        }
 
-       ptmpbuf = (u8 *)rtw_malloc(cnt);
+       ptmpbuf = rtw_malloc(cnt);
        if (!ptmpbuf)
                return (-1);
 
                struct c2h_evt_hdr_88xx *c2h_evt;
 
                DBG_8192C("%s: C2H Command\n", __func__);
-               c2h_evt = (struct c2h_evt_hdr_88xx *)rtw_zmalloc(16);
+               c2h_evt = rtw_zmalloc(16);
                if (c2h_evt != NULL) {
                        if (rtw_hal_c2h_evt_read(padapter, (u8 *)c2h_evt) == _SUCCESS) {
                                if (c2h_id_filter_ccx_8723b((u8 *)c2h_evt)) {
 
                goto exit;
        }
 
-       spt_band = (struct ieee80211_supported_band *)rtw_zmalloc(
-               sizeof(struct ieee80211_supported_band)
-               + sizeof(struct ieee80211_channel)*n_channels
-               + sizeof(struct ieee80211_rate)*n_bitrates
-       );
+       spt_band = rtw_zmalloc(sizeof(struct ieee80211_supported_band) +
+                              sizeof(struct ieee80211_channel) * n_channels +
+                              sizeof(struct ieee80211_rate) * n_bitrates);
        if (!spt_band)
                goto exit;
 
        DBG_871X("pairwise =%d\n", pairwise);
 
        param_len = sizeof(struct ieee_param) + params->key_len;
-       param = (struct ieee_param *)rtw_malloc(param_len);
+       param = rtw_malloc(param_len);
        if (param == NULL)
                return -1;
 
                {
                        wep_key_len = wep_key_len <= 5 ? 5 : 13;
                        wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
-                       pwep =(struct ndis_802_11_wep    *) rtw_malloc(wep_total_len);
+                       pwep = rtw_malloc(wep_total_len);
                        if (pwep == NULL) {
                                DBG_871X(" wpa_set_encryption: pwep allocate fail !!!\n");
                                ret = -ENOMEM;
        pnpi->sizeof_priv = sizeof(struct adapter);
 
        /*  wdev */
-       mon_wdev = (struct wireless_dev *)rtw_zmalloc(sizeof(struct wireless_dev));
+       mon_wdev = rtw_zmalloc(sizeof(struct wireless_dev));
        if (!mon_wdev) {
                DBG_871X(FUNC_ADPT_FMT" allocate mon_wdev fail\n", FUNC_ADPT_ARG(padapter));
                ret = -ENOMEM;
        }
 
        /*  wdev */
-       wdev = (struct wireless_dev *)rtw_zmalloc(sizeof(struct wireless_dev));
+       wdev = rtw_zmalloc(sizeof(struct wireless_dev));
        if (!wdev) {
                DBG_8192C("Couldn't allocate wireless device\n");
                ret = -ENOMEM;
 
                if (wep_key_len > 0) {
                        wep_key_len = wep_key_len <= 5 ? 5 : 13;
                        wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
-                       pwep =(struct ndis_802_11_wep    *) rtw_malloc(wep_total_len);
+                       pwep = rtw_malloc(wep_total_len);
                        if (pwep == NULL) {
                                RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, (" wpa_set_encryption: pwep allocate fail !!!\n"));
                                goto exit;
        int ret = 0;
 
        param_len = sizeof(struct ieee_param) + pext->key_len;
-       param = (struct ieee_param *)rtw_malloc(param_len);
+       param = rtw_malloc(param_len);
        if (param == NULL)
                return -1;
 
        if (0 == len)
                return -EINVAL;
 
-       ptmp = (u8 *)rtw_malloc(len);
+       ptmp = rtw_malloc(len);
        if (NULL == ptmp)
                return -ENOMEM;
 
                goto out;
        }
 
-       param = (struct ieee_param *)rtw_malloc(p->length);
+       param = rtw_malloc(p->length);
        if (param == NULL) {
                ret = -ENOMEM;
                goto out;
                if (wep_key_len > 0) {
                        wep_key_len = wep_key_len <= 5 ? 5 : 13;
                        wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
-                       pwep =(struct ndis_802_11_wep *)rtw_malloc(wep_total_len);
+                       pwep = rtw_malloc(wep_total_len);
                        if (pwep == NULL) {
                                DBG_871X(" r871x_set_encryption: pwep allocate fail !!!\n");
                                goto exit;
                goto out;
        }
 
-       param = (struct ieee_param *)rtw_malloc(p->length);
+       param = rtw_malloc(p->length);
        if (param == NULL) {
                ret = -ENOMEM;
                goto out;
        DBG_871X("+%s\n", __func__);
        len = wrqu->data.length;
 
-       pbuf = (u8 *)rtw_zmalloc(len);
+       pbuf = rtw_zmalloc(len);
        if (pbuf == NULL) {
                DBG_871X("%s: no memory!\n", __func__);
                return -ENOMEM;
 
 {
        struct dvobj_priv *pdvobj = NULL;
 
-       if ((pdvobj = (struct dvobj_priv*)rtw_zmalloc(sizeof(*pdvobj))) == NULL)
+       pdvobj = rtw_zmalloc(sizeof(*pdvobj));
+       if (pdvobj == NULL)
                return NULL;
 
        mutex_init(&pdvobj->hw_init_mutex);
 
 {
        struct rtw_cbuf *cbuf;
 
-       cbuf = (struct rtw_cbuf *)rtw_malloc(sizeof(*cbuf) + sizeof(void*)*size);
+       cbuf = rtw_malloc(sizeof(*cbuf) + sizeof(void *) * size);
 
        if (cbuf) {
                cbuf->write = cbuf->read = 0;