1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
6 *******************************************************************************/
10 #include <rtw_debug.h>
11 #include <rtl8723b_hal.h>
13 /* define SDIO_DEBUG_IO 1 */
18 /* The following mapping is for SDIO host local register space. */
20 /* Creadted by Roger, 2011.01.31. */
22 static void HalSdioGetCmdAddr8723BSdio(
23 struct adapter *adapter,
30 case SDIO_LOCAL_DEVICE_ID:
31 *cmdaddr = ((SDIO_LOCAL_DEVICE_ID << 13) | (addr & SDIO_LOCAL_MSK));
34 case WLAN_IOREG_DEVICE_ID:
35 *cmdaddr = ((WLAN_IOREG_DEVICE_ID << 13) | (addr & WLAN_IOREG_MSK));
38 case WLAN_TX_HIQ_DEVICE_ID:
39 *cmdaddr = ((WLAN_TX_HIQ_DEVICE_ID << 13) | (addr & WLAN_FIFO_MSK));
42 case WLAN_TX_MIQ_DEVICE_ID:
43 *cmdaddr = ((WLAN_TX_MIQ_DEVICE_ID << 13) | (addr & WLAN_FIFO_MSK));
46 case WLAN_TX_LOQ_DEVICE_ID:
47 *cmdaddr = ((WLAN_TX_LOQ_DEVICE_ID << 13) | (addr & WLAN_FIFO_MSK));
50 case WLAN_RX0FF_DEVICE_ID:
51 *cmdaddr = ((WLAN_RX0FF_DEVICE_ID << 13) | (addr & WLAN_RX0FF_MSK));
59 static u8 get_deviceid(u32 addr)
64 pseudo_id = (u16)(addr >> 16);
67 devide_id = SDIO_LOCAL_DEVICE_ID;
71 devide_id = WLAN_IOREG_DEVICE_ID;
75 devide_id = WLAN_TX_HIQ_DEVICE_ID;
79 devide_id = WLAN_TX_MIQ_DEVICE_ID;
83 devide_id = WLAN_TX_LOQ_DEVICE_ID;
87 devide_id = WLAN_RX0FF_DEVICE_ID;
91 devide_id = WLAN_IOREG_DEVICE_ID;
100 *HalSdioGetCmdAddr8723BSdio()
102 static u32 _cvrt2ftaddr(const u32 addr, u8 *pdevice_id, u16 *poffset)
108 device_id = get_deviceid(addr);
112 case SDIO_LOCAL_DEVICE_ID:
113 offset = addr & SDIO_LOCAL_MSK;
116 case WLAN_TX_HIQ_DEVICE_ID:
117 case WLAN_TX_MIQ_DEVICE_ID:
118 case WLAN_TX_LOQ_DEVICE_ID:
119 offset = addr & WLAN_FIFO_MSK;
122 case WLAN_RX0FF_DEVICE_ID:
123 offset = addr & WLAN_RX0FF_MSK;
126 case WLAN_IOREG_DEVICE_ID:
128 device_id = WLAN_IOREG_DEVICE_ID;
129 offset = addr & WLAN_IOREG_MSK;
132 ftaddr = (device_id << 13) | offset;
135 *pdevice_id = device_id;
142 static u8 sdio_read8(struct intf_hdl *intfhdl, u32 addr)
145 ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
147 return sd_read8(intfhdl, ftaddr, NULL);
150 static u16 sdio_read16(struct intf_hdl *intfhdl, u32 addr)
155 ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
156 sd_cmd52_read(intfhdl, ftaddr, 2, (u8 *)&le_tmp);
158 return le16_to_cpu(le_tmp);
161 static u32 sdio_read32(struct intf_hdl *intfhdl, u32 addr)
163 struct adapter *adapter;
173 adapter = intfhdl->padapter;
174 ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
176 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
178 ((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
179 (!mac_pwr_ctrl_on) ||
180 (adapter_to_pwrctl(adapter)->bFwCurrentInPSMode)
182 err = sd_cmd52_read(intfhdl, ftaddr, 4, (u8 *)&le_tmp);
186 return le32_to_cpu(le_tmp);
190 DBG_8192C(KERN_ERR "%s: Mac Power off, Read FAIL(%d)! addr = 0x%x\n", __func__, err, addr);
191 return SDIO_ERR_VAL32;
195 /* 4 bytes alignment */
196 shift = ftaddr & 0x3;
198 val = sd_read32(intfhdl, ftaddr, NULL);
202 tmpbuf = rtw_malloc(8);
204 DBG_8192C(KERN_ERR "%s: Allocate memory FAIL!(size =8) addr = 0x%x\n", __func__, addr);
205 return SDIO_ERR_VAL32;
209 sd_read(intfhdl, ftaddr, 8, tmpbuf);
210 memcpy(&le_tmp, tmpbuf + shift, 4);
211 val = le32_to_cpu(le_tmp);
218 static s32 sdio_readN(struct intf_hdl *intfhdl, u32 addr, u32 cnt, u8 *buf)
220 struct adapter *adapter;
228 adapter = intfhdl->padapter;
231 ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
233 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
235 ((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
236 (!mac_pwr_ctrl_on) ||
237 (adapter_to_pwrctl(adapter)->bFwCurrentInPSMode)
239 return sd_cmd52_read(intfhdl, ftaddr, cnt, buf);
241 /* 4 bytes alignment */
242 shift = ftaddr & 0x3;
244 err = sd_read(intfhdl, ftaddr, cnt, buf);
251 tmpbuf = rtw_malloc(n);
255 err = sd_read(intfhdl, ftaddr, n, tmpbuf);
257 memcpy(buf, tmpbuf + shift, cnt);
263 static s32 sdio_write8(struct intf_hdl *intfhdl, u32 addr, u8 val)
268 ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
269 sd_write8(intfhdl, ftaddr, val, &err);
274 static s32 sdio_write16(struct intf_hdl *intfhdl, u32 addr, u16 val)
279 ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
280 le_tmp = cpu_to_le16(val);
281 return sd_cmd52_write(intfhdl, ftaddr, 2, (u8 *)&le_tmp);
284 static s32 sdio_write32(struct intf_hdl *intfhdl, u32 addr, u32 val)
286 struct adapter *adapter;
295 adapter = intfhdl->padapter;
298 ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
300 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
302 ((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
303 (!mac_pwr_ctrl_on) ||
304 (adapter_to_pwrctl(adapter)->bFwCurrentInPSMode)
306 le_tmp = cpu_to_le32(val);
308 return sd_cmd52_write(intfhdl, ftaddr, 4, (u8 *)&le_tmp);
311 /* 4 bytes alignment */
312 shift = ftaddr & 0x3;
314 sd_write32(intfhdl, ftaddr, val, &err);
316 le_tmp = cpu_to_le32(val);
317 err = sd_cmd52_write(intfhdl, ftaddr, 4, (u8 *)&le_tmp);
322 static s32 sdio_writeN(struct intf_hdl *intfhdl, u32 addr, u32 cnt, u8 *buf)
324 struct adapter *adapter;
332 adapter = intfhdl->padapter;
335 ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
337 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
339 ((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
340 (!mac_pwr_ctrl_on) ||
341 (adapter_to_pwrctl(adapter)->bFwCurrentInPSMode)
343 return sd_cmd52_write(intfhdl, ftaddr, cnt, buf);
345 shift = ftaddr & 0x3;
347 err = sd_write(intfhdl, ftaddr, cnt, buf);
354 tmpbuf = rtw_malloc(n);
357 err = sd_read(intfhdl, ftaddr, 4, tmpbuf);
362 memcpy(tmpbuf + shift, buf, cnt);
363 err = sd_write(intfhdl, ftaddr, n, tmpbuf);
369 static u8 sdio_f0_read8(struct intf_hdl *intfhdl, u32 addr)
371 return sd_f0_read8(intfhdl, addr, NULL);
374 static void sdio_read_mem(
375 struct intf_hdl *intfhdl,
383 err = sdio_readN(intfhdl, addr, cnt, rmem);
384 /* TODO: Report error is err not zero */
387 static void sdio_write_mem(
388 struct intf_hdl *intfhdl,
394 sdio_writeN(intfhdl, addr, cnt, wmem);
400 *Round read size to block size,
401 *and make sure data transfer will be done in one command.
404 *intfhdl a pointer of intf_hdl
407 *rmem address to put data
413 static u32 sdio_read_port(
414 struct intf_hdl *intfhdl,
420 struct adapter *adapter;
421 struct sdio_data *psdio;
422 struct hal_com_data *hal;
425 adapter = intfhdl->padapter;
426 psdio = &adapter_to_dvobj(adapter)->intf_data;
427 hal = GET_HAL_DATA(adapter);
429 HalSdioGetCmdAddr8723BSdio(adapter, addr, hal->SdioRxFIFOCnt++, &addr);
431 if (cnt > psdio->block_transfer_len)
432 cnt = _RND(cnt, psdio->block_transfer_len);
434 err = _sd_read(intfhdl, addr, cnt, mem);
444 *Align write size block size,
445 *and make sure data could be written in one command.
448 *intfhdl a pointer of intf_hdl
451 *wmem data pointer to write
457 static u32 sdio_write_port(
458 struct intf_hdl *intfhdl,
464 struct adapter *adapter;
465 struct sdio_data *psdio;
467 struct xmit_buf *xmitbuf = (struct xmit_buf *)mem;
469 adapter = intfhdl->padapter;
470 psdio = &adapter_to_dvobj(adapter)->intf_data;
472 if (!adapter->hw_init_completed) {
473 DBG_871X("%s [addr = 0x%x cnt =%d] adapter->hw_init_completed == false\n", __func__, addr, cnt);
478 HalSdioGetCmdAddr8723BSdio(adapter, addr, cnt >> 2, &addr);
480 if (cnt > psdio->block_transfer_len)
481 cnt = _RND(cnt, psdio->block_transfer_len);
483 err = sd_write(intfhdl, addr, cnt, xmitbuf->pdata);
487 err ? RTW_SCTX_DONE_WRITE_PORT_ERR : RTW_SCTX_DONE_SUCCESS
495 void sdio_set_intf_ops(struct adapter *adapter, struct _io_ops *ops)
497 ops->_read8 = &sdio_read8;
498 ops->_read16 = &sdio_read16;
499 ops->_read32 = &sdio_read32;
500 ops->_read_mem = &sdio_read_mem;
501 ops->_read_port = &sdio_read_port;
503 ops->_write8 = &sdio_write8;
504 ops->_write16 = &sdio_write16;
505 ops->_write32 = &sdio_write32;
506 ops->_writeN = &sdio_writeN;
507 ops->_write_mem = &sdio_write_mem;
508 ops->_write_port = &sdio_write_port;
510 ops->_sd_f0_read8 = sdio_f0_read8;
514 * Todo: align address to 4 bytes.
516 static s32 _sdio_local_read(
517 struct adapter *adapter,
523 struct intf_hdl *intfhdl;
529 intfhdl = &adapter->iopriv.intf;
531 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
533 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
534 if (!mac_pwr_ctrl_on)
535 return _sd_cmd52_read(intfhdl, addr, cnt, buf);
538 tmpbuf = rtw_malloc(n);
542 err = _sd_read(intfhdl, addr, n, tmpbuf);
544 memcpy(buf, tmpbuf, cnt);
552 * Todo: align address to 4 bytes.
555 struct adapter *adapter,
561 struct intf_hdl *intfhdl;
567 intfhdl = &adapter->iopriv.intf;
569 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
571 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
573 (!mac_pwr_ctrl_on) ||
574 (adapter_to_pwrctl(adapter)->bFwCurrentInPSMode)
576 return sd_cmd52_read(intfhdl, addr, cnt, buf);
579 tmpbuf = rtw_malloc(n);
583 err = sd_read(intfhdl, addr, n, tmpbuf);
585 memcpy(buf, tmpbuf, cnt);
593 * Todo: align address to 4 bytes.
595 s32 sdio_local_write(
596 struct adapter *adapter,
602 struct intf_hdl *intfhdl;
608 DBG_8192C("%s, address must be 4 bytes alignment\n", __func__);
611 DBG_8192C("%s, size must be the multiple of 4\n", __func__);
613 intfhdl = &adapter->iopriv.intf;
615 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
617 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
619 (!mac_pwr_ctrl_on) ||
620 (adapter_to_pwrctl(adapter)->bFwCurrentInPSMode)
622 return sd_cmd52_write(intfhdl, addr, cnt, buf);
624 tmpbuf = rtw_malloc(cnt);
628 memcpy(tmpbuf, buf, cnt);
630 err = sd_write(intfhdl, addr, cnt, tmpbuf);
637 u8 SdioLocalCmd52Read1Byte(struct adapter *adapter, u32 addr)
640 struct intf_hdl *intfhdl = &adapter->iopriv.intf;
642 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
643 sd_cmd52_read(intfhdl, addr, 1, &val);
648 static u16 SdioLocalCmd52Read2Byte(struct adapter *adapter, u32 addr)
651 struct intf_hdl *intfhdl = &adapter->iopriv.intf;
653 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
654 sd_cmd52_read(intfhdl, addr, 2, (u8 *)&val);
656 return le16_to_cpu(val);
659 static u32 SdioLocalCmd53Read4Byte(struct adapter *adapter, u32 addr)
664 struct intf_hdl *intfhdl = &adapter->iopriv.intf;
667 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
668 rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
669 if (!mac_pwr_ctrl_on || adapter_to_pwrctl(adapter)->bFwCurrentInPSMode) {
670 sd_cmd52_read(intfhdl, addr, 4, (u8 *)&le_tmp);
671 val = le32_to_cpu(le_tmp);
673 val = sd_read32(intfhdl, addr, NULL);
678 void SdioLocalCmd52Write1Byte(struct adapter *adapter, u32 addr, u8 v)
680 struct intf_hdl *intfhdl = &adapter->iopriv.intf;
682 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
683 sd_cmd52_write(intfhdl, addr, 1, &v);
686 static void SdioLocalCmd52Write4Byte(struct adapter *adapter, u32 addr, u32 v)
688 struct intf_hdl *intfhdl = &adapter->iopriv.intf;
691 HalSdioGetCmdAddr8723BSdio(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
692 le_tmp = cpu_to_le32(v);
693 sd_cmd52_write(intfhdl, addr, 4, (u8 *)&le_tmp);
696 static s32 ReadInterrupt8723BSdio(struct adapter *adapter, u32 *phisr)
704 himr = GET_HAL_DATA(adapter)->sdio_himr;
706 /* decide how many bytes need to be read */
714 while (hisr_len != 0) {
716 val8 = SdioLocalCmd52Read1Byte(adapter, SDIO_REG_HISR + hisr_len);
717 hisr |= (val8 << (8 * hisr_len));
727 /* Initialize SDIO Host Interrupt Mask configuration variables for future use. */
730 /* Using SDIO Local register ONLY for configuration. */
732 /* Created by Roger, 2011.02.11. */
734 void InitInterrupt8723BSdio(struct adapter *adapter)
736 struct hal_com_data *haldata;
738 haldata = GET_HAL_DATA(adapter);
739 haldata->sdio_himr = (u32)( \
740 SDIO_HIMR_RX_REQUEST_MSK |
747 /* Initialize System Host Interrupt Mask configuration variables for future use. */
749 /* Created by Roger, 2011.08.03. */
751 void InitSysInterrupt8723BSdio(struct adapter *adapter)
753 struct hal_com_data *haldata;
755 haldata = GET_HAL_DATA(adapter);
757 haldata->SysIntrMask = ( \
763 /* Enalbe SDIO Host Interrupt Mask configuration on SDIO local domain. */
766 /* 1. Using SDIO Local register ONLY for configuration. */
767 /* 2. PASSIVE LEVEL */
769 /* Created by Roger, 2011.02.11. */
771 void EnableInterrupt8723BSdio(struct adapter *adapter)
773 struct hal_com_data *haldata;
777 haldata = GET_HAL_DATA(adapter);
779 himr = cpu_to_le32(haldata->sdio_himr);
780 sdio_local_write(adapter, SDIO_REG_HIMR, 4, (u8 *)&himr);
786 "%s: enable SDIO HIMR = 0x%08X\n",
792 /* Update current system IMR settings */
793 tmp = rtw_read32(adapter, REG_HSIMR);
794 rtw_write32(adapter, REG_HSIMR, tmp | haldata->SysIntrMask);
800 "%s: enable HSIMR = 0x%08X\n",
807 /* <Roger_Notes> There are some C2H CMDs have been sent before system interrupt is enabled, e.g., C2H, CPWM. */
808 /* So we need to clear all C2H events that FW has notified, otherwise FW won't schedule any commands anymore. */
811 rtw_write8(adapter, REG_C2HEVT_CLEAR, C2H_EVT_HOST_CLOSE);
816 /* Disable SDIO Host IMR configuration to mask unnecessary interrupt service. */
819 /* Using SDIO Local register ONLY for configuration. */
821 /* Created by Roger, 2011.02.11. */
823 void DisableInterrupt8723BSdio(struct adapter *adapter)
827 himr = cpu_to_le32(SDIO_HIMR_DISABLED);
828 sdio_local_write(adapter, SDIO_REG_HIMR, 4, (u8 *)&himr);
833 /* Using 0x100 to check the power status of FW. */
836 /* Using SDIO Local register ONLY for configuration. */
838 /* Created by Isaac, 2013.09.10. */
840 u8 CheckIPSStatus(struct adapter *adapter)
843 "%s(): Read 0x100 = 0x%02x 0x86 = 0x%02x\n",
845 rtw_read8(adapter, 0x100),
846 rtw_read8(adapter, 0x86)
849 if (rtw_read8(adapter, 0x100) == 0xEA)
855 static struct recv_buf *sd_recv_rxfifo(struct adapter *adapter, u32 size)
859 struct recv_priv *recv_priv;
860 struct recv_buf *recvbuf;
862 /* Patch for some SDIO Host 4 bytes issue */
864 readsize = RND4(size);
866 /* 3 1. alloc recvbuf */
867 recv_priv = &adapter->recvpriv;
868 recvbuf = rtw_dequeue_recvbuf(&recv_priv->free_recv_buf_queue);
870 DBG_871X_LEVEL(_drv_err_, "%s: alloc recvbuf FAIL!\n", __func__);
875 if (!recvbuf->pskb) {
876 SIZE_PTR tmpaddr = 0;
877 SIZE_PTR alignment = 0;
879 recvbuf->pskb = rtw_skb_alloc(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
882 recvbuf->pskb->dev = adapter->pnetdev;
884 tmpaddr = (SIZE_PTR)recvbuf->pskb->data;
885 alignment = tmpaddr & (RECVBUFF_ALIGN_SZ - 1);
886 skb_reserve(recvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment));
889 if (!recvbuf->pskb) {
890 DBG_871X("%s: alloc_skb fail! read =%d\n", __func__, readsize);
895 /* 3 3. read data from rxfifo */
896 readbuf = recvbuf->pskb->data;
897 ret = sdio_read_port(&adapter->iopriv.intf, WLAN_RX0FF_DEVICE_ID, readsize, readbuf);
899 RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("%s: read port FAIL!\n", __func__));
903 /* 3 4. init recvbuf */
905 recvbuf->phead = recvbuf->pskb->head;
906 recvbuf->pdata = recvbuf->pskb->data;
907 skb_set_tail_pointer(recvbuf->pskb, size);
908 recvbuf->ptail = skb_tail_pointer(recvbuf->pskb);
909 recvbuf->pend = skb_end_pointer(recvbuf->pskb);
914 static void sd_rxhandler(struct adapter *adapter, struct recv_buf *recvbuf)
916 struct recv_priv *recv_priv;
917 struct __queue *pending_queue;
919 recv_priv = &adapter->recvpriv;
920 pending_queue = &recv_priv->recv_buf_pending_queue;
922 /* 3 1. enqueue recvbuf */
923 rtw_enqueue_recvbuf(recvbuf, pending_queue);
925 /* 3 2. schedule tasklet */
926 tasklet_schedule(&recv_priv->recv_tasklet);
929 void sd_int_dpc(struct adapter *adapter)
931 struct hal_com_data *hal;
932 struct dvobj_priv *dvobj;
933 struct intf_hdl *intfhdl = &adapter->iopriv.intf;
934 struct pwrctrl_priv *pwrctl;
936 hal = GET_HAL_DATA(adapter);
937 dvobj = adapter_to_dvobj(adapter);
938 pwrctl = dvobj_to_pwrctl(dvobj);
940 if (hal->sdio_hisr & SDIO_HISR_AVAL) {
943 _sdio_local_read(adapter, SDIO_REG_FREE_TXPG, 4, freepage);
944 complete(&(adapter->xmitpriv.xmit_comp));
947 if (hal->sdio_hisr & SDIO_HISR_CPWM1) {
948 struct reportpwrstate_parm report;
951 _cancel_timer(&(pwrctl->pwr_rpwm_timer), &bcancelled);
953 report.state = SdioLocalCmd52Read1Byte(adapter, SDIO_REG_HCPWM1_8723B);
955 _set_workitem(&(pwrctl->cpwm_event));
958 if (hal->sdio_hisr & SDIO_HISR_TXERR) {
962 status = rtw_malloc(4);
964 addr = REG_TXDMA_STATUS;
965 HalSdioGetCmdAddr8723BSdio(adapter, WLAN_IOREG_DEVICE_ID, addr, &addr);
966 _sd_read(intfhdl, addr, 4, status);
967 _sd_write(intfhdl, addr, 4, status);
968 DBG_8192C("%s: SDIO_HISR_TXERR (0x%08x)\n", __func__, le32_to_cpu(*(u32 *)status));
971 DBG_8192C("%s: SDIO_HISR_TXERR, but can't allocate memory to read status!\n", __func__);
975 if (hal->sdio_hisr & SDIO_HISR_TXBCNOK)
976 DBG_8192C("%s: SDIO_HISR_TXBCNOK\n", __func__);
978 if (hal->sdio_hisr & SDIO_HISR_TXBCNERR)
979 DBG_8192C("%s: SDIO_HISR_TXBCNERR\n", __func__);
980 #ifndef CONFIG_C2H_PACKET_EN
981 if (hal->sdio_hisr & SDIO_HISR_C2HCMD) {
982 struct c2h_evt_hdr_88xx *c2h_evt;
984 DBG_8192C("%s: C2H Command\n", __func__);
985 c2h_evt = rtw_zmalloc(16);
987 if (c2h_evt_read_88xx(adapter, (u8 *)c2h_evt) == _SUCCESS) {
988 if (c2h_id_filter_ccx_8723b((u8 *)c2h_evt)) {
989 /* Handle CCX report here */
990 rtw_hal_c2h_handler(adapter, (u8 *)c2h_evt);
991 kfree((u8 *)c2h_evt);
993 rtw_c2h_wk_cmd(adapter, (u8 *)c2h_evt);
997 /* Error handling for malloc fail */
998 if (rtw_cbuf_push(adapter->evtpriv.c2h_queue, NULL) != _SUCCESS)
999 DBG_871X("%s rtw_cbuf_push fail\n", __func__);
1000 _set_workitem(&adapter->evtpriv.c2h_wk);
1005 if (hal->sdio_hisr & SDIO_HISR_RXFOVW)
1006 DBG_8192C("%s: Rx Overflow\n", __func__);
1008 if (hal->sdio_hisr & SDIO_HISR_RXERR)
1009 DBG_8192C("%s: Rx Error\n", __func__);
1011 if (hal->sdio_hisr & SDIO_HISR_RX_REQUEST) {
1012 struct recv_buf *recvbuf;
1013 int alloc_fail_time = 0;
1016 hal->sdio_hisr ^= SDIO_HISR_RX_REQUEST;
1018 hal->SdioRxFIFOSize = SdioLocalCmd52Read2Byte(adapter, SDIO_REG_RX0_REQ_LEN);
1019 if (hal->SdioRxFIFOSize != 0) {
1020 recvbuf = sd_recv_rxfifo(adapter, hal->SdioRxFIFOSize);
1022 sd_rxhandler(adapter, recvbuf);
1025 DBG_871X("recvbuf is Null for %d times because alloc memory failed\n", alloc_fail_time);
1026 if (alloc_fail_time >= 10)
1029 hal->SdioRxFIFOSize = 0;
1034 ReadInterrupt8723BSdio(adapter, &hisr);
1035 hisr &= SDIO_HISR_RX_REQUEST;
1040 if (alloc_fail_time == 10)
1041 DBG_871X("exit because alloc memory failed more than 10 times\n");
1046 void sd_int_hdl(struct adapter *adapter)
1048 struct hal_com_data *hal;
1051 (adapter->bDriverStopped) || (adapter->bSurpriseRemoved)
1055 hal = GET_HAL_DATA(adapter);
1058 ReadInterrupt8723BSdio(adapter, &hal->sdio_hisr);
1060 if (hal->sdio_hisr & hal->sdio_himr) {
1063 hal->sdio_hisr &= hal->sdio_himr;
1066 v32 = hal->sdio_hisr & MASK_SDIO_HISR_CLEAR;
1068 SdioLocalCmd52Write4Byte(adapter, SDIO_REG_HISR, v32);
1070 sd_int_dpc(adapter);
1072 RT_TRACE(_module_hci_ops_c_, _drv_err_,
1073 ("%s: HISR(0x%08x) and HIMR(0x%08x) not match!\n",
1074 __func__, hal->sdio_hisr, hal->sdio_himr));
1080 /* Query SDIO Local register to query current the number of Free TxPacketBuffer page. */
1083 /* 1. Running at PASSIVE_LEVEL */
1084 /* 2. RT_TX_SPINLOCK is NOT acquired. */
1086 /* Created by Roger, 2011.01.28. */
1088 u8 HalQueryTxBufferStatus8723BSdio(struct adapter *adapter)
1090 struct hal_com_data *hal;
1091 u32 numof_free_page;
1093 hal = GET_HAL_DATA(adapter);
1095 numof_free_page = SdioLocalCmd53Read4Byte(adapter, SDIO_REG_FREE_TXPG);
1097 memcpy(hal->SdioTxFIFOFreePage, &numof_free_page, 4);
1098 RT_TRACE(_module_hci_ops_c_, _drv_notice_,
1099 ("%s: Free page for HIQ(%#x), MIDQ(%#x), LOWQ(%#x), PUBQ(%#x)\n",
1101 hal->SdioTxFIFOFreePage[HI_QUEUE_IDX],
1102 hal->SdioTxFIFOFreePage[MID_QUEUE_IDX],
1103 hal->SdioTxFIFOFreePage[LOW_QUEUE_IDX],
1104 hal->SdioTxFIFOFreePage[PUBLIC_QUEUE_IDX]));
1111 /* Query SDIO Local register to get the current number of TX OQT Free Space. */
1113 void HalQueryTxOQTBufferStatus8723BSdio(struct adapter *adapter)
1115 struct hal_com_data *haldata = GET_HAL_DATA(adapter);
1117 haldata->SdioTxOQTFreeSpace = SdioLocalCmd52Read1Byte(adapter, SDIO_REG_OQT_FREE_PG);
1120 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
1121 u8 RecvOnePkt(struct adapter *adapter, u32 size)
1123 struct recv_buf *recvbuf;
1124 struct dvobj_priv *sddev;
1125 struct sdio_func *func;
1129 DBG_871X("+%s: size: %d+\n", __func__, size);
1132 DBG_871X(KERN_ERR "%s: adapter is NULL!\n", __func__);
1136 sddev = adapter_to_dvobj(adapter);
1137 psdio_data = &sddev->intf_data;
1138 func = psdio_data->func;
1141 sdio_claim_host(func);
1142 recvbuf = sd_recv_rxfifo(adapter, size);
1145 sd_rxhandler(adapter, recvbuf);
1150 sdio_release_host(func);
1152 DBG_871X("-%s-\n", __func__);
1155 #endif /* CONFIG_WOWLAN */