int rtw_android_pno_enable(struct net_device *net, int pno_enable) { _adapter *padapter = (_adapter *)rtw_netdev_priv(net); struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter); if (pwrctl) { pwrctl->wowlan_pno_enable = pno_enable; DBG_871X("%s: wowlan_pno_enable: %d\n", __func__, pwrctl->wowlan_pno_enable); if (pwrctl->wowlan_pno_enable == 0) { if (pwrctl->pnlo_info != NULL) { rtw_mfree((u8 *)pwrctl->pnlo_info, sizeof(pno_nlo_info_t)); pwrctl->pnlo_info = NULL; } if (pwrctl->pno_ssid_list != NULL) { rtw_mfree((u8 *)pwrctl->pno_ssid_list, sizeof(pno_ssid_list_t)); pwrctl->pno_ssid_list = NULL; } if (pwrctl->pscan_info != NULL) { rtw_mfree((u8 *)pwrctl->pscan_info, sizeof(pno_scan_info_t)); pwrctl->pscan_info = NULL; } } return 0; } else { return -1; } }
void rtw_os_xmit_resource_free(_adapter *padapter, struct xmit_buf *pxmitbuf,u32 free_sz) { #ifdef CONFIG_USB_HCI int i; struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter); struct usb_device *pusbd = pdvobjpriv->pusbdev; for(i=0; i<8; i++) { if(pxmitbuf->pxmit_urb[i]) { //usb_kill_urb(pxmitbuf->pxmit_urb[i]); usb_free_urb(pxmitbuf->pxmit_urb[i]); } } #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX rtw_usb_buffer_free(pusbd, (size_t)free_sz, pxmitbuf->pallocated_buf, pxmitbuf->dma_transfer_addr); pxmitbuf->pallocated_buf = NULL; pxmitbuf->dma_transfer_addr = 0; #else // CONFIG_USE_USB_BUFFER_ALLOC_TX if(pxmitbuf->pallocated_buf) rtw_mfree(pxmitbuf->pallocated_buf, free_sz); #endif // CONFIG_USE_USB_BUFFER_ALLOC_TX #endif #if defined(CONFIG_PCI_HCI) || defined(CONFIG_SDIO_HCI) if(pxmitbuf->pallocated_buf) rtw_mfree(pxmitbuf->pallocated_buf, free_sz); #endif }
static int _usbctrl_vendorreq_async_write(struct usb_device *udev, u8 request, u16 value, u16 index, void *pdata, u16 len, u8 requesttype) { int rc; unsigned int pipe; u8 reqtype; struct usb_ctrlrequest *dr; struct urb *urb; struct rtl819x_async_write_data { u8 data[VENDOR_CMD_MAX_DATA_LEN]; struct usb_ctrlrequest dr; } *buf; if (requesttype == VENDOR_READ) { pipe = usb_rcvctrlpipe(udev, 0);//read_in reqtype = REALTEK_USB_VENQT_READ; } else { pipe = usb_sndctrlpipe(udev, 0);//write_out reqtype = REALTEK_USB_VENQT_WRITE; } buf = (struct rtl819x_async_write_data *)rtw_zmalloc(sizeof(*buf)); if (!buf) { rc = -ENOMEM; goto exit; } urb = usb_alloc_urb(0, GFP_ATOMIC); if (!urb) { rtw_mfree((u8*)buf, sizeof(*buf)); rc = -ENOMEM; goto exit; } dr = &buf->dr; dr->bRequestType = reqtype; dr->bRequest = request; dr->wValue = cpu_to_le16(value); dr->wIndex = cpu_to_le16(index); dr->wLength = cpu_to_le16(len); _rtw_memcpy(buf, pdata, len); usb_fill_control_urb(urb, udev, pipe, (unsigned char *)dr, buf, len, _usbctrl_vendorreq_async_callback, buf); rc = usb_submit_urb(urb, GFP_ATOMIC); if (rc < 0) { rtw_mfree((u8*)buf, sizeof(*buf)); usb_free_urb(urb); } exit: return rc; }
s32 sdio_writeN(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8* pbuf) { PADAPTER padapter; struct dvobj_priv *psdiodev; PSDIO_DATA psdio; u8 bMacPwrCtrlOn; u8 deviceId; u16 offset; u32 ftaddr; u8 shift; s32 err; _func_enter_; padapter = pintfhdl->padapter; psdiodev = pintfhdl->pintf_dev; psdio = &psdiodev->intf_data; err = 0; ftaddr = _cvrt2ftaddr(addr, &deviceId, &offset); rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn); if (((deviceId == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) || (_FALSE == bMacPwrCtrlOn) #ifdef CONFIG_LPS_LCLK || (_TRUE == padapter->pwrctrlpriv.bFwCurrentInPSMode) #endif ) { err = sd_cmd52_write(psdio, ftaddr, cnt, pbuf); return err; } shift = ftaddr & 0x3; if (shift == 0) { err = sd_write(psdio, ftaddr, cnt, pbuf); } else { u8 *ptmpbuf; u32 n; ftaddr &= ~(u16)0x3; n = cnt + shift; ptmpbuf = rtw_malloc(n); if (NULL == ptmpbuf) return -1; err = sd_read(psdio, ftaddr, 4, ptmpbuf); if (err) { rtw_mfree(ptmpbuf, n); return err; } _rtw_memcpy(ptmpbuf+shift, pbuf, cnt); err = sd_write(psdio, ftaddr, n, ptmpbuf); rtw_mfree(ptmpbuf, n); } _func_exit_; return err; }
void usb_unload_intf_priv(struct intf_priv *pintfpriv) { #ifndef PLATFORM_OS_CE rtw_mfree((u8 *)(pintfpriv->allocated_io_rwmem), pintfpriv->max_iosz+4); rtw_mfree((u8 *)(pintfpriv->allocated_io_r_mem), pintfpriv->max_iosz+4); #endif RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("%s(%u)\n",__FUNCTION__, __LINE__)); }
s32 sdio_writeN(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8* pbuf) { PADAPTER padapter; u8 bMacPwrCtrlOn; u8 deviceId; u16 offset; u32 ftaddr; u8 shift; s32 err; _func_enter_; padapter = pintfhdl->padapter; err = 0; ftaddr = _cvrt2ftaddr(addr, &deviceId, &offset); // rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn); // if (((deviceId == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) // || (_FALSE == bMacPwrCtrlOn) // #ifdef CONFIG_LPS_LCLK // || (_TRUE == adapter_to_pwrctl(padapter)->bFwCurrentInPSMode) // #endif // ) // { // err = sd_cmd52_write(pintfhdl, ftaddr, cnt, pbuf); // return err; // } shift = ftaddr & 0x3; if (shift == 0) { err = sd_write(pintfhdl, ftaddr, cnt, pbuf); } else { u8 *ptmpbuf; u32 n; ftaddr &= ~(u16)0x3; n = cnt + shift; ptmpbuf = rtw_malloc(n); if (NULL == ptmpbuf) return -1; err = sd_read(pintfhdl, ftaddr, 4, ptmpbuf); if (err) { rtw_mfree(ptmpbuf, n); return err; } _rtw_memcpy(ptmpbuf+shift, pbuf, cnt); err = sd_write(pintfhdl, ftaddr, n, ptmpbuf); rtw_mfree(ptmpbuf, n); } _func_exit_; return err; }
static void usb_bulkout_zero_complete(struct urb *purb, struct pt_regs *regs) { struct zero_bulkout_context *pcontext = (struct zero_bulkout_context *)purb->context; if(pcontext) { if(pcontext->pbuf) rtw_mfree(pcontext->pbuf, sizeof(int)); if(pcontext->purb && (pcontext->purb==purb)) usb_free_urb(pcontext->purb); rtw_mfree((u8*)pcontext, sizeof(struct zero_bulkout_context)); } }
void rtl8188eu_free_recv_priv (_adapter *padapter) { int i; struct recv_buf *precvbuf; struct recv_priv *precvpriv = &padapter->recvpriv; precvbuf = (struct recv_buf *)precvpriv->precv_buf; for(i=0; i < NR_RECVBUFF ; i++) { rtw_os_recvbuf_resource_free(padapter, precvbuf); precvbuf++; } if(precvpriv->pallocated_recv_buf) rtw_mfree(precvpriv->pallocated_recv_buf, NR_RECVBUFF *sizeof(struct recv_buf) + 4); #ifdef CONFIG_USB_INTERRUPT_IN_PIPE #ifdef PLATFORM_LINUX if(precvpriv->int_in_urb) { usb_free_urb(precvpriv->int_in_urb); } #endif//PLATFORM_LINUX if(precvpriv->int_in_buf) rtw_mfree(precvpriv->int_in_buf, INTERRUPT_MSG_FORMAT_LEN); #endif//CONFIG_USB_INTERRUPT_IN_PIPE #ifdef PLATFORM_LINUX if (skb_queue_len(&precvpriv->rx_skb_queue)) { DBG_8192C(KERN_WARNING "rx_skb_queue not empty\n"); } skb_queue_purge(&precvpriv->rx_skb_queue); #ifdef CONFIG_PREALLOC_RECV_SKB if (skb_queue_len(&precvpriv->free_recv_skb_queue)) { DBG_8192C(KERN_WARNING "free_recv_skb_queue not empty, %d\n", skb_queue_len(&precvpriv->free_recv_skb_queue)); } skb_queue_purge(&precvpriv->free_recv_skb_queue); #endif #endif }
uint usb_init_intf_priv(struct intf_priv *pintfpriv) { // get the dvobj_priv object struct dvobj_priv * pNdisCEDvice = (struct dvobj_priv *) pintfpriv->intf_dev; RT_TRACE( _module_hci_ops_os_c_, _drv_info_, ("%s(%u)\n",__FUNCTION__, __LINE__)); // set init intf_priv init status as _IOREADY pintfpriv->intf_status = _IOREADY; // determine the max io size by dvobj_priv.ishighspeed if(pNdisCEDvice->ishighspeed) pintfpriv->max_iosz = 128; else pintfpriv->max_iosz = 64; // read/write size set as 0 pintfpriv->io_wsz = 0; pintfpriv->io_rsz = 0; // init io_rwmem buffer pintfpriv->allocated_io_rwmem = rtw_zmalloc(pintfpriv->max_iosz +4); if (pintfpriv->allocated_io_rwmem == NULL) { rtw_mfree((u8 *)(pintfpriv->allocated_io_rwmem), pintfpriv->max_iosz +4); return _FAIL; } else { // word align the io_rwmem pintfpriv->io_rwmem = pintfpriv->allocated_io_rwmem + 4 - ( (u32)(pintfpriv->allocated_io_rwmem) & 3); } #ifndef PLATFORM_OS_CE // init io_r_mem buffer pintfpriv->allocated_io_r_mem = rtw_zmalloc(pintfpriv->max_iosz +4); if (pintfpriv->allocated_io_r_mem == NULL) { rtw_mfree((u8 *)(pintfpriv->allocated_io_r_mem), pintfpriv->max_iosz +4); return _FAIL; } else { // word align the io_rwmem pintfpriv->io_r_mem = pintfpriv->allocated_io_r_mem + 4 - ( (u32)(pintfpriv->allocated_io_r_mem) & 3); } #endif return _SUCCESS; }
void rtw_os_xmit_resource_free(_adapter *padapter, struct xmit_buf *pxmitbuf,u32 free_sz, u8 flag) { if (free_sz > 0 ) { if(pxmitbuf->pallocated_buf) rtw_mfree(pxmitbuf->pallocated_buf, free_sz); } }
static void rtl8723bs_c2h_packet_handler(PADAPTER padapter, u8 *pbuf, u16 length) { u8 *tmpBuf=NULL; u8 res = _FALSE; if(length == 0) return; //DBG_871X("+%s() length=%d\n", __func__, length); tmpBuf = rtw_zmalloc(length); if (tmpBuf == NULL) return; _rtw_memcpy(tmpBuf, pbuf, length); res = rtw_c2h_packet_wk_cmd(padapter, tmpBuf, length); if (res == _FALSE && tmpBuf != NULL) rtw_mfree(tmpBuf, length); //DBG_871X("-%s res(%d)\n", __func__, res); return; }
void nat25_db_cleanup(_adapter *priv) { int i; _irqL irqL; _enter_critical_bh(&priv->br_ext_lock, &irqL); for (i=0; i<NAT25_HASH_SIZE; i++) { struct nat25_network_db_entry *f; f = priv->nethash[i]; while (f != NULL) { struct nat25_network_db_entry *g; g = f->next_hash; if (priv->scdb_entry == f) { memset(priv->scdb_mac, 0, ETH_ALEN); memset(priv->scdb_ip, 0, 4); priv->scdb_entry = NULL; } __network_hash_unlink(f); rtw_mfree((u8 *) f, sizeof(struct nat25_network_db_entry)); f = g; } } _exit_critical_bh(&priv->br_ext_lock, &irqL); }
void rtw_os_xmit_resource_free(_adapter *padapter, struct xmit_buf *pxmitbuf, u32 free_sz, u8 flag) { if (flag) { #ifdef CONFIG_USB_HCI int i; for (i = 0; i < 8; i++) { if (pxmitbuf->pxmit_urb[i]) { /* usb_kill_urb(pxmitbuf->pxmit_urb[i]); */ usb_free_urb(pxmitbuf->pxmit_urb[i]); } } #endif } if (free_sz > 0) { #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter); struct usb_device *pusbd = pdvobjpriv->pusbdev; rtw_usb_buffer_free(pusbd, (size_t)free_sz, pxmitbuf->pallocated_buf, pxmitbuf->dma_transfer_addr); pxmitbuf->pallocated_buf = NULL; pxmitbuf->dma_transfer_addr = 0; #else /* CONFIG_USE_USB_BUFFER_ALLOC_TX */ if (pxmitbuf->pallocated_buf) rtw_mfree(pxmitbuf->pallocated_buf, free_sz); #endif /* CONFIG_USE_USB_BUFFER_ALLOC_TX */ } }
/* * Free recv private variable of hardware dependent * 1. recv buf * 2. recv tasklet * */ void rtl8723as_free_recv_priv(PADAPTER padapter) { u32 i, n; struct recv_priv *precvpriv; struct recv_buf *precvbuf; precvpriv = &padapter->recvpriv; //3 1. kill tasklet #ifdef PLATFORM_LINUX tasklet_kill(&precvpriv->recv_tasklet); #endif //3 2. free all recv buffers precvbuf = (struct recv_buf*)precvpriv->precv_buf; if (precvbuf) { n = NR_RECVBUFF; precvpriv->free_recv_buf_queue_cnt = 0; for (i = 0; i < n ; i++) { rtw_list_delete(&precvbuf->list); rtw_os_recvbuf_resource_free(padapter, precvbuf); freerecvbuf(precvbuf); precvbuf++; } precvpriv->precv_buf = NULL; } if (precvpriv->pallocated_recv_buf) { n = NR_RECVBUFF * sizeof(struct recv_buf) + 4; rtw_mfree(precvpriv->pallocated_recv_buf, n); precvpriv->pallocated_recv_buf = NULL; } }
void rtw_buf_update(u8 **buf, u32 *buf_len, u8 *src, u32 src_len) { u32 ori_len = 0, dup_len = 0; u8 *ori = NULL; u8 *dup = NULL; if (!buf || !buf_len) return; if (!src || !src_len) goto keep_ori; /* duplicate src */ dup = rtw_malloc(src_len); if (dup) { dup_len = src_len; _rtw_memcpy(dup, src, dup_len); } keep_ori: ori = *buf; ori_len = *buf_len; /* replace buf with dup */ *buf_len = 0; *buf = dup; *buf_len = dup_len; /* free ori */ if (ori && ori_len > 0) rtw_mfree(ori, ori_len); }
static void _usbctrl_vendorreq_async_callback(struct urb *urb, struct pt_regs *regs) { if (urb) { if (urb->context) rtw_mfree(urb->context, sizeof(struct rtw_async_write_data)); usb_free_urb(urb); } }
void free_mp_priv(struct mp_priv *pmp_priv) { if (pmp_priv->pallocated_mp_xmitframe_buf) { rtw_mfree(pmp_priv->pallocated_mp_xmitframe_buf, 0); pmp_priv->pallocated_mp_xmitframe_buf = NULL; } pmp_priv->pmp_xmtframe_buf = NULL; }
static struct dvobj_priv *gspi_dvobj_init(struct spi_device *spi) { int status = _FAIL; struct dvobj_priv *dvobj = NULL; PGSPI_DATA pgspi; _func_enter_; dvobj = (struct dvobj_priv*)rtw_zmalloc(sizeof(*dvobj)); if (NULL == dvobj) { goto exit; } //spi init /* This is the only SPI value that we need to set here, the rest * comes from the board-peripherals file */ spi->bits_per_word = 32; spi->max_speed_hz = 48 * 1000 * 1000; //here mode 0 and 3 all ok, //3 can run under 48M clock when SPI_CTL4 bit14 IS_FST set to 1 //0 can run under 24M clock, but can run under 48M when SPI_CTL4 bit14 IS_FST set to 1 and Ctl0_reg[1:0] set to 3. spi->mode = SPI_MODE_3; spi_setup(spi); #if 1 //DBG_8192C("set spi ==========================%d \n", spi_setup(spi)); DBG_871X("%s, mode = %d \n", __func__, spi->mode); DBG_871X("%s, bit_per_word = %d \n", __func__, spi->bits_per_word); DBG_871X("%s, speed = %d \n", __func__, spi->max_speed_hz); DBG_871X("%s, chip_select = %d \n", __func__, spi->chip_select); DBG_871X("%s, controller_data = %d \n", __func__, *(int *)spi->controller_data); DBG_871X("%s, irq= %d \n", __func__, oob_irq); #endif spi_set_drvdata(spi, dvobj); pgspi = &dvobj->intf_data; pgspi->func = spi; if (gspi_init(dvobj) != _SUCCESS) { DBG_871X("%s: initialize GSPI Failed!\n", __FUNCTION__); goto free_dvobj; } status = _SUCCESS; free_dvobj: if (status != _SUCCESS && dvobj) { spi_set_drvdata(spi, NULL); rtw_mfree((u8*)dvobj, sizeof(*dvobj)); dvobj = NULL; } exit: _func_exit_; return dvobj; }
static void usb_bulkout_zero_complete(struct urb *purb, struct pt_regs *regs) { struct zero_bulkout_context *pcontext = (struct zero_bulkout_context *)purb->context; if(pcontext) { if(pcontext->pbuf) { rtw_mfree(pcontext->pbuf); } if(pcontext->purb && (pcontext->purb==purb)) { usb_free_urb(pcontext->purb); } rtw_mfree(pcontext); } }
static void _usbctrl_vendorreq_async_callback(struct urb *urb, struct pt_regs *regs) { if (urb) { if (urb->context) { rtw_mfree(urb->context); } usb_free_urb(urb); } }
uint sdbus_read_reg_int(struct intf_priv *pintfpriv, u32 addr, u32 cnt, void *pdata) { struct dvobj_priv *pdvobjpriv = (struct dvobj_priv*)pintfpriv->intf_dev; struct sdio_func *func = pdvobjpriv->func; u8 *mem = NULL; int status; #ifdef CONFIG_IO_4B u32 addr_org = addr, addr_offset = 0; u32 cnt_org = cnt; #endif _func_enter_; #ifdef CONFIG_IO_4B addr_offset = addr % 4; if (addr_offset) { addr = addr - addr_offset; cnt = cnt + addr_offset; } if (cnt % 4) cnt = ((cnt + 4) >> 2) << 2; #endif mem = rtw_malloc(cnt); if (mem == NULL) { RT_TRACE(_module_hci_ops_os_c_, _drv_emerg_, ("SDIO_STATUS_NO_RESOURCES - memory alloc fail\n")); return _FAIL; } status = sdio_memcpy_fromio(func, mem, addr&0x1FFFF, cnt); if (status) { //error RT_TRACE(_module_hci_ops_os_c_, _drv_emerg_, ("sdbus_read_reg_int error 0x%x\n" "***** Addr = %x *****\n" "***** Length = %d *****\n", status, addr, cnt)); status = _FAIL; } else { #ifdef CONFIG_IO_4B if (cnt != cnt_org) _rtw_memcpy(pdata, mem + addr_offset, cnt_org); else #endif _rtw_memcpy(pdata, mem, cnt); status = _SUCCESS; } rtw_mfree(mem, cnt); _func_exit_; return status; }
DWORD usb_bulkout_zero_complete( LPVOID pZeroContext ) { struct zero_bulkout_context *pcontext = (struct zero_bulkout_context *)pZeroContext; _adapter * padapter = pcontext->padapter; struct dvobj_priv * pdvobj_priv = (struct dvobj_priv *)&padapter->dvobjpriv; LPCUSB_FUNCS usb_funcs_vp = pdvobj_priv->usb_extension._lpUsbFuncs; struct xmit_priv * pxmitpriv = &padapter->xmitpriv; int fComplete =_FALSE; DWORD dwBytesTransferred = 0; DWORD dwErr = USB_CANCELED_ERROR; _func_enter_; #if 1 (*usb_funcs_vp->lpGetTransferStatus)(pxmitpriv->usb_transfer_write_port, &dwBytesTransferred, &dwErr); fComplete = (*usb_funcs_vp->lpIsTransferComplete)(pxmitpriv->usb_transfer_write_port); if(fComplete!=_TRUE) { RT_TRACE( _module_hci_ops_os_c_, _drv_err_, ("usb_bulkout_zero_complete CloseTransfer before complete\n")); } (*usb_funcs_vp->lpCloseTransfer)(pxmitpriv->usb_transfer_write_port); #endif if(pcontext) { if(pcontext->pbuf) { rtw_mfree(pcontext->pbuf, sizeof(int)); } rtw_mfree((u8*)pcontext, sizeof(struct zero_bulkout_context)); } _func_exit_; return ERROR_SUCCESS; }
/* * Description: * Read from RX FIFO * Round read size to block size, * and make sure data transfer will be done in one command. * * Parameters: * pintfhdl a pointer of intf_hdl * addr port ID * cnt size to read * rmem address to put data * * Return: * _SUCCESS(1) Success * _FAIL(0) Fail */ static u32 sdio_read_port( struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *mem) { PADAPTER padapter; PSDIO_DATA psdio; PHAL_DATA_TYPE phal; u32 oldcnt; #ifdef SDIO_DYNAMIC_ALLOC_MEM u8 *oldmem; #endif s32 err; padapter = pintfhdl->padapter; psdio = &adapter_to_dvobj(padapter)->intf_data; phal = GET_HAL_DATA(padapter); HalSdioGetCmdAddr8723BSdio(padapter, addr, phal->SdioRxFIFOCnt++, &addr); oldcnt = cnt; if (cnt > psdio->block_transfer_len) cnt = _RND(cnt, psdio->block_transfer_len); // cnt = sdio_align_size(cnt); if (oldcnt != cnt) { #ifdef SDIO_DYNAMIC_ALLOC_MEM oldmem = mem; mem = rtw_malloc(cnt); if (mem == NULL) { DBG_8192C(KERN_WARNING "%s: allocate memory %d bytes fail!\n", __func__, cnt); mem = oldmem; oldmem == NULL; } #else // in this case, caller should gurante the buffer is big enough // to receive data after alignment #endif } err = _sd_read(pintfhdl, addr, cnt, mem); #ifdef SDIO_DYNAMIC_ALLOC_MEM if ((oldcnt != cnt) && (oldmem)) { _rtw_memcpy(oldmem, mem, oldcnt); rtw_mfree(mem, cnt); } #endif if (err) return _FAIL; return _SUCCESS; }
void rtw_os_xmit_resource_free(_adapter *padapter, struct xmit_buf *pxmitbuf,u32 free_sz) { #ifdef CONFIG_USB_HCI int i; struct dvobj_priv *pdvobjpriv = &padapter->dvobjpriv; struct usb_device *pusbd = pdvobjpriv->pusbdev; for(i=0; i<8; i++) { if(pxmitbuf->pxmit_urb[i]) { //usb_kill_urb(pxmitbuf->pxmit_urb[i]); usb_free_urb(pxmitbuf->pxmit_urb[i]); } } #ifdef CONFIG_USE_USB_BUFFER_ALLOC #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)) usb_free_coherent(pusbd, (size_t)free_sz, pxmitbuf->pallocated_buf, pxmitbuf->dma_transfer_addr); #else usb_buffer_free(pusbd, (size_t)free_sz, pxmitbuf->pallocated_buf, pxmitbuf->dma_transfer_addr); #endif pxmitbuf->pallocated_buf = NULL; pxmitbuf->dma_transfer_addr = 0; #else if(pxmitbuf->pallocated_buf) rtw_mfree(pxmitbuf->pallocated_buf, free_sz); #endif #endif #ifdef CONFIG_PCI_HCI if(pxmitbuf->pallocated_buf) rtw_mfree(pxmitbuf->pallocated_buf, free_sz); #endif }
void rtw_report_sec_ie(_adapter *adapter,u8 authmode,u8 *sec_ie) { uint len; u8 *buff,*p,i; union iwreq_data wrqu; _func_enter_; RT_TRACE(_module_mlme_osdep_c_,_drv_info_,("+rtw_report_sec_ie, authmode=%d\n", authmode)); buff = NULL; if(authmode==_WPA_IE_ID_) { RT_TRACE(_module_mlme_osdep_c_,_drv_info_,("rtw_report_sec_ie, authmode=%d\n", authmode)); buff = rtw_zmalloc(IW_CUSTOM_MAX); if (NULL == buff) { DBG_871X(FUNC_ADPT_FMT ": alloc memory FAIL!!\n", FUNC_ADPT_ARG(adapter)); return; } p = buff; p+=sprintf(p,"ASSOCINFO(ReqIEs="); len = sec_ie[1]+2; len = (len < IW_CUSTOM_MAX) ? len:IW_CUSTOM_MAX; for(i=0;i<len;i++){ p+=sprintf(p,"%02x",sec_ie[i]); } p+=sprintf(p,")"); _rtw_memset(&wrqu,0,sizeof(wrqu)); wrqu.data.length=p-buff; wrqu.data.length = (wrqu.data.length<IW_CUSTOM_MAX) ? wrqu.data.length:IW_CUSTOM_MAX; #ifndef CONFIG_IOCTL_CFG80211 wireless_send_event(adapter->pnetdev,IWEVCUSTOM,&wrqu,buff); #endif rtw_mfree(buff, IW_CUSTOM_MAX); } exit: _func_exit_; }
static void gspi_dvobj_deinit(struct spi_device *spi) { struct dvobj_priv *dvobj = spi_get_drvdata(spi); _func_enter_; spi_set_drvdata(spi, NULL); if (dvobj) { gspi_deinit(dvobj); rtw_mfree((u8*)dvobj, sizeof(*dvobj)); } _func_exit_; }
void rtw_report_sec_ie(_adapter *adapter,u8 authmode,u8 *sec_ie) { uint len; u8 *buff,*p,i; union iwreq_data wrqu; _func_enter_; RT_TRACE(_module_mlme_osdep_c_,_drv_info_,("+rtw_report_sec_ie, authmode=%d\n", authmode)); buff = NULL; if(authmode==_WPA_IE_ID_) { RT_TRACE(_module_mlme_osdep_c_,_drv_info_,("rtw_report_sec_ie, authmode=%d\n", authmode)); buff = rtw_malloc(IW_CUSTOM_MAX); _rtw_memset(buff,0,IW_CUSTOM_MAX); p=buff; p+=sprintf(p,"ASSOCINFO(ReqIEs="); len = sec_ie[1]+2; len = (len < IW_CUSTOM_MAX) ? len:IW_CUSTOM_MAX; for(i=0;i<len;i++){ p+=sprintf(p,"%02x",sec_ie[i]); } p+=sprintf(p,")"); _rtw_memset(&wrqu,0,sizeof(wrqu)); wrqu.data.length=p-buff; wrqu.data.length = (wrqu.data.length<IW_CUSTOM_MAX) ? wrqu.data.length:IW_CUSTOM_MAX; wireless_send_event(adapter->pnetdev,IWEVCUSTOM,&wrqu,buff); if(buff) rtw_mfree(buff, IW_CUSTOM_MAX); } _func_exit_; }
/* * Todo: align address to 4 bytes. */ s32 sdio_local_write( PADAPTER padapter, u32 addr, u32 cnt, u8 *pbuf) { PSDIO_DATA psdio; u8 bMacPwrCtrlOn; s32 err; u8 *ptmpbuf; #ifdef CONFIG_DEBUG_RTL819X if(addr & 0x3) DBG_8192C("%s, address must be 4 bytes alignment\n", __FUNCTION__); if(cnt & 0x3) DBG_8192C("%s, size must be the multiple of 4 \n", __FUNCTION__); #endif psdio = &padapter->dvobjpriv.intf_data; HalSdioGetCmdAddr8723ASdio(padapter, SDIO_LOCAL_DEVICE_ID, addr, &addr); padapter->HalFunc.GetHwRegHandler(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn); if ((_FALSE == bMacPwrCtrlOn) #ifdef CONFIG_LPS_LCLK || (_TRUE == padapter->pwrctrlpriv.bFwCurrentInPSMode) #endif ) { err = sd_cmd52_write(psdio, addr, cnt, pbuf); return err; } ptmpbuf = (u8*)rtw_malloc(cnt); if(!ptmpbuf) return (-1); _rtw_memcpy(ptmpbuf, pbuf, cnt); err = sd_write(psdio, addr, cnt, ptmpbuf); if (ptmpbuf) rtw_mfree(ptmpbuf, cnt); return err; }
void rtw_buf_free(u8 **buf, u32 *buf_len) { u32 ori_len; if (!buf || !buf_len) return; ori_len = *buf_len; if (*buf) { u32 tmp_buf_len = *buf_len; *buf_len = 0; rtw_mfree(*buf, tmp_buf_len); *buf = NULL; } }
/* * Free recv private variable of hardware dependent * 1. recv buf * 2. recv tasklet * */ void rtl8195as_free_recv_priv(PADAPTER padapter) { u32 n; struct recv_priv *precvpriv = &padapter->recvpriv; //3 1. kill tasklet tasklet_kill(&precvpriv->recv_tasklet); //3 2. free all recv buffers if (precvpriv->pallocated_recv_buf) { n = NR_RECVBUFF * sizeof(struct recv_buf) + 4; rtw_mfree(precvpriv->pallocated_recv_buf, n); precvpriv->pallocated_recv_buf = NULL; precvpriv->precv_buf = NULL; } }