void rtw_os_wake_queue_at_free_stainfo(_adapter *padapter, int *qcnt_freed)
{
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
int i;
for (i = 0; i < 4; i++) {
if (qcnt_freed[i] == 0)
continue;
if (rtw_os_need_wake_queue(padapter, i)) {
if (DBG_DUMP_OS_QUEUE_CTL)
RTW_INFO(FUNC_ADPT_FMT": netif_wake_subqueue[%d]\n", FUNC_ADPT_ARG(padapter), i);
netif_wake_subqueue(padapter->pnetdev, i);
}
}
#else
if (qcnt_freed[0] || qcnt_freed[1] || qcnt_freed[2] || qcnt_freed[3]) {
if (rtw_os_need_wake_queue(padapter, 0)) {
if (DBG_DUMP_OS_QUEUE_CTL)
RTW_INFO(FUNC_ADPT_FMT": netif_wake_queue\n", FUNC_ADPT_ARG(padapter));
netif_wake_queue(padapter->pnetdev);
}
}
#endif
}
static void rtw_dbg_dump_fwstate(_adapter *padapter, sint state)
{
u8 buf[32] = {0};
if (state & WIFI_FW_NULL_STATE) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "WIFI_FW_NULL_STATE");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
if (state & _FW_LINKED) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "_FW_LINKED");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
if (state & _FW_UNDER_LINKING) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "_FW_UNDER_LINKING");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
if (state & _FW_UNDER_SURVEY) {
_rtw_memset(buf, 0, 32);
sprintf(buf, "_FW_UNDER_SURVEY");
RTW_INFO(FUNC_ADPT_FMT"fwstate-%s\n", FUNC_ADPT_ARG(padapter), buf);
}
}
/*
* Return:
* 0: power on successfully
* others: power on failed
*/
int platform_wifi_power_on(void)
{
int ret = 0;
#ifdef CONFIG_MMC
{
script_item_u val;
script_item_value_type_e type;
#ifdef CONFIG_PLATFORM_ARM_SUN8I_W5P1
unsigned int mod_sel = get_rf_mod_type();
#else
unsigned int mod_sel = wifi_pm_get_mod_type();
#endif
type = script_get_item("wifi_para", "wifi_sdc_id", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
RTW_INFO("get wifi_sdc_id failed\n");
ret = -1;
} else {
sdc_id = val.val;
RTW_INFO("----- %s sdc_id: %d, mod_sel: %d\n", __FUNCTION__, sdc_id, mod_sel);
#if defined(CONFIG_PLATFORM_ARM_SUN6I) || defined(CONFIG_PLATFORM_ARM_SUN7I)
sw_mci_rescan_card(sdc_id, 1);
#elif defined(CONFIG_PLATFORM_ARM_SUN8I)
sunxi_mci_rescan_card(sdc_id, 1);
#endif
mdelay(100);
wifi_pm_power(1);
RTW_INFO("%s: power up, rescan card.\n", __FUNCTION__);
}
#ifdef CONFIG_GPIO_WAKEUP
#ifdef CONFIG_PLATFORM_ARM_SUN8I_W5P1
type = script_get_item("wifi_para", "wl_host_wake", &val);
#else
#ifdef CONFIG_RTL8723B
type = script_get_item("wifi_para", "rtl8723bs_wl_host_wake", &val);
#endif
#ifdef CONFIG_RTL8188E
type = script_get_item("wifi_para", "rtl8189es_host_wake", &val);
#endif
#endif /* CONFIG_PLATFORM_ARM_SUN8I_W5P1 */
if (SCIRPT_ITEM_VALUE_TYPE_PIO != type) {
RTW_INFO("No definition of wake up host PIN\n");
ret = -1;
} else {
gpio_eint_wlan = val.gpio.gpio;
#ifdef CONFIG_PLATFORM_ARM_SUN8I
oob_irq = gpio_to_irq(gpio_eint_wlan);
#endif
}
#endif /* CONFIG_GPIO_WAKEUP */
}
#endif /* CONFIG_MMC */
return ret;
}
void rtl8812_sreset_linked_status_check(_adapter *padapter)
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
u32 rx_dma_status = 0;
rx_dma_status = rtw_read32(padapter, REG_RXDMA_STATUS);
if (rx_dma_status != 0x00)
RTW_INFO("%s REG_RXDMA_STATUS:0x%08x\n", __FUNCTION__, rx_dma_status);
#if 0
u32 regc50, regc58, reg824, reg800;
regc50 = rtw_read32(padapter, 0xc50);
regc58 = rtw_read32(padapter, 0xc58);
reg824 = rtw_read32(padapter, 0x824);
reg800 = rtw_read32(padapter, 0x800);
if (((regc50 & 0xFFFFFF00) != 0x69543400) ||
((regc58 & 0xFFFFFF00) != 0x69543400) ||
(((reg824 & 0xFFFFFF00) != 0x00390000) && (((reg824 & 0xFFFFFF00) != 0x80390000))) ||
(((reg800 & 0xFFFFFF00) != 0x03040000) && ((reg800 & 0xFFFFFF00) != 0x83040000))) {
RTW_INFO("%s regc50:0x%08x, regc58:0x%08x, reg824:0x%08x, reg800:0x%08x,\n", __FUNCTION__,
regc50, regc58, reg824, reg800);
rtw_hal_sreset_reset(padapter);
}
#endif
if (psrtpriv->dbg_trigger_point == SRESET_TGP_LINK_STATUS) {
psrtpriv->dbg_trigger_point = SRESET_TGP_NULL;
rtw_hal_sreset_reset(padapter);
return;
}
}
void rtl8812_sreset_xmit_status_check(_adapter *padapter)
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
unsigned long current_time;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
unsigned int diff_time;
u32 txdma_status;
txdma_status = rtw_read32(padapter, REG_TXDMA_STATUS);
if (txdma_status != 0x00) {
RTW_INFO("%s REG_TXDMA_STATUS:0x%08x\n", __FUNCTION__, txdma_status);
rtw_hal_sreset_reset(padapter);
}
#ifdef CONFIG_USB_HCI
/* total xmit irp = 4 */
/* RTW_INFO("==>%s free_xmitbuf_cnt(%d),txirp_cnt(%d)\n",__FUNCTION__,pxmitpriv->free_xmitbuf_cnt,pxmitpriv->txirp_cnt); */
/* if(pxmitpriv->txirp_cnt == NR_XMITBUFF+1) */
current_time = rtw_get_current_time();
if (0 == pxmitpriv->free_xmitbuf_cnt || 0 == pxmitpriv->free_xmit_extbuf_cnt) {
diff_time = rtw_get_passing_time_ms(psrtpriv->last_tx_time);
if (diff_time > 2000) {
if (psrtpriv->last_tx_complete_time == 0)
psrtpriv->last_tx_complete_time = current_time;
else {
diff_time = rtw_get_passing_time_ms(psrtpriv->last_tx_complete_time);
if (diff_time > 4000) {
u32 ability = 0;
/* padapter->Wifi_Error_Status = WIFI_TX_HANG; */
ability = rtw_phydm_ability_get(padapter);
RTW_INFO("%s tx hang %s\n", __FUNCTION__,
(ability & ODM_BB_ADAPTIVITY) ? "ODM_BB_ADAPTIVITY" : "");
if (!(ability & ODM_BB_ADAPTIVITY))
rtw_hal_sreset_reset(padapter);
}
}
}
}
#endif /* CONFIG_USB_HCI */
if (psrtpriv->dbg_trigger_point == SRESET_TGP_XMIT_STATUS) {
psrtpriv->dbg_trigger_point = SRESET_TGP_NULL;
rtw_hal_sreset_reset(padapter);
return;
}
}
u32 usb_read_interrupt(struct intf_hdl *pintfhdl, u32 addr)
{
int err;
unsigned int pipe;
u32 ret = _SUCCESS;
_adapter *adapter = pintfhdl->padapter;
struct dvobj_priv *pdvobj = adapter_to_dvobj(adapter);
struct recv_priv *precvpriv = &adapter->recvpriv;
struct usb_device *pusbd = pdvobj->pusbdev;
if (RTW_CANNOT_RX(adapter)) {
return _FAIL;
}
/*translate DMA FIFO addr to pipehandle*/
pipe = ffaddr2pipehdl(pdvobj, addr);
usb_fill_int_urb(precvpriv->int_in_urb, pusbd, pipe,
precvpriv->int_in_buf,
INTERRUPT_MSG_FORMAT_LEN,
usb_read_interrupt_complete,
adapter,
1);
err = usb_submit_urb(precvpriv->int_in_urb, GFP_ATOMIC);
if ((err) && (err != (-EPERM))) {
RTW_INFO("cannot submit interrupt in-token(err = 0x%08x), urb_status = %d\n", err, precvpriv->int_in_urb->status);
ret = _FAIL;
}
return ret;
}
void usb_write_port_cancel(struct intf_hdl *pintfhdl)
{
int i, j;
_adapter *padapter = pintfhdl->padapter;
struct xmit_buf *pxmitbuf = (struct xmit_buf *)padapter->xmitpriv.pxmitbuf;
RTW_INFO("%s\n", __func__);
for (i = 0; i < NR_XMITBUFF; i++) {
for (j = 0; j < 8; j++) {
if (pxmitbuf->pxmit_urb[j])
usb_kill_urb(pxmitbuf->pxmit_urb[j]);
}
pxmitbuf++;
}
pxmitbuf = (struct xmit_buf *)padapter->xmitpriv.pxmit_extbuf;
for (i = 0; i < NR_XMIT_EXTBUFF ; i++) {
for (j = 0; j < 8; j++) {
if (pxmitbuf->pxmit_urb[j])
usb_kill_urb(pxmitbuf->pxmit_urb[j]);
}
pxmitbuf++;
}
}
void usb_recv_tasklet(void *priv)
{
_pkt *pskb;
_adapter *padapter = (_adapter *)priv;
struct recv_priv *precvpriv = &padapter->recvpriv;
struct recv_buf *precvbuf = NULL;
while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue))) {
if (RTW_CANNOT_RUN(padapter)) {
RTW_INFO("recv_tasklet => bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
, rtw_is_drv_stopped(padapter) ? "True" : "False"
, rtw_is_surprise_removed(padapter) ? "True" : "False");
#ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
if (rtw_free_skb_premem(pskb) != 0)
#endif /* CONFIG_PREALLOC_RX_SKB_BUFFER */
rtw_skb_free(pskb);
break;
}
recvbuf2recvframe(padapter, pskb);
skb_reset_tail_pointer(pskb);
pskb->len = 0;
skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue);
if (NULL != precvbuf) {
precvbuf->pskb = NULL;
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
}
static void config_chip_out_EP(PADAPTER padapter, u8 NumOutPipe)
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
pHalData->OutEpQueueSel = 0;
pHalData->OutEpNumber = 0;
switch (NumOutPipe) {
case 4:
pHalData->OutEpQueueSel = TX_SELE_HQ | TX_SELE_LQ | TX_SELE_NQ;
pHalData->OutEpNumber = 4;
break;
case 3:
pHalData->OutEpQueueSel = TX_SELE_HQ | TX_SELE_LQ | TX_SELE_NQ;
pHalData->OutEpNumber = 3;
break;
case 2:
pHalData->OutEpQueueSel = TX_SELE_HQ | TX_SELE_NQ;
pHalData->OutEpNumber = 2;
break;
case 1:
pHalData->OutEpQueueSel = TX_SELE_HQ;
pHalData->OutEpNumber = 1;
break;
default:
break;
}
/* RTW_INFO("%s OutEpQueueSel(0x%02x), OutEpNumber(%d)\n", __func__, pHalData->OutEpQueueSel, pHalData->OutEpNumber); */
RTW_INFO("%s OutEpQueueSel(0x%02x), OutEpNumber(%d)\n", __func__, pHalData->OutEpQueueSel, pHalData->OutEpNumber);
}
/*
* Return:
* _SUCCESS Download Firmware MEM OK.
* _FAIL Download Firmware MEM FAIL!
*/
s32 rtl8821c_fw_mem_dl(PADAPTER adapter, enum fw_mem mem)
{
struct dvobj_priv *d = adapter_to_dvobj(adapter);
HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter);
int err = 0;
u8 fw_bin = _TRUE;
#ifdef CONFIG_FILE_FWIMG
fw_bin = _TRUE;
rtw_get_phy_file_path(adapter, MAC_FILE_FW_NIC);
err = rtw_halmac_dlfw_mem_from_file(d, rtw_phy_para_file_path, mem);
#else
fw_bin = _FALSE;
err = rtw_halmac_dlfw_mem(d, array_mp_8821c_fw_nic, array_length_mp_8821c_fw_nic, mem);
#endif
if (err) {
RTW_ERR("%s Download Firmware MEM from %s failed\n", __func__, (fw_bin) ? "file" : "array");
return _FAIL;
}
RTW_INFO("%s Download Firmware MEM from %s success\n", __func__, (fw_bin) ? "file" : "array");
return _SUCCESS;
}
static u8 _rtw_mi_hal_dump_macaddr(_adapter *padapter, void *data)
{
u8 mac_addr[ETH_ALEN] = {0};
rtw_hal_get_macaddr_port(padapter, mac_addr);
RTW_INFO(ADPT_FMT"MAC Address ="MAC_FMT"\n", ADPT_ARG(padapter), MAC_ARG(mac_addr));
return _TRUE;
}
void _rtw_reg_notifier(struct wiphy *wiphy, struct regulatory_request *request)
{
struct rtw_regulatory *reg = NULL;
RTW_INFO("%s\n", __func__);
_rtw_reg_notifier_apply(wiphy, request, reg);
}
void usb_read_interrupt_complete(struct urb *purb, struct pt_regs *regs)
{
int err;
_adapter *padapter = (_adapter *)purb->context;
if (RTW_CANNOT_RX(padapter)) {
RTW_INFO("%s() RX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
, __func__
, rtw_is_drv_stopped(padapter) ? "True" : "False"
, rtw_is_surprise_removed(padapter) ? "True" : "False");
return;
}
if (purb->status == 0) {/*SUCCESS*/
if (purb->actual_length > INTERRUPT_MSG_FORMAT_LEN)
RTW_INFO("usb_read_interrupt_complete: purb->actual_length > INTERRUPT_MSG_FORMAT_LEN(%d)\n", INTERRUPT_MSG_FORMAT_LEN);
rtw_hal_interrupt_handler(padapter, purb->actual_length, purb->transfer_buffer);
err = usb_submit_urb(purb, GFP_ATOMIC);
if ((err) && (err != (-EPERM)))
RTW_INFO("cannot submit interrupt in-token(err = 0x%08x),urb_status = %d\n", err, purb->status);
} else {
RTW_INFO("###=> usb_read_interrupt_complete => urb status(%d)\n", purb->status);
switch (purb->status) {
case -EINVAL:
case -EPIPE:
case -ENODEV:
case -ESHUTDOWN:
case -ENOENT:
rtw_set_drv_stopped(padapter);
break;
case -EPROTO:
break;
case -EINPROGRESS:
RTW_INFO("ERROR: URB IS IN PROGRESS!/n");
break;
default:
break;
}
}
}
void rtw_dbg_skb_process(_adapter *padapter, union recv_frame *precvframe, union recv_frame *pcloneframe)
{
_pkt *pkt_copy, *pkt_org;
pkt_org = precvframe->u.hdr.pkt;
pkt_copy = pcloneframe->u.hdr.pkt;
/*
RTW_INFO("%s ===== ORG SKB =====\n", __func__);
RTW_INFO(" SKB head(%p)\n", pkt_org->head);
RTW_INFO(" SKB data(%p)\n", pkt_org->data);
RTW_INFO(" SKB tail(%p)\n", pkt_org->tail);
RTW_INFO(" SKB end(%p)\n", pkt_org->end);
RTW_INFO(" recv frame head(%p)\n", precvframe->u.hdr.rx_head);
RTW_INFO(" recv frame data(%p)\n", precvframe->u.hdr.rx_data);
RTW_INFO(" recv frame tail(%p)\n", precvframe->u.hdr.rx_tail);
RTW_INFO(" recv frame end(%p)\n", precvframe->u.hdr.rx_end);
RTW_INFO("%s ===== COPY SKB =====\n", __func__);
RTW_INFO(" SKB head(%p)\n", pkt_copy->head);
RTW_INFO(" SKB data(%p)\n", pkt_copy->data);
RTW_INFO(" SKB tail(%p)\n", pkt_copy->tail);
RTW_INFO(" SKB end(%p)\n", pkt_copy->end);
RTW_INFO(" recv frame head(%p)\n", pcloneframe->u.hdr.rx_head);
RTW_INFO(" recv frame data(%p)\n", pcloneframe->u.hdr.rx_data);
RTW_INFO(" recv frame tail(%p)\n", pcloneframe->u.hdr.rx_tail);
RTW_INFO(" recv frame end(%p)\n", pcloneframe->u.hdr.rx_end);
*/
/*
RTW_INFO("%s => recv_frame adapter(%p,%p)\n", __func__, precvframe->u.hdr.adapter, pcloneframe->u.hdr.adapter);
RTW_INFO("%s => recv_frame dev(%p,%p)\n", __func__, pkt_org->dev , pkt_copy->dev);
RTW_INFO("%s => recv_frame len(%d,%d)\n", __func__, precvframe->u.hdr.len, pcloneframe->u.hdr.len);
*/
if (precvframe->u.hdr.len != pcloneframe->u.hdr.len)
RTW_INFO("%s [WARN] recv_frame length(%d:%d) compare failed\n", __func__, precvframe->u.hdr.len, pcloneframe->u.hdr.len);
if (_rtw_memcmp(&precvframe->u.hdr.attrib, &pcloneframe->u.hdr.attrib, sizeof(struct rx_pkt_attrib)) == _FALSE)
RTW_INFO("%s [WARN] recv_frame attrib compare failed\n", __func__);
if (_rtw_memcmp(precvframe->u.hdr.rx_data, pcloneframe->u.hdr.rx_data, precvframe->u.hdr.len) == _FALSE)
RTW_INFO("%s [WARN] recv_frame rx_data compare failed\n", __func__);
}
static u8 _rtw_mi_beacon_update(_adapter *padapter, void *data)
{
struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
if (mlmeext_msr(mlmeext) == WIFI_FW_AP_STATE
&& check_fwstate(&padapter->mlmepriv, _FW_LINKED) == _TRUE) {
RTW_INFO(ADPT_FMT"-WIFI_FW_AP_STATE - update_beacon\n", ADPT_ARG(padapter));
update_beacon(padapter, 0, NULL, _TRUE);
}
return _TRUE;
}
u32 rtl8821cu_hal_deinit(PADAPTER padapter)
{
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
struct dvobj_priv *pobj_priv = adapter_to_dvobj(padapter);
u8 status = _TRUE;
RTW_INFO("==> %s\n", __func__);
hal_deinit_misc(padapter);
status = rtl8821c_hal_deinit(padapter);
if (status == _FALSE) {
RTW_INFO("%s: rtl8821c_hal_deinit fail\n", __func__);
return _FAIL;
}
RTW_INFO("%s <==\n", __func__);
return _SUCCESS;
}
void rtw_os_pkt_complete(_adapter *padapter, _pkt *pkt)
{
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
u16 qidx;
qidx = skb_get_queue_mapping(pkt);
if (rtw_os_need_wake_queue(padapter, qidx)) {
if (DBG_DUMP_OS_QUEUE_CTL)
RTW_INFO(FUNC_ADPT_FMT": netif_wake_subqueue[%d]\n", FUNC_ADPT_ARG(padapter), qidx);
netif_wake_subqueue(padapter->pnetdev, qidx);
}
#else
if (rtw_os_need_wake_queue(padapter, 0)) {
if (DBG_DUMP_OS_QUEUE_CTL)
RTW_INFO(FUNC_ADPT_FMT": netif_wake_queue\n", FUNC_ADPT_ARG(padapter));
netif_wake_queue(padapter->pnetdev);
}
#endif
rtw_skb_free(pkt);
}
u32 rtl8821cu_hal_init(PADAPTER padapter)
{
u8 status = _SUCCESS;
u32 init_start_time = rtw_get_current_time();
if (_FALSE == rtl8821c_hal_init(padapter))
return _FAIL;
RTW_INFO("%s in %dms\n", __func__, rtw_get_passing_time_ms(init_start_time));
return status;
}
u32 rtl8821cu_inirp_init(PADAPTER padapter)
{
u8 i, status;
struct recv_buf *precvbuf;
struct dvobj_priv *pdev = adapter_to_dvobj(padapter);
struct intf_hdl *pintfhdl = &padapter->iopriv.intf;
struct recv_priv *precvpriv = &(padapter->recvpriv);
u32(*_read_port)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
u32(*_read_interrupt)(struct intf_hdl *pintfhdl, u32 addr);
#endif
_read_port = pintfhdl->io_ops._read_port;
status = _SUCCESS;
precvpriv->ff_hwaddr = RECV_BULK_IN_ADDR;
/* issue Rx irp to receive data */
precvbuf = (struct recv_buf *)precvpriv->precv_buf;
for (i = 0; i < NR_RECVBUFF; i++) {
if (_read_port(pintfhdl, precvpriv->ff_hwaddr, 0, (u8 *)precvbuf) == _FALSE) {
status = _FAIL;
goto exit;
}
precvbuf++;
precvpriv->free_recv_buf_queue_cnt--;
}
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
if (pdev->RtInPipe[REALTEK_USB_IN_INT_EP_IDX] != 0x05) {
status = _FAIL;
/* RTW_INFO("%s =>Warning !! Have not USB Int-IN pipe, RtIntInPipe(%d)!!!\n", __func__, pdev->RtInPipe[REALTEK_USB_IN_INT_EP_IDX]); */
RTW_INFO("%s =>Warning !! Have not USB Int-IN pipe, RtIntInPipe(%d)!!!\n", __func__, pdev->RtInPipe[REALTEK_USB_IN_INT_EP_IDX]);
goto exit;
}
_read_interrupt = pintfhdl->io_ops._read_interrupt;
if (_read_interrupt(pintfhdl, RECV_INT_IN_ADDR) == _FALSE) {
status = _FAIL;
}
#endif
exit:
return status;
}
static void _dbg_dump_macreg(PADAPTER padapter)
{
u32 offset = 0;
u32 val32 = 0;
u32 index = 0;
for (index = 0; index < 64; index++) {
offset = index * 4;
val32 = rtw_read32(padapter, offset);
/* RTW_INFO("offset : 0x%02x ,val:0x%08x\n", offset, val32); */
RTW_INFO("offset : 0x%02x ,val:0x%08x\n", offset, val32);
}
}
static int _rtw_reg_notifier_apply(struct wiphy *wiphy,
struct regulatory_request *request,
struct rtw_regulatory *reg)
{
/* Hard code flags */
_rtw_reg_apply_flags(wiphy);
/* We always apply this */
_rtw_reg_apply_radar_flags(wiphy);
switch (request->initiator) {
case NL80211_REGDOM_SET_BY_DRIVER:
RTW_INFO("%s: %s\n", __func__, "NL80211_REGDOM_SET_BY_DRIVER");
_rtw_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER,
reg);
break;
case NL80211_REGDOM_SET_BY_CORE:
RTW_INFO("%s: %s\n", __func__,
"NL80211_REGDOM_SET_BY_CORE to DRV");
_rtw_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER,
reg);
break;
case NL80211_REGDOM_SET_BY_USER:
RTW_INFO("%s: %s\n", __func__,
"NL80211_REGDOM_SET_BY_USER to DRV");
_rtw_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER,
reg);
break;
case NL80211_REGDOM_SET_BY_COUNTRY_IE:
RTW_INFO("%s: %s\n", __func__,
"NL80211_REGDOM_SET_BY_COUNTRY_IE");
_rtw_reg_apply_world_flags(wiphy, request->initiator, reg);
break;
}
return 0;
}
void platform_wifi_power_off(void)
{
#ifdef CONFIG_MMC
#if defined(CONFIG_PLATFORM_ARM_SUN6I) || defined(CONFIG_PLATFORM_ARM_SUN7I)
sw_mci_rescan_card(sdc_id, 0);
#elif defined(CONFIG_PLATFORM_ARM_SUN8I)
sunxi_mci_rescan_card(sdc_id, 0);
#endif
mdelay(100);
wifi_pm_power(0);
RTW_INFO("%s: remove card, power off.\n", __FUNCTION__);
#endif /* CONFIG_MMC */
}
u8 rtw_mi_buddy_under_survey(_adapter *padapter)
{
int i;
u8 ret = 0;
_adapter *iface = NULL;
_irqL irqL;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
#ifdef CONFIG_IOCTL_CFG80211
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
#endif
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_priv *buddy_mlmepriv;
struct rtw_wdev_priv *buddy_wdev_priv;
for (i = 0; i < dvobj->iface_nums; i++) {
iface = dvobj->padapters[i];
if ((iface) && rtw_is_adapter_up(iface)) {
if (iface == padapter)
continue;
buddy_mlmepriv = &iface->mlmepriv;
if (check_fwstate(buddy_mlmepriv, _FW_UNDER_SURVEY)) {
ret = UNDER_SURVEY_T1;
#ifdef CONFIG_IOCTL_CFG80211
buddy_wdev_priv = adapter_wdev_data(iface);
_enter_critical_bh(&pwdev_priv->scan_req_lock, &irqL);
_enter_critical_bh(&buddy_wdev_priv->scan_req_lock, &irqL);
if (buddy_wdev_priv->scan_request) {
pmlmepriv->scanning_via_buddy_intf = _TRUE;
_enter_critical_bh(&pmlmepriv->lock, &irqL);
set_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
_exit_critical_bh(&pmlmepriv->lock, &irqL);
ret = UNDER_SURVEY_T2;
}
_exit_critical_bh(&buddy_wdev_priv->scan_req_lock, &irqL);
_exit_critical_bh(&pwdev_priv->scan_req_lock, &irqL);
#endif
RTW_INFO(ADPT_FMT"_FW_UNDER_SURVEY\n", ADPT_ARG(iface));
return ret;
}
}
}
return ret;
}
void rtw_set_tx_chksum_offload(_pkt *pkt, struct pkt_attrib *pattrib)
{
#ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
struct sk_buff *skb = (struct sk_buff *)pkt;
pattrib->hw_tcp_csum = 0;
if (skb->ip_summed == CHECKSUM_PARTIAL) {
if (skb_shinfo(skb)->nr_frags == 0) {
const struct iphdr *ip = ip_hdr(skb);
if (ip->protocol == IPPROTO_TCP) {
/* TCP checksum offload by HW */
RTW_INFO("CHECKSUM_PARTIAL TCP\n");
pattrib->hw_tcp_csum = 1;
/* skb_checksum_help(skb); */
} else if (ip->protocol == IPPROTO_UDP) {
/* RTW_INFO("CHECKSUM_PARTIAL UDP\n"); */
#if 1
skb_checksum_help(skb);
#else
/* Set UDP checksum = 0 to skip checksum check */
struct udphdr *udp = skb_transport_header(skb);
udp->check = 0;
#endif
} else {
RTW_INFO("%s-%d TCP CSUM offload Error!!\n", __FUNCTION__, __LINE__);
WARN_ON(1); /* we need a WARN() */
}
} else { /* IP fragmentation case */
RTW_INFO("%s-%d nr_frags != 0, using skb_checksum_help(skb);!!\n", __FUNCTION__, __LINE__);
skb_checksum_help(skb);
}
}
#endif
}
/*
* Return:
* _SUCCESS Download Firmware OK.
* _FAIL Download Firmware FAIL!
*/
s32 rtl8821c_fw_dl(PADAPTER adapter, u8 wowlan)
{
struct dvobj_priv *d = adapter_to_dvobj(adapter);
HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter);
int err;
u8 fw_bin = _TRUE;
#ifdef CONFIG_FILE_FWIMG
fw_bin = _TRUE;
if (_TRUE == wowlan) {
rtw_get_phy_file_path(adapter, MAC_FILE_FW_WW_IMG);
err = rtw_halmac_dlfw_from_file(d, rtw_phy_para_file_path);
} else {
rtw_get_phy_file_path(adapter, MAC_FILE_FW_NIC);
err = rtw_halmac_dlfw_from_file(d, rtw_phy_para_file_path);
}
#else
fw_bin = _FALSE;
if (_TRUE == wowlan)
err = rtw_halmac_dlfw(d, array_mp_8821c_fw_wowlan, array_length_mp_8821c_fw_wowlan);
else
err = rtw_halmac_dlfw(d, array_mp_8821c_fw_nic, array_length_mp_8821c_fw_nic);
#endif
if (!err) {
adapter->bFWReady = _TRUE;
hal_data->fw_ractrl = _TRUE;
RTW_INFO("%s Download Firmware from %s success\n", __func__, (fw_bin) ? "file" : "array");
RTW_INFO("%s FW Version:%d SubVersion:%d\n", (wowlan) ? "WOW" : "NIC", hal_data->firmware_version, hal_data->firmware_sub_version);
return _SUCCESS;
} else {
RTW_ERR("%s Download Firmware from %s failed\n", __func__, (fw_bin) ? "file" : "array");
return _FAIL;
}
}
static bool rtw_check_xmit_resource(_adapter *padapter, _pkt *pkt)
{
bool busy = _FALSE;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
u16 qidx;
qidx = skb_get_queue_mapping(pkt);
if (rtw_os_need_stop_queue(padapter, qidx)) {
if (DBG_DUMP_OS_QUEUE_CTL)
RTW_INFO(FUNC_ADPT_FMT": netif_stop_subqueue[%d]\n", FUNC_ADPT_ARG(padapter), qidx);
netif_stop_subqueue(padapter->pnetdev, qidx);
busy = _TRUE;
}
#else
if (rtw_os_need_stop_queue(padapter, 0)) {
if (DBG_DUMP_OS_QUEUE_CTL)
RTW_INFO(FUNC_ADPT_FMT": netif_stop_queue\n", FUNC_ADPT_ARG(padapter));
rtw_netif_stop_queue(padapter->pnetdev);
busy = _TRUE;
}
#endif
return busy;
}
u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
{
int err;
unsigned int pipe;
u32 ret = _SUCCESS;
PURB purb = NULL;
struct recv_buf *precvbuf = (struct recv_buf *)rmem;
_adapter *adapter = pintfhdl->padapter;
struct dvobj_priv *pdvobj = adapter_to_dvobj(adapter);
struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj);
struct recv_priv *precvpriv = &adapter->recvpriv;
struct usb_device *pusbd = pdvobj->pusbdev;
if (RTW_CANNOT_RX(adapter) || (precvbuf == NULL)) {
return _FAIL;
}
usb_init_recvbuf(adapter, precvbuf);
if (precvbuf->pbuf) {
ATOMIC_INC(&(precvpriv->rx_pending_cnt));
purb = precvbuf->purb;
/* translate DMA FIFO addr to pipehandle */
pipe = ffaddr2pipehdl(pdvobj, addr);
usb_fill_bulk_urb(purb, pusbd, pipe,
precvbuf->pbuf,
MAX_RECVBUF_SZ,
usb_read_port_complete,
precvbuf);/* context is precvbuf */
purb->transfer_dma = precvbuf->dma_transfer_addr;
purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
err = usb_submit_urb(purb, GFP_ATOMIC);
if ((err) && (err != (-EPERM))) {
RTW_INFO("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n", err, purb->status);
ret = _FAIL;
}
}
return ret;
}
static s32 _rtw_mi_buddy_clone_bcmc_packet(_adapter *adapter, union recv_frame *precvframe, u8 *pphy_status, union recv_frame *pcloneframe)
{
s32 ret = _SUCCESS;
u8 *pbuf = precvframe->u.hdr.rx_data;
struct rx_pkt_attrib *pattrib = NULL;
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(adapter);
if (pcloneframe) {
pcloneframe->u.hdr.adapter = adapter;
_rtw_init_listhead(&pcloneframe->u.hdr.list);
pcloneframe->u.hdr.precvbuf = NULL; /*can't access the precvbuf for new arch.*/
pcloneframe->u.hdr.len = 0;
_rtw_memcpy(&pcloneframe->u.hdr.attrib, &precvframe->u.hdr.attrib, sizeof(struct rx_pkt_attrib));
pattrib = &pcloneframe->u.hdr.attrib;
#ifdef CONFIG_SKB_ALLOCATED
if (rtw_os_alloc_recvframe(adapter, pcloneframe, pbuf, NULL) == _SUCCESS)
#else
if (rtw_os_recvframe_duplicate_skb(adapter, pcloneframe, precvframe->u.hdr.pkt) == _SUCCESS)
#endif
{
#ifdef CONFIG_SKB_ALLOCATED
recvframe_put(pcloneframe, pattrib->pkt_len);
#endif
#ifdef DBG_SKB_PROCESS
rtw_dbg_skb_process(adapter, precvframe, pcloneframe);
#endif
if (pattrib->physt && pphy_status)
rx_query_phy_status(pcloneframe, pphy_status);
ret = rtw_recv_entry(pcloneframe);
} else {
ret = -1;
RTW_INFO("%s()-%d: rtw_os_alloc_recvframe() failed!\n", __func__, __LINE__);
}
}
return ret;
}
void usb_recv_tasklet(void *priv)
{
struct recv_buf *precvbuf = NULL;
_adapter *padapter = (_adapter *)priv;
struct recv_priv *precvpriv = &padapter->recvpriv;
while (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue))) {
if (RTW_CANNOT_RUN(padapter)) {
RTW_INFO("recv_tasklet => bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
, rtw_is_drv_stopped(padapter)? "True" : "False"
, rtw_is_surprise_removed(padapter)? "True" : "False");
break;
}
recvbuf2recvframe(padapter, precvbuf);
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
}
}
u8 _rtw_mi_busy_traffic_check(_adapter *padapter, void *data)
{
u32 passtime;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
bool check_sc_interval = *(bool *)data;
if (pmlmepriv->LinkDetectInfo.bBusyTraffic == _TRUE) {
if (check_sc_interval) {
/* Miracast can't do AP scan*/
passtime = rtw_get_passing_time_ms(pmlmepriv->lastscantime);
pmlmepriv->lastscantime = rtw_get_current_time();
if (passtime > BUSY_TRAFFIC_SCAN_DENY_PERIOD) {
RTW_INFO(ADPT_FMT" bBusyTraffic == _TRUE\n", ADPT_ARG(padapter));
return _TRUE;
}
} else
return _TRUE;
}
return _FALSE;
}
