void rtw_hal_data_deinit(_adapter *padapter)
{
if (is_primary_adapter(padapter)) {
if (padapter->HalData)
{
#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
phy_free_filebuf(padapter);
#endif
rtw_vmfree(padapter->HalData, padapter->hal_data_sz);
padapter->HalData = NULL;
padapter->hal_data_sz = 0;
}
}
}
u32 _rtw_free_sta_priv(struct sta_priv *pstapriv)
{
_func_enter_;
if(pstapriv){
rtw_mfree_sta_priv_lock(pstapriv);
if(pstapriv->pallocated_stainfo_buf) {
rtw_vmfree(pstapriv->pallocated_stainfo_buf, sizeof(struct sta_info)*NUM_STA+4);
}
}
_func_exit_;
return _SUCCESS;
}
// length could be ignored, used to detect memory leakage.
VOID
ODM_FreeMemory(
IN PDM_ODM_T pDM_Odm,
OUT PVOID pPtr,
IN u4Byte length
)
{
#if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL))
kfree(pPtr);
#elif (DM_ODM_SUPPORT_TYPE & ODM_CE )
rtw_vmfree(pPtr, length);
#elif(DM_ODM_SUPPORT_TYPE & ODM_MP)
//PADAPTER Adapter = pDM_Odm->Adapter;
PlatformFreeMemory(pPtr, length);
#endif
}
// length could be ignored, used to detect memory leakage.
void
ODM_FreeMemory(
PDM_ODM_T pDM_Odm,
void * pPtr,
u32 length
)
{
#if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL))
kfree(pPtr);
#elif (DM_ODM_SUPPORT_TYPE & ODM_CE )
rtw_vmfree(pPtr, length);
#elif(DM_ODM_SUPPORT_TYPE & ODM_MP)
//struct rtw_adapter * Adapter = pDM_Odm->Adapter;
PlatformFreeMemory(pPtr, length);
#endif
}
void rtw_free_netdev(struct net_device *netdev)
{
struct rtw_netdev_priv_indicator *pnpi;
if (!netdev)
goto RETURN;
pnpi = netdev_priv(netdev);
if (!pnpi->priv)
goto RETURN;
rtw_vmfree(pnpi->priv, pnpi->sizeof_priv);
free_netdev(netdev);
RETURN:
return;
}
u32 _rtw_free_sta_priv(struct sta_priv *pstapriv)
{
_func_enter_;
if(pstapriv) {
rtw_mfree_sta_priv_lock(pstapriv);
if(pstapriv->pallocated_stainfo_buf) {
#ifdef MEM_ALLOC_REFINE
rtw_vmfree(pstapriv->pallocated_stainfo_buf, sizeof(struct sta_info)*NUM_STA+4);
#else
rtw_mfree(pstapriv->pallocated_stainfo_buf, sizeof(struct sta_info)*NUM_STA+4);
#endif
}
}
_func_exit_;
return _SUCCESS;
}
u32 _rtw_free_sta_priv(struct sta_priv *pstapriv)
{
_irqL irqL;
_list *phead, *plist;
struct sta_info *psta = NULL;
struct recv_reorder_ctrl *preorder_ctrl;
int index;
_func_enter_;
if(pstapriv){
/* delete all reordering_ctrl_timer */
_enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
for(index = 0; index < NUM_STA; index++)
{
phead = &(pstapriv->sta_hash[index]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
{
int i;
psta = LIST_CONTAINOR(plist, struct sta_info ,hash_list);
plist = get_next(plist);
for(i=0; i < 16 ; i++)
{
preorder_ctrl = &psta->recvreorder_ctrl[i];
_cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer);
}
}
}
_exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
/*===============================*/
rtw_mfree_sta_priv_lock(pstapriv);
if(pstapriv->pallocated_stainfo_buf) {
rtw_vmfree(pstapriv->pallocated_stainfo_buf, sizeof(struct sta_info)*NUM_STA+4);
}
}
_func_exit_;
return _SUCCESS;
}
void rtw_free_xmit_priv(PADAPTER padapter)
{
int i = 0;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->xmit_freebuf;
_func_enter_;
rtw_hal_free_xmit_priv(padapter);
for(i=0; i<NR_XMITBUFF; i++)
{
rtw_os_xmit_complete(padapter, pxmitbuf);
rtw_os_xmit_resource_free(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), _TRUE);
pxmitbuf++;
}
if(pxmitpriv->pallocated_freebuf)
rtw_vmfree(pxmitpriv->pallocated_freebuf, NR_XMITBUFF*sizeof(struct xmit_buf)+4);
pxmitpriv->free_xmitbuf_cnt = 0;
_func_exit_;
}
static PADAPTER rtw_gspi_if1_init(struct dvobj_priv *dvobj)
{
int status = _FAIL;
struct net_device *pnetdev;
PADAPTER padapter = NULL;
padapter = (PADAPTER)rtw_zvmalloc(sizeof(*padapter));
if (NULL == padapter) {
goto exit;
}
padapter->dvobj = dvobj;
dvobj->if1 = padapter;
padapter->bDriverStopped = _TRUE;
#if defined(CONFIG_CONCURRENT_MODE) || defined(CONFIG_DUALMAC_CONCURRENT)
//set adapter_type/iface type for primary padapter
padapter->isprimary = _TRUE;
padapter->adapter_type = PRIMARY_ADAPTER;
#ifndef CONFIG_HWPORT_SWAP
padapter->iface_type = IFACE_PORT0;
#else
padapter->iface_type = IFACE_PORT1;
#endif
#endif
padapter->hw_init_mutex = &drvpriv.hw_init_mutex;
#ifdef CONFIG_CONCURRENT_MODE
//set global variable to primary adapter
padapter->ph2c_fwcmd_mutex = &drvpriv.h2c_fwcmd_mutex;
padapter->psetch_mutex = &drvpriv.setch_mutex;
padapter->psetbw_mutex = &drvpriv.setbw_mutex;
#endif
padapter->interface_type = RTW_GSPI;
decide_chip_type_by_device_id(padapter);
//3 1. init network device data
pnetdev = rtw_init_netdev(padapter);
if (!pnetdev)
goto free_adapter;
SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
#ifdef CONFIG_IOCTL_CFG80211
rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj));
#endif
//3 3. init driver special setting, interface, OS and hardware relative
//4 3.1 set hardware operation functions
hal_set_hal_ops(padapter);
//3 5. initialize Chip version
padapter->intf_start = &gspi_intf_start;
padapter->intf_stop = &gspi_intf_stop;
if (rtw_init_io_priv(padapter, spi_set_intf_ops) == _FAIL)
{
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("rtw_drv_init: Can't init io_priv\n"));
goto free_hal_data;
}
{
u32 ret = 0;
DBG_8192C("read start:\n");
//spi_write8_endian(padapter, SPI_LOCAL_OFFSET | 0xF0, 0x01, 1);
rtw_write8(padapter, SPI_LOCAL_OFFSET | 0xF0, 0x03);
ret = rtw_read32(padapter, SPI_LOCAL_OFFSET | 0xF0);
DBG_8192C("read end 0xF0 read32:%x:\n", ret);
DBG_8192C("read end 0xF0 read8:%x:\n", rtw_read8(padapter, SPI_LOCAL_OFFSET | 0xF0));
}
rtw_hal_read_chip_version(padapter);
rtw_hal_chip_configure(padapter);
//3 6. read efuse/eeprom data
rtw_hal_read_chip_info(padapter);
//3 7. init driver common data
if (rtw_init_drv_sw(padapter) == _FAIL) {
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("rtw_drv_init: Initialize driver software resource Failed!\n"));
goto free_hal_data;
}
//3 8. get WLan MAC address
// alloc dev name after read efuse.
rtw_init_netdev_name(pnetdev, padapter->registrypriv.ifname);
rtw_macaddr_cfg(padapter->eeprompriv.mac_addr);
_rtw_memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
rtw_hal_disable_interrupt(padapter);
//3 9. Tell the network stack we exist
if (register_netdev(pnetdev) != 0) {
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("rtw_drv_init: register_netdev() failed\n"));
goto free_hal_data;
}
DBG_871X("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n"
,padapter->bDriverStopped
,padapter->bSurpriseRemoved
,padapter->bup
,padapter->hw_init_completed
);
#ifdef CONFIG_HOSTAPD_MLME
hostapd_mode_init(padapter);
#endif
status = _SUCCESS;
free_hal_data:
if (status != _SUCCESS && padapter->HalData)
rtw_mfree(padapter->HalData, sizeof(*(padapter->HalData)));
free_wdev:
if (status != _SUCCESS) {
#ifdef CONFIG_IOCTL_CFG80211
rtw_wdev_free(padapter->rtw_wdev);
#endif
}
free_adapter:
if (status != _SUCCESS) {
if (pnetdev)
rtw_free_netdev(pnetdev);
else if (padapter)
rtw_vmfree((u8*)padapter, sizeof(*padapter));
padapter = NULL;
}
exit:
return padapter;
}
_adapter *rtw_sdio_if1_init(struct dvobj_priv *dvobj, const struct sdio_device_id *pdid){
int status = _FAIL;
struct net_device *pnetdev;
PADAPTER padapter = NULL;
u8 mac_addr[ETH_ALEN];
u16 fw_ready;
u32 i;
_func_enter_;
if ((padapter = (_adapter *)rtw_zvmalloc(sizeof(*padapter))) == NULL) {
DBG_871X("%s: vmalloc for padapter failed!\n", __FUNCTION__);
goto exit;
}
padapter->dvobj = dvobj;
dvobj->if1 = padapter;
padapter->interface_type = RTW_SDIO;
// 1. init network device data
pnetdev = rtw_init_netdev(padapter);
if (!pnetdev)
goto free_adapter;
SET_NETDEV_DEV(pnetdev, &dvobj->intf_data.func->dev);
padapter = rtw_netdev_priv(pnetdev);
// 2. init driver special setting, interface, OS and hardware relative
rtw_set_hal_ops(padapter);
// 3. initialize Chip version
padapter->intf_start = &sd_intf_start;
padapter->intf_stop = &sd_intf_stop;
padapter->intf_init = &sdio_init;
padapter->intf_deinit = &sdio_deinit;
padapter->intf_alloc_irq = &sdio_alloc_irq;
padapter->intf_free_irq = &sdio_free_irq;
sdio_set_intf_ops(padapter, &padapter->io_ops);
// 4. init driver common data
if (rtw_init_drv_sw(padapter) == _FAIL) {
goto free_adapter;
}
// 5. get MAC address
mac_addr[0] = 0x00;
mac_addr[1] = 0xe0;
mac_addr[2] = 0x4c;
mac_addr[3] = 0xB7;
mac_addr[4] = 0x23;
mac_addr[5] = 0x00;
_rtw_memcpy(pnetdev->dev_addr, mac_addr, ETH_ALEN);
#ifdef CONFIG_FWDL
// wait for the device boot code ready
for (i=0;i<100;i++) {
fw_ready = rtw_read16(padapter, SDIO_REG_HCPWM2);
if (fw_ready & SDIO_INIT_DONE) {
break;
}
rtw_msleep_os(10);
}
if (i==100) {
DBG_871X("%s: Wait Device Firmware Ready Timeout!!SDIO_REG_HCPWM2 @ 0x%04x\n", __FUNCTION__, fw_ready);
goto free_adapter;
}
#else
// wait for the device firmware ready
for (i=0;i<100;i++) {
fw_ready = rtw_read8(padapter, SDIO_REG_CPU_IND);
if (fw_ready & SDIO_SYSTEM_TRX_RDY_IND) {
break;
}
rtw_msleep_os(10);
}
if (i==100) {
DBG_871X("%s: Wait Device Firmware Ready Timeout!!SDIO_REG_CPU_IND @ 0x%04x\n", __FUNCTION__, fw_ready);
goto free_adapter;
}
#endif
rtw_hal_disable_interrupt(padapter);
DBG_871X("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d\n"
,padapter->bDriverStopped
,padapter->bSurpriseRemoved
,padapter->bup
);
status = _SUCCESS;
free_adapter:
if (status != _SUCCESS) {
if (pnetdev)
rtw_free_netdev(pnetdev);
else
rtw_vmfree((u8*)padapter, sizeof(*padapter));
padapter = NULL;
}
exit:
_func_exit_;
return padapter;
}
s32 rtw_init_xmit_priv(PADAPTER padapter)
{
struct xmit_buf *pxmitbuf;
sint res=_SUCCESS;
int i , j=0;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_rtw_init_queue(&pxmitpriv->free_xmit_queue);
_rtw_init_queue(&pxmitpriv->xmitbuf_pending_queue);
_rtw_spinlock_init(&pxmitpriv->lock_sctx);
_rtw_init_sema(&pxmitpriv->xmit_sema, 0);
//_rtw_init_sema(&padapter->XmitTerminateSema, 0);
pxmitpriv->padapter = padapter;
pxmitpriv->pallocated_freebuf = rtw_zvmalloc(NR_XMITBUFF*sizeof(struct xmit_buf)+4);
if(pxmitpriv->pallocated_freebuf==NULL)
{
DBG_871X("%s: pallocated_freebuf failed!\n", __FUNCTION__);
res = _FAIL;
goto exit;
}
pxmitpriv->xmit_freebuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_freebuf), 4);
pxmitbuf = (struct xmit_buf *)pxmitpriv->xmit_freebuf;
for (i = 0; i < NR_XMITBUFF; i++)
{
_rtw_init_listhead(&(pxmitbuf->list));
pxmitbuf->padapter = padapter;
/* Tx buf allocation may fail sometimes, so sleep and retry. */
if((res=rtw_os_xmit_resource_alloc(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), _TRUE)) == _FAIL) {
rtw_msleep_os(10);
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), _TRUE);
if (res == _FAIL) {
goto free_os_resource;
}
}
#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ;
pxmitbuf->pkt_len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
#endif
rtw_list_insert_tail(&(pxmitbuf->list), &(pxmitpriv->free_xmit_queue.queue));
#ifdef DBG_XMIT_BUF
pxmitbuf->no=i;
#endif
pxmitbuf++;
}
pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF;
#ifdef CONFIG_USB_HCI
pxmitpriv->txirp_cnt=1;
_rtw_init_sema(&(pxmitpriv->tx_retevt), 0);
//per AC pending irp
pxmitpriv->beq_cnt = 0;
pxmitpriv->bkq_cnt = 0;
pxmitpriv->viq_cnt = 0;
pxmitpriv->voq_cnt = 0;
#endif
if((res = rtw_hal_init_xmit_priv(padapter)) == _FAIL)
goto free_os_resource;
free_os_resource:
if(res == _FAIL){
pxmitbuf = (struct xmit_buf *)pxmitpriv->xmit_freebuf;
for(j=1;j<i;j++)
{
rtw_os_xmit_resource_free(padapter, pxmitbuf,(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), _TRUE);
pxmitbuf++;
}
}
if((res == _FAIL)&&(pxmitpriv->pallocated_freebuf))
rtw_vmfree(pxmitpriv->pallocated_freebuf, NR_XMITBUFF*sizeof(struct xmit_buf)+4);
exit:
_func_exit_;
return res;
}
//
// Description:
// Download 8192C firmware code.
//
//
int FirmwareDownload92C(
IN PADAPTER Adapter
)
{
int rtStatus = _SUCCESS;
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
char R92CFwImageFileName_TSMC[] ={RTL8192C_FW_TSMC_IMG};
char R92CFwImageFileName_UMC[] ={RTL8192C_FW_UMC_IMG};
char R8723FwImageFileName_UMC[] ={RTL8723_FW_UMC_IMG};
char * FwImage;
u32 FwImageLen;
char* pFwImageFileName;
//vivi, merge 92c and 92s into one driver, 20090817
//vivi modify this temply, consider it later!!!!!!!!
//PRT_FIRMWARE pFirmware = GET_FIRMWARE_819X(Adapter);
//PRT_FIRMWARE_92C pFirmware = GET_FIRMWARE_8192C(Adapter);
PRT_FIRMWARE_92C pFirmware = NULL;
PRT_8192C_FIRMWARE_HDR pFwHdr = NULL;
u8 *pFirmwareBuf;
u32 FirmwareLen;
#ifdef MEM_ALLOC_REFINE
pFirmware = (PRT_FIRMWARE_92C)rtw_zvmalloc(sizeof(RT_FIRMWARE_92C));
#else
pFirmware = (PRT_FIRMWARE_92C)rtw_zmalloc(sizeof(RT_FIRMWARE_92C));
#endif
if(!pFirmware)
{
rtStatus = _FAIL;
goto Exit;
}
//RT_TRACE(COMP_INIT, DBG_LOUD, (" ===> FirmwareDownload91C() fw:%s\n", pFwImageFileName));
#ifdef CONFIG_EMBEDDED_FWIMG
pFirmware->eFWSource = FW_SOURCE_HEADER_FILE;
#else
pFirmware->eFWSource = FW_SOURCE_IMG_FILE;
#endif
if(IS_NORMAL_CHIP(pHalData->VersionID))
{
if(IS_VENDOR_UMC_A_CUT(pHalData->VersionID) && !IS_92C_SERIAL(pHalData->VersionID))// UMC , 8188
{
pFwImageFileName = R92CFwImageFileName_UMC;
FwImage = Rtl819XFwUMCACutImageArray;
FwImageLen = UMCACutImgArrayLength;
DBG_871X(" ===> FirmwareDownload91C() fw:Rtl819XFwImageArray_UMC_ACUT\n");
}
else if(IS_VENDOR_UMC_B_CUT(pHalData->VersionID) && !IS_92C_SERIAL(pHalData->VersionID))// UMC , 8188
{
pFwImageFileName = R92CFwImageFileName_UMC;
FwImage = Rtl819XFwUMCBCutImageArray;
FwImageLen = UMCBCutImgArrayLength;
DBG_871X(" ===> FirmwareDownload91C() fw:Rtl819XFwImageArray_UMC_BCUT\n");
}
else
{
pFwImageFileName = R92CFwImageFileName_TSMC;
FwImage = Rtl819XFwTSMCImageArray;
FwImageLen = TSMCImgArrayLength;
DBG_871X(" ===> FirmwareDownload91C() fw:Rtl819XFwImageArray_TSMC\n");
}
}
else
{
#if 0
pFwImageFileName = TestChipFwFile;
FwImage = Rtl8192CTestFwImg;
FwImageLen = Rtl8192CTestFwImgLen;
RT_TRACE(COMP_INIT, DBG_LOUD, (" ===> FirmwareDownload91C() fw:Rtl8192CTestFwImg\n"));
#endif
}
switch(pFirmware->eFWSource)
{
case FW_SOURCE_IMG_FILE:
//TODO:load fw bin file
break;
case FW_SOURCE_HEADER_FILE:
if(TSMCImgArrayLength > FW_8192C_SIZE){
rtStatus = _FAIL;
//RT_TRACE(COMP_INIT, DBG_SERIOUS, ("Firmware size exceed 0x%X. Check it.\n", FW_8192C_SIZE) );
DBG_871X("Firmware size exceed 0x%X. Check it.\n", FW_8192C_SIZE);
goto Exit;
}
#ifdef CONFIG_EMBEDDED_FWIMG
pFirmware->szFwBuffer=FwImage;
#else
_rtw_memcpy(pFirmware->szFwBuffer, FwImage, FwImageLen);
#endif
pFirmware->ulFwLength = FwImageLen;
break;
}
pFirmwareBuf = pFirmware->szFwBuffer;
FirmwareLen = pFirmware->ulFwLength;
// To Check Fw header.
pFwHdr = (PRT_8192C_FIRMWARE_HDR)pFirmware->szFwBuffer;
pHalData->FirmwareVersion = le16_to_cpu(pFwHdr->Version);
pHalData->FirmwareSubVersion = le16_to_cpu(pFwHdr->Subversion);
//RT_TRACE(COMP_INIT, DBG_LOUD, (" FirmwareVersion(%#x), Signature(%#x)\n",
// Adapter->MgntInfo.FirmwareVersion, pFwHdr->Signature));
DBG_8192C("fw_ver=v%d, fw_subver=%d, sig=0x%x\n",
pHalData->FirmwareVersion, pHalData->FirmwareSubVersion, le16_to_cpu(pFwHdr->Signature)&0xFFF0);
if(IS_FW_HEADER_EXIST(pFwHdr))
{
//RT_TRACE(COMP_INIT, DBG_LOUD,("Shift 32 bytes for FW header!!\n"));
pFirmwareBuf = pFirmwareBuf + 32;
FirmwareLen = FirmwareLen -32;
}
// Suggested by Filen. If 8051 is running in RAM code, driver should inform Fw to reset by itself,
// or it will cause download Fw fail. 2010.02.01. by tynli.
if(rtw_read8(Adapter, REG_MCUFWDL)&BIT7) //8051 RAM code
{
DBG_8192C("8051 in Ram......prepare to reset by itself\n");
_FirmwareSelfReset(Adapter);
rtw_write8(Adapter, REG_MCUFWDL, 0x00);
}
_FWDownloadEnable(Adapter, _TRUE);
_WriteFW(Adapter, pFirmwareBuf, FirmwareLen);
_FWDownloadEnable(Adapter, _FALSE);
rtStatus = _FWFreeToGo(Adapter);
if(_SUCCESS != rtStatus){
//RT_TRACE(COMP_INIT, DBG_SERIOUS, ("DL Firmware failed!\n") );
goto Exit;
}
//RT_TRACE(COMP_INIT, DBG_LOUD, (" Firmware is ready to run!\n"));
Exit:
if(pFirmware) {
#ifdef MEM_ALLOC_REFINE
rtw_vmfree((u8*)pFirmware, sizeof(RT_FIRMWARE_92C));
#else
rtw_mfree((u8*)pFirmware, sizeof(RT_FIRMWARE_92C));
#endif
}
//RT_TRACE(COMP_INIT, DBG_LOUD, (" <=== FirmwareDownload91C()\n"));
return rtStatus;
}
