1 /******************************************************************************
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
22 The purpose of rtw_io.c
26 b. provides the protocol engine
28 c. provides the software interface between caller and the hardware interface
34 a. USE_SYNC_IRP: Only sync operations are provided.
35 b. USE_ASYNC_IRP:Both sync/async operations are provided.
38 a. USE_ASYNC_IRP: Both sync/async operations are provided.
41 b. USE_SYNC_IRP: Only sync operations are provided.
44 Only sync read/rtw_write_mem operations are provided.
46 jackson@realtek.com.tw
52 #include <drv_types.h>
55 #if defined(PLATFORM_LINUX) && defined (PLATFORM_WINDOWS)
56 #error "Shall be Linux or Windows, but not both!\n"
59 #ifdef CONFIG_SDIO_HCI
60 #define rtw_le16_to_cpu(val) val
61 #define rtw_le32_to_cpu(val) val
62 #define rtw_cpu_to_le16(val) val
63 #define rtw_cpu_to_le32(val) val
65 #define rtw_le16_to_cpu(val) le16_to_cpu(val)
66 #define rtw_le32_to_cpu(val) le32_to_cpu(val)
67 #define rtw_cpu_to_le16(val) cpu_to_le16(val)
68 #define rtw_cpu_to_le32(val) cpu_to_le32(val)
72 u8 _rtw_read8(_adapter *adapter, u32 addr)
75 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
76 struct io_priv *pio_priv = &adapter->iopriv;
77 struct intf_hdl *pintfhdl = &(pio_priv->intf);
78 u8(*_read8)(struct intf_hdl *pintfhdl, u32 addr);
79 _read8 = pintfhdl->io_ops._read8;
81 r_val = _read8(pintfhdl, addr);
85 u16 _rtw_read16(_adapter *adapter, u32 addr)
88 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
89 struct io_priv *pio_priv = &adapter->iopriv;
90 struct intf_hdl *pintfhdl = &(pio_priv->intf);
91 u16(*_read16)(struct intf_hdl *pintfhdl, u32 addr);
92 _read16 = pintfhdl->io_ops._read16;
94 r_val = _read16(pintfhdl, addr);
95 return rtw_le16_to_cpu(r_val);
98 u32 _rtw_read32(_adapter *adapter, u32 addr)
101 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
102 struct io_priv *pio_priv = &adapter->iopriv;
103 struct intf_hdl *pintfhdl = &(pio_priv->intf);
104 u32(*_read32)(struct intf_hdl *pintfhdl, u32 addr);
105 _read32 = pintfhdl->io_ops._read32;
107 r_val = _read32(pintfhdl, addr);
108 return rtw_le32_to_cpu(r_val);
112 int _rtw_write8(_adapter *adapter, u32 addr, u8 val)
114 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
115 struct io_priv *pio_priv = &adapter->iopriv;
116 struct intf_hdl *pintfhdl = &(pio_priv->intf);
117 int (*_write8)(struct intf_hdl *pintfhdl, u32 addr, u8 val);
119 _write8 = pintfhdl->io_ops._write8;
121 ret = _write8(pintfhdl, addr, val);
123 return RTW_STATUS_CODE(ret);
125 int _rtw_write16(_adapter *adapter, u32 addr, u16 val)
127 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
128 struct io_priv *pio_priv = &adapter->iopriv;
129 struct intf_hdl *pintfhdl = &(pio_priv->intf);
130 int (*_write16)(struct intf_hdl *pintfhdl, u32 addr, u16 val);
132 _write16 = pintfhdl->io_ops._write16;
134 val = rtw_cpu_to_le16(val);
135 ret = _write16(pintfhdl, addr, val);
137 return RTW_STATUS_CODE(ret);
139 int _rtw_write32(_adapter *adapter, u32 addr, u32 val)
141 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
142 struct io_priv *pio_priv = &adapter->iopriv;
143 struct intf_hdl *pintfhdl = &(pio_priv->intf);
144 int (*_write32)(struct intf_hdl *pintfhdl, u32 addr, u32 val);
146 _write32 = pintfhdl->io_ops._write32;
148 val = rtw_cpu_to_le32(val);
149 ret = _write32(pintfhdl, addr, val);
151 return RTW_STATUS_CODE(ret);
154 int _rtw_writeN(_adapter *adapter, u32 addr , u32 length , u8 *pdata)
156 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
157 struct io_priv *pio_priv = &adapter->iopriv;
158 struct intf_hdl *pintfhdl = (struct intf_hdl *)(&(pio_priv->intf));
159 int (*_writeN)(struct intf_hdl *pintfhdl, u32 addr, u32 length, u8 *pdata);
161 _writeN = pintfhdl->io_ops._writeN;
163 ret = _writeN(pintfhdl, addr, length, pdata);
165 return RTW_STATUS_CODE(ret);
168 #ifdef CONFIG_SDIO_HCI
169 u8 _rtw_sd_f0_read8(_adapter *adapter, u32 addr)
172 struct io_priv *pio_priv = &adapter->iopriv;
173 struct intf_hdl *pintfhdl = &(pio_priv->intf);
174 u8(*_sd_f0_read8)(struct intf_hdl *pintfhdl, u32 addr);
176 _sd_f0_read8 = pintfhdl->io_ops._sd_f0_read8;
179 r_val = _sd_f0_read8(pintfhdl, addr);
181 RTW_WARN(FUNC_ADPT_FMT" _sd_f0_read8 callback is NULL\n", FUNC_ADPT_ARG(adapter));
186 #ifdef CONFIG_SDIO_INDIRECT_ACCESS
187 u8 _rtw_sd_iread8(_adapter *adapter, u32 addr)
190 struct io_priv *pio_priv = &adapter->iopriv;
191 struct intf_hdl *pintfhdl = &(pio_priv->intf);
192 u8(*_sd_iread8)(struct intf_hdl *pintfhdl, u32 addr);
194 _sd_iread8 = pintfhdl->io_ops._sd_iread8;
197 r_val = _sd_iread8(pintfhdl, addr);
199 RTW_ERR(FUNC_ADPT_FMT" _sd_iread8 callback is NULL\n", FUNC_ADPT_ARG(adapter));
204 u16 _rtw_sd_iread16(_adapter *adapter, u32 addr)
207 struct io_priv *pio_priv = &adapter->iopriv;
208 struct intf_hdl *pintfhdl = &(pio_priv->intf);
209 u16(*_sd_iread16)(struct intf_hdl *pintfhdl, u32 addr);
211 _sd_iread16 = pintfhdl->io_ops._sd_iread16;
214 r_val = _sd_iread16(pintfhdl, addr);
216 RTW_ERR(FUNC_ADPT_FMT" _sd_iread16 callback is NULL\n", FUNC_ADPT_ARG(adapter));
221 u32 _rtw_sd_iread32(_adapter *adapter, u32 addr)
224 struct io_priv *pio_priv = &adapter->iopriv;
225 struct intf_hdl *pintfhdl = &(pio_priv->intf);
226 u32(*_sd_iread32)(struct intf_hdl *pintfhdl, u32 addr);
228 _sd_iread32 = pintfhdl->io_ops._sd_iread32;
231 r_val = _sd_iread32(pintfhdl, addr);
233 RTW_ERR(FUNC_ADPT_FMT" _sd_iread32 callback is NULL\n", FUNC_ADPT_ARG(adapter));
238 int _rtw_sd_iwrite8(_adapter *adapter, u32 addr, u8 val)
240 struct io_priv *pio_priv = &adapter->iopriv;
241 struct intf_hdl *pintfhdl = &(pio_priv->intf);
242 int (*_sd_iwrite8)(struct intf_hdl *pintfhdl, u32 addr, u8 val);
245 _sd_iwrite8 = pintfhdl->io_ops._sd_iwrite8;
248 ret = _sd_iwrite8(pintfhdl, addr, val);
250 RTW_ERR(FUNC_ADPT_FMT" _sd_iwrite8 callback is NULL\n", FUNC_ADPT_ARG(adapter));
252 return RTW_STATUS_CODE(ret);
255 int _rtw_sd_iwrite16(_adapter *adapter, u32 addr, u16 val)
257 struct io_priv *pio_priv = &adapter->iopriv;
258 struct intf_hdl *pintfhdl = &(pio_priv->intf);
259 int (*_sd_iwrite16)(struct intf_hdl *pintfhdl, u32 addr, u16 val);
262 _sd_iwrite16 = pintfhdl->io_ops._sd_iwrite16;
265 ret = _sd_iwrite16(pintfhdl, addr, val);
267 RTW_ERR(FUNC_ADPT_FMT" _sd_iwrite16 callback is NULL\n", FUNC_ADPT_ARG(adapter));
269 return RTW_STATUS_CODE(ret);
271 int _rtw_sd_iwrite32(_adapter *adapter, u32 addr, u32 val)
273 struct io_priv *pio_priv = &adapter->iopriv;
274 struct intf_hdl *pintfhdl = &(pio_priv->intf);
275 int (*_sd_iwrite32)(struct intf_hdl *pintfhdl, u32 addr, u32 val);
278 _sd_iwrite32 = pintfhdl->io_ops._sd_iwrite32;
281 ret = _sd_iwrite32(pintfhdl, addr, val);
283 RTW_ERR(FUNC_ADPT_FMT" _sd_iwrite32 callback is NULL\n", FUNC_ADPT_ARG(adapter));
285 return RTW_STATUS_CODE(ret);
288 #endif /* CONFIG_SDIO_INDIRECT_ACCESS */
290 #endif /* CONFIG_SDIO_HCI */
292 int _rtw_write8_async(_adapter *adapter, u32 addr, u8 val)
294 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
295 struct io_priv *pio_priv = &adapter->iopriv;
296 struct intf_hdl *pintfhdl = &(pio_priv->intf);
297 int (*_write8_async)(struct intf_hdl *pintfhdl, u32 addr, u8 val);
299 _write8_async = pintfhdl->io_ops._write8_async;
301 ret = _write8_async(pintfhdl, addr, val);
303 return RTW_STATUS_CODE(ret);
305 int _rtw_write16_async(_adapter *adapter, u32 addr, u16 val)
307 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
308 struct io_priv *pio_priv = &adapter->iopriv;
309 struct intf_hdl *pintfhdl = &(pio_priv->intf);
310 int (*_write16_async)(struct intf_hdl *pintfhdl, u32 addr, u16 val);
312 _write16_async = pintfhdl->io_ops._write16_async;
313 val = rtw_cpu_to_le16(val);
314 ret = _write16_async(pintfhdl, addr, val);
316 return RTW_STATUS_CODE(ret);
318 int _rtw_write32_async(_adapter *adapter, u32 addr, u32 val)
320 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
321 struct io_priv *pio_priv = &adapter->iopriv;
322 struct intf_hdl *pintfhdl = &(pio_priv->intf);
323 int (*_write32_async)(struct intf_hdl *pintfhdl, u32 addr, u32 val);
325 _write32_async = pintfhdl->io_ops._write32_async;
326 val = rtw_cpu_to_le32(val);
327 ret = _write32_async(pintfhdl, addr, val);
329 return RTW_STATUS_CODE(ret);
332 void _rtw_read_mem(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
334 void (*_read_mem)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
335 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
336 struct io_priv *pio_priv = &adapter->iopriv;
337 struct intf_hdl *pintfhdl = &(pio_priv->intf);
340 if (RTW_CANNOT_RUN(adapter)) {
344 _read_mem = pintfhdl->io_ops._read_mem;
346 _read_mem(pintfhdl, addr, cnt, pmem);
351 void _rtw_write_mem(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
353 void (*_write_mem)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
354 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
355 struct io_priv *pio_priv = &adapter->iopriv;
356 struct intf_hdl *pintfhdl = &(pio_priv->intf);
359 _write_mem = pintfhdl->io_ops._write_mem;
361 _write_mem(pintfhdl, addr, cnt, pmem);
366 void _rtw_read_port(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
368 u32(*_read_port)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
369 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
370 struct io_priv *pio_priv = &adapter->iopriv;
371 struct intf_hdl *pintfhdl = &(pio_priv->intf);
374 if (RTW_CANNOT_RUN(adapter)) {
378 _read_port = pintfhdl->io_ops._read_port;
380 _read_port(pintfhdl, addr, cnt, pmem);
385 void _rtw_read_port_cancel(_adapter *adapter)
387 void (*_read_port_cancel)(struct intf_hdl *pintfhdl);
388 struct io_priv *pio_priv = &adapter->iopriv;
389 struct intf_hdl *pintfhdl = &(pio_priv->intf);
391 _read_port_cancel = pintfhdl->io_ops._read_port_cancel;
393 RTW_DISABLE_FUNC(adapter, DF_RX_BIT);
395 if (_read_port_cancel)
396 _read_port_cancel(pintfhdl);
399 u32 _rtw_write_port(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
401 u32(*_write_port)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
402 /* struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue; */
403 struct io_priv *pio_priv = &adapter->iopriv;
404 struct intf_hdl *pintfhdl = &(pio_priv->intf);
408 _write_port = pintfhdl->io_ops._write_port;
410 ret = _write_port(pintfhdl, addr, cnt, pmem);
416 u32 _rtw_write_port_and_wait(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem, int timeout_ms)
419 struct xmit_buf *pxmitbuf = (struct xmit_buf *)pmem;
420 struct submit_ctx sctx;
422 rtw_sctx_init(&sctx, timeout_ms);
423 pxmitbuf->sctx = &sctx;
425 ret = _rtw_write_port(adapter, addr, cnt, pmem);
428 ret = rtw_sctx_wait(&sctx, __func__);
433 void _rtw_write_port_cancel(_adapter *adapter)
435 void (*_write_port_cancel)(struct intf_hdl *pintfhdl);
436 struct io_priv *pio_priv = &adapter->iopriv;
437 struct intf_hdl *pintfhdl = &(pio_priv->intf);
439 _write_port_cancel = pintfhdl->io_ops._write_port_cancel;
441 RTW_DISABLE_FUNC(adapter, DF_TX_BIT);
443 if (_write_port_cancel)
444 _write_port_cancel(pintfhdl);
446 int rtw_init_io_priv(_adapter *padapter, void (*set_intf_ops)(_adapter *padapter, struct _io_ops *pops))
448 struct io_priv *piopriv = &padapter->iopriv;
449 struct intf_hdl *pintf = &piopriv->intf;
451 if (set_intf_ops == NULL)
454 piopriv->padapter = padapter;
455 pintf->padapter = padapter;
456 pintf->pintf_dev = adapter_to_dvobj(padapter);
458 set_intf_ops(padapter, &pintf->io_ops);
464 * Increase and check if the continual_io_error of this @param dvobjprive is larger than MAX_CONTINUAL_IO_ERR
468 int rtw_inc_and_chk_continual_io_error(struct dvobj_priv *dvobj)
473 value = ATOMIC_INC_RETURN(&dvobj->continual_io_error);
474 if (value > MAX_CONTINUAL_IO_ERR) {
475 RTW_INFO("[dvobj:%p][ERROR] continual_io_error:%d > %d\n", dvobj, value, MAX_CONTINUAL_IO_ERR);
478 /* RTW_INFO("[dvobj:%p] continual_io_error:%d\n", dvobj, value); */
484 * Set the continual_io_error of this @param dvobjprive to 0
486 void rtw_reset_continual_io_error(struct dvobj_priv *dvobj)
488 ATOMIC_SET(&dvobj->continual_io_error, 0);
493 u32 read_sniff_ranges[][2] = {
494 /* {0x520, 0x523}, */
497 u32 write_sniff_ranges[][2] = {
498 /* {0x520, 0x523}, */
502 int read_sniff_num = sizeof(read_sniff_ranges) / sizeof(u32) / 2;
503 int write_sniff_num = sizeof(write_sniff_ranges) / sizeof(u32) / 2;
505 bool match_read_sniff_ranges(u32 addr, u16 len)
508 for (i = 0; i < read_sniff_num; i++) {
509 if (addr + len > read_sniff_ranges[i][0] && addr <= read_sniff_ranges[i][1])
516 bool match_write_sniff_ranges(u32 addr, u16 len)
519 for (i = 0; i < write_sniff_num; i++) {
520 if (addr + len > write_sniff_ranges[i][0] && addr <= write_sniff_ranges[i][1])
527 struct rf_sniff_ent {
533 struct rf_sniff_ent rf_read_sniff_ranges[] = {
534 /* example for all path addr 0x55 with all RF Reg mask */
535 /* {MAX_RF_PATH, 0x55, bRFRegOffsetMask}, */
538 struct rf_sniff_ent rf_write_sniff_ranges[] = {
539 /* example for all path addr 0x55 with all RF Reg mask */
540 /* {MAX_RF_PATH, 0x55, bRFRegOffsetMask}, */
543 int rf_read_sniff_num = sizeof(rf_read_sniff_ranges) / sizeof(struct rf_sniff_ent);
544 int rf_write_sniff_num = sizeof(rf_write_sniff_ranges) / sizeof(struct rf_sniff_ent);
546 bool match_rf_read_sniff_ranges(u8 path, u32 addr, u32 mask)
550 for (i = 0; i < rf_read_sniff_num; i++) {
551 if (rf_read_sniff_ranges[i].path == MAX_RF_PATH || rf_read_sniff_ranges[i].path == path)
552 if (addr == rf_read_sniff_ranges[i].reg && (mask & rf_read_sniff_ranges[i].mask))
559 bool match_rf_write_sniff_ranges(u8 path, u32 addr, u32 mask)
563 for (i = 0; i < rf_write_sniff_num; i++) {
564 if (rf_write_sniff_ranges[i].path == MAX_RF_PATH || rf_write_sniff_ranges[i].path == path)
565 if (addr == rf_write_sniff_ranges[i].reg && (mask & rf_write_sniff_ranges[i].mask))
572 u8 dbg_rtw_read8(_adapter *adapter, u32 addr, const char *caller, const int line)
574 u8 val = _rtw_read8(adapter, addr);
576 if (match_read_sniff_ranges(addr, 1))
577 RTW_INFO("DBG_IO %s:%d rtw_read8(0x%04x) return 0x%02x\n", caller, line, addr, val);
582 u16 dbg_rtw_read16(_adapter *adapter, u32 addr, const char *caller, const int line)
584 u16 val = _rtw_read16(adapter, addr);
586 if (match_read_sniff_ranges(addr, 2))
587 RTW_INFO("DBG_IO %s:%d rtw_read16(0x%04x) return 0x%04x\n", caller, line, addr, val);
592 u32 dbg_rtw_read32(_adapter *adapter, u32 addr, const char *caller, const int line)
594 u32 val = _rtw_read32(adapter, addr);
596 if (match_read_sniff_ranges(addr, 4))
597 RTW_INFO("DBG_IO %s:%d rtw_read32(0x%04x) return 0x%08x\n", caller, line, addr, val);
602 int dbg_rtw_write8(_adapter *adapter, u32 addr, u8 val, const char *caller, const int line)
604 if (match_write_sniff_ranges(addr, 1))
605 RTW_INFO("DBG_IO %s:%d rtw_write8(0x%04x, 0x%02x)\n", caller, line, addr, val);
607 return _rtw_write8(adapter, addr, val);
609 int dbg_rtw_write16(_adapter *adapter, u32 addr, u16 val, const char *caller, const int line)
611 if (match_write_sniff_ranges(addr, 2))
612 RTW_INFO("DBG_IO %s:%d rtw_write16(0x%04x, 0x%04x)\n", caller, line, addr, val);
614 return _rtw_write16(adapter, addr, val);
616 int dbg_rtw_write32(_adapter *adapter, u32 addr, u32 val, const char *caller, const int line)
618 if (match_write_sniff_ranges(addr, 4))
619 RTW_INFO("DBG_IO %s:%d rtw_write32(0x%04x, 0x%08x)\n", caller, line, addr, val);
621 return _rtw_write32(adapter, addr, val);
623 int dbg_rtw_writeN(_adapter *adapter, u32 addr , u32 length , u8 *data, const char *caller, const int line)
625 if (match_write_sniff_ranges(addr, length))
626 RTW_INFO("DBG_IO %s:%d rtw_writeN(0x%04x, %u)\n", caller, line, addr, length);
628 return _rtw_writeN(adapter, addr, length, data);
631 #ifdef CONFIG_SDIO_HCI
632 u8 dbg_rtw_sd_f0_read8(_adapter *adapter, u32 addr, const char *caller, const int line)
634 u8 val = _rtw_sd_f0_read8(adapter, addr);
637 if (match_read_sniff_ranges(addr, 1))
638 RTW_INFO("DBG_IO %s:%d rtw_sd_f0_read8(0x%04x) return 0x%02x\n", caller, line, addr, val);
644 #ifdef CONFIG_SDIO_INDIRECT_ACCESS
645 u8 dbg_rtw_sd_iread8(_adapter *adapter, u32 addr, const char *caller, const int line)
647 u8 val = rtw_sd_iread8(adapter, addr);
649 if (match_read_sniff_ranges(addr, 1))
650 RTW_INFO("DBG_IO %s:%d rtw_sd_iread8(0x%04x) return 0x%02x\n", caller, line, addr, val);
655 u16 dbg_rtw_sd_iread16(_adapter *adapter, u32 addr, const char *caller, const int line)
657 u16 val = _rtw_sd_iread16(adapter, addr);
659 if (match_read_sniff_ranges(addr, 2))
660 RTW_INFO("DBG_IO %s:%d rtw_sd_iread16(0x%04x) return 0x%04x\n", caller, line, addr, val);
665 u32 dbg_rtw_sd_iread32(_adapter *adapter, u32 addr, const char *caller, const int line)
667 u32 val = _rtw_sd_iread32(adapter, addr);
669 if (match_read_sniff_ranges(addr, 4))
670 RTW_INFO("DBG_IO %s:%d rtw_sd_iread32(0x%04x) return 0x%08x\n", caller, line, addr, val);
675 int dbg_rtw_sd_iwrite8(_adapter *adapter, u32 addr, u8 val, const char *caller, const int line)
677 if (match_write_sniff_ranges(addr, 1))
678 RTW_INFO("DBG_IO %s:%d rtw_sd_iwrite8(0x%04x, 0x%02x)\n", caller, line, addr, val);
680 return _rtw_sd_iwrite8(adapter, addr, val);
682 int dbg_rtw_sd_iwrite16(_adapter *adapter, u32 addr, u16 val, const char *caller, const int line)
684 if (match_write_sniff_ranges(addr, 2))
685 RTW_INFO("DBG_IO %s:%d rtw_sd_iwrite16(0x%04x, 0x%04x)\n", caller, line, addr, val);
687 return _rtw_sd_iwrite16(adapter, addr, val);
689 int dbg_rtw_sd_iwrite32(_adapter *adapter, u32 addr, u32 val, const char *caller, const int line)
691 if (match_write_sniff_ranges(addr, 4))
692 RTW_INFO("DBG_IO %s:%d rtw_sd_iwrite32(0x%04x, 0x%08x)\n", caller, line, addr, val);
694 return _rtw_sd_iwrite32(adapter, addr, val);
697 #endif /* CONFIG_SDIO_INDIRECT_ACCESS */
699 #endif /* CONFIG_SDIO_HCI */