rtl8723bu/core/rtw_io.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   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.
   8  *
   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
  12  * more details.
  13  *
  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
  17  *
  18  *
  19  ******************************************************************************/
  20 /*
  21
  22 The purpose of rtw_io.c
  23
  24 a. provides the API
  25
  26 b. provides the protocol engine
  27
  28 c. provides the software interface between caller and the hardware interface
  29
  30
  31 Compiler Flag Option:
  32
  33 1. CONFIG_SDIO_HCI:
  34     a. USE_SYNC_IRP:  Only sync operations are provided.
  35     b. USE_ASYNC_IRP:Both sync/async operations are provided.
  36
  37 2. CONFIG_USB_HCI:
  38    a. USE_ASYNC_IRP: Both sync/async operations are provided.
  39
  40 3. CONFIG_CFIO_HCI:
  41    b. USE_SYNC_IRP: Only sync operations are provided.
  42
  43
  44 Only sync read/rtw_write_mem operations are provided.
  45
  46 jackson@realtek.com.tw
  47
  48 */
  49
  50 #define _RTW_IO_C_
  51
  52 #include <drv_types.h>
  53 #include <hal_data.h>
  54
  55 #if defined (PLATFORM_LINUX) && defined (PLATFORM_WINDOWS)
  56 #error "Shall be Linux or Windows, but not both!\n"
  57 #endif
  58
  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
  64 #else
  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)
  69 #endif
  70
  71
  72 u8 _rtw_read8(_adapter *adapter, u32 addr)
  73 {
  74         u8 r_val;
  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         _func_enter_;
  80         _read8 = pintfhdl->io_ops._read8;
  81
  82         r_val = _read8(pintfhdl, addr);
  83         _func_exit_;
  84         return r_val;
  85 }
  86
  87 u16 _rtw_read16(_adapter *adapter, u32 addr)
  88 {
  89         u16 r_val;
  90         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
  91         struct io_priv *pio_priv = &adapter->iopriv;
  92         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
  93         u16     (*_read16)(struct intf_hdl *pintfhdl, u32 addr);
  94         _func_enter_;
  95         _read16 = pintfhdl->io_ops._read16;
  96
  97         r_val = _read16(pintfhdl, addr);
  98         _func_exit_;
  99         return rtw_le16_to_cpu(r_val);
 100 }
 101
 102 u32 _rtw_read32(_adapter *adapter, u32 addr)
 103 {
 104         u32 r_val;
 105         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 106         struct io_priv *pio_priv = &adapter->iopriv;
 107         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 108         u32     (*_read32)(struct intf_hdl *pintfhdl, u32 addr);
 109         _func_enter_;
 110         _read32 = pintfhdl->io_ops._read32;
 111
 112         r_val = _read32(pintfhdl, addr);
 113         _func_exit_;
 114         return rtw_le32_to_cpu(r_val);
 115
 116 }
 117
 118 int _rtw_write8(_adapter *adapter, u32 addr, u8 val)
 119 {
 120         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 121         struct io_priv *pio_priv = &adapter->iopriv;
 122         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 123         int (*_write8)(struct intf_hdl *pintfhdl, u32 addr, u8 val);
 124         int ret;
 125         _func_enter_;
 126         _write8 = pintfhdl->io_ops._write8;
 127
 128         ret = _write8(pintfhdl, addr, val);
 129         _func_exit_;
 130
 131         return RTW_STATUS_CODE(ret);
 132 }
 133 int _rtw_write16(_adapter *adapter, u32 addr, u16 val)
 134 {
 135         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 136         struct io_priv *pio_priv = &adapter->iopriv;
 137         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 138         int (*_write16)(struct intf_hdl *pintfhdl, u32 addr, u16 val);
 139         int ret;
 140         _func_enter_;
 141         _write16 = pintfhdl->io_ops._write16;
 142
 143         val = rtw_cpu_to_le16(val);
 144         ret = _write16(pintfhdl, addr, val);
 145         _func_exit_;
 146
 147         return RTW_STATUS_CODE(ret);
 148 }
 149 int _rtw_write32(_adapter *adapter, u32 addr, u32 val)
 150 {
 151         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 152         struct io_priv *pio_priv = &adapter->iopriv;
 153         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 154         int (*_write32)(struct intf_hdl *pintfhdl, u32 addr, u32 val);
 155         int ret;
 156         _func_enter_;
 157         _write32 = pintfhdl->io_ops._write32;
 158
 159         val = rtw_cpu_to_le32(val);
 160         ret = _write32(pintfhdl, addr, val);
 161         _func_exit_;
 162
 163         return RTW_STATUS_CODE(ret);
 164 }
 165
 166 int _rtw_writeN(_adapter *adapter, u32 addr ,u32 length , u8 *pdata)
 167 {
 168         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 169         struct io_priv *pio_priv = &adapter->iopriv;
 170         struct  intf_hdl        *pintfhdl = (struct intf_hdl*)(&(pio_priv->intf));
 171         int (*_writeN)(struct intf_hdl *pintfhdl, u32 addr,u32 length, u8 *pdata);
 172         int ret;
 173         _func_enter_;
 174         _writeN = pintfhdl->io_ops._writeN;
 175
 176         ret = _writeN(pintfhdl, addr,length,pdata);
 177         _func_exit_;
 178
 179         return RTW_STATUS_CODE(ret);
 180 }
 181
 182 #ifdef CONFIG_SDIO_HCI
 183 u8 _rtw_sd_f0_read8(_adapter *adapter, u32 addr)
 184 {
 185         u8 r_val = 0x00;
 186         struct io_priv *pio_priv = &adapter->iopriv;
 187         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 188         u8 (*_sd_f0_read8)(struct intf_hdl *pintfhdl, u32 addr);
 189
 190         _func_enter_;
 191         _sd_f0_read8 = pintfhdl->io_ops._sd_f0_read8;
 192
 193         if (_sd_f0_read8)
 194                 r_val = _sd_f0_read8(pintfhdl, addr);
 195         else
 196                 DBG_871X_LEVEL(_drv_warning_, FUNC_ADPT_FMT" _sd_f0_read8 callback is NULL\n", FUNC_ADPT_ARG(adapter));
 197
 198         _func_exit_;
 199         return r_val;
 200 }
 201
 202 #ifdef CONFIG_SDIO_INDIRECT_ACCESS
 203 u8 _rtw_sd_iread8(_adapter *adapter, u32 addr)
 204 {
 205         u8 r_val = 0x00;
 206         struct io_priv *pio_priv = &adapter->iopriv;
 207         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 208         u8 (*_sd_iread8)(struct intf_hdl *pintfhdl, u32 addr);
 209
 210         _sd_iread8 = pintfhdl->io_ops._sd_iread8;
 211
 212         if (_sd_iread8)
 213                 r_val = _sd_iread8(pintfhdl, addr);
 214         else
 215                 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT" _sd_iread8 callback is NULL\n", FUNC_ADPT_ARG(adapter));
 216
 217         return r_val;
 218 }
 219
 220 u16 _rtw_sd_iread16(_adapter *adapter, u32 addr)
 221 {
 222         u16 r_val = 0x00;
 223         struct io_priv *pio_priv = &adapter->iopriv;
 224         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 225         u16 (*_sd_iread16)(struct intf_hdl *pintfhdl, u32 addr);
 226
 227         _sd_iread16 = pintfhdl->io_ops._sd_iread16;
 228
 229         if (_sd_iread16)
 230                 r_val = _sd_iread16(pintfhdl, addr);
 231         else
 232                 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT" _sd_iread16 callback is NULL\n", FUNC_ADPT_ARG(adapter));
 233
 234         return r_val;
 235 }
 236
 237 u32 _rtw_sd_iread32(_adapter *adapter, u32 addr)
 238 {
 239         u32 r_val = 0x00;
 240         struct io_priv *pio_priv = &adapter->iopriv;
 241         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 242         u32 (*_sd_iread32)(struct intf_hdl *pintfhdl, u32 addr);
 243
 244         _sd_iread32 = pintfhdl->io_ops._sd_iread32;
 245
 246         if (_sd_iread32)
 247                 r_val = _sd_iread32(pintfhdl, addr);
 248         else
 249                 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT" _sd_iread32 callback is NULL\n", FUNC_ADPT_ARG(adapter));
 250
 251         return r_val;
 252 }
 253
 254 int _rtw_sd_iwrite8(_adapter *adapter, u32 addr, u8 val)
 255 {
 256         struct io_priv *pio_priv = &adapter->iopriv;
 257         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 258         int (*_sd_iwrite8)(struct intf_hdl *pintfhdl, u32 addr, u8 val);
 259         int ret = -1;
 260
 261         _sd_iwrite8 = pintfhdl->io_ops._sd_iwrite8;
 262
 263         if (_sd_iwrite8)
 264                 ret = _sd_iwrite8(pintfhdl, addr, val);
 265         else
 266                 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT" _sd_iwrite8 callback is NULL\n", FUNC_ADPT_ARG(adapter));
 267
 268         return RTW_STATUS_CODE(ret);
 269 }
 270
 271 int _rtw_sd_iwrite16(_adapter *adapter, u32 addr, u16 val)
 272 {
 273         struct io_priv *pio_priv = &adapter->iopriv;
 274         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 275         int (*_sd_iwrite16)(struct intf_hdl *pintfhdl, u32 addr, u16 val);
 276         int ret = -1;
 277
 278         _sd_iwrite16 = pintfhdl->io_ops._sd_iwrite16;
 279
 280         if (_sd_iwrite16)
 281                 ret = _sd_iwrite16(pintfhdl, addr, val);
 282         else
 283                 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT" _sd_iwrite16 callback is NULL\n", FUNC_ADPT_ARG(adapter));
 284
 285         return RTW_STATUS_CODE(ret);
 286 }
 287 int _rtw_sd_iwrite32(_adapter *adapter, u32 addr, u32 val)
 288 {
 289         struct io_priv *pio_priv = &adapter->iopriv;
 290         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 291         int (*_sd_iwrite32)(struct intf_hdl *pintfhdl, u32 addr, u32 val);
 292         int ret = -1;
 293
 294         _sd_iwrite32 = pintfhdl->io_ops._sd_iwrite32;
 295
 296         if (_sd_iwrite32)
 297                 ret = _sd_iwrite32(pintfhdl, addr, val);
 298         else
 299                 DBG_871X_LEVEL(_drv_err_, FUNC_ADPT_FMT" _sd_iwrite32 callback is NULL\n", FUNC_ADPT_ARG(adapter));
 300
 301         return RTW_STATUS_CODE(ret);
 302 }
 303
 304 #endif /* CONFIG_SDIO_INDIRECT_ACCESS */
 305
 306 #endif /* CONFIG_SDIO_HCI */
 307
 308 int _rtw_write8_async(_adapter *adapter, u32 addr, u8 val)
 309 {
 310         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 311         struct io_priv *pio_priv = &adapter->iopriv;
 312         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 313         int (*_write8_async)(struct intf_hdl *pintfhdl, u32 addr, u8 val);
 314         int ret;
 315         _func_enter_;
 316         _write8_async = pintfhdl->io_ops._write8_async;
 317
 318         ret = _write8_async(pintfhdl, addr, val);
 319         _func_exit_;
 320
 321         return RTW_STATUS_CODE(ret);
 322 }
 323 int _rtw_write16_async(_adapter *adapter, u32 addr, u16 val)
 324 {
 325         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 326         struct io_priv *pio_priv = &adapter->iopriv;
 327         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 328         int (*_write16_async)(struct intf_hdl *pintfhdl, u32 addr, u16 val);
 329         int ret;
 330         _func_enter_;
 331         _write16_async = pintfhdl->io_ops._write16_async;
 332         val = rtw_cpu_to_le16(val);
 333         ret = _write16_async(pintfhdl, addr, val);
 334         _func_exit_;
 335
 336         return RTW_STATUS_CODE(ret);
 337 }
 338 int _rtw_write32_async(_adapter *adapter, u32 addr, u32 val)
 339 {
 340         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 341         struct io_priv *pio_priv = &adapter->iopriv;
 342         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 343         int (*_write32_async)(struct intf_hdl *pintfhdl, u32 addr, u32 val);
 344         int ret;
 345         _func_enter_;
 346         _write32_async = pintfhdl->io_ops._write32_async;
 347         val = rtw_cpu_to_le32(val);
 348         ret = _write32_async(pintfhdl, addr, val);
 349         _func_exit_;
 350
 351         return RTW_STATUS_CODE(ret);
 352 }
 353
 354 void _rtw_read_mem(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
 355 {
 356         void (*_read_mem)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
 357         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 358         struct io_priv *pio_priv = &adapter->iopriv;
 359         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 360
 361         _func_enter_;
 362
 363         if (RTW_CANNOT_RUN(adapter)) {
 364                 RT_TRACE(_module_rtl871x_io_c_, _drv_info_, ("rtw_read_mem:bDriverStopped(%s) OR bSurpriseRemoved(%s)"
 365                         , rtw_is_drv_stopped(adapter)?"True":"False"
 366                         , rtw_is_surprise_removed(adapter)?"True":"False"));
 367                 return;
 368         }
 369
 370         _read_mem = pintfhdl->io_ops._read_mem;
 371
 372         _read_mem(pintfhdl, addr, cnt, pmem);
 373
 374         _func_exit_;
 375
 376 }
 377
 378 void _rtw_write_mem(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
 379 {
 380         void (*_write_mem)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
 381         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 382         struct io_priv *pio_priv = &adapter->iopriv;
 383         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 384
 385         _func_enter_;
 386
 387         _write_mem = pintfhdl->io_ops._write_mem;
 388
 389         _write_mem(pintfhdl, addr, cnt, pmem);
 390
 391         _func_exit_;
 392
 393 }
 394
 395 void _rtw_read_port(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
 396 {
 397         u32 (*_read_port)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
 398         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 399         struct io_priv *pio_priv = &adapter->iopriv;
 400         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 401
 402         _func_enter_;
 403
 404         if (RTW_CANNOT_RUN(adapter)) {
 405                 RT_TRACE(_module_rtl871x_io_c_, _drv_info_, ("rtw_read_port:bDriverStopped(%s) OR bSurpriseRemoved(%s)"
 406                         , rtw_is_drv_stopped(adapter)?"True":"False"
 407                         , rtw_is_surprise_removed(adapter)?"True":"False"));
 408              return;
 409         }
 410
 411         _read_port = pintfhdl->io_ops._read_port;
 412
 413         _read_port(pintfhdl, addr, cnt, pmem);
 414
 415         _func_exit_;
 416
 417 }
 418
 419 void _rtw_read_port_cancel(_adapter *adapter)
 420 {
 421         void (*_read_port_cancel)(struct intf_hdl *pintfhdl);
 422         struct io_priv *pio_priv = &adapter->iopriv;
 423         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 424
 425         _read_port_cancel = pintfhdl->io_ops._read_port_cancel;
 426
 427         RTW_DISABLE_FUNC(adapter, DF_RX_BIT);
 428
 429         if(_read_port_cancel)
 430                 _read_port_cancel(pintfhdl);
 431 }
 432
 433 u32 _rtw_write_port(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem)
 434 {
 435         u32 (*_write_port)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
 436         //struct        io_queue        *pio_queue = (struct io_queue *)adapter->pio_queue;
 437         struct io_priv *pio_priv = &adapter->iopriv;
 438         struct  intf_hdl                *pintfhdl = &(pio_priv->intf);
 439         u32 ret = _SUCCESS;
 440
 441         _func_enter_;
 442
 443         _write_port = pintfhdl->io_ops._write_port;
 444
 445         ret = _write_port(pintfhdl, addr, cnt, pmem);
 446
 447          _func_exit_;
 448
 449         return ret;
 450 }
 451
 452 u32 _rtw_write_port_and_wait(_adapter *adapter, u32 addr, u32 cnt, u8 *pmem, int timeout_ms)
 453 {
 454         int ret = _SUCCESS;
 455         struct xmit_buf *pxmitbuf = (struct xmit_buf *)pmem;
 456         struct submit_ctx sctx;
 457
 458         rtw_sctx_init(&sctx, timeout_ms);
 459         pxmitbuf->sctx = &sctx;
 460
 461         ret = _rtw_write_port(adapter, addr, cnt, pmem);
 462
 463         if (ret == _SUCCESS)
 464                 ret = rtw_sctx_wait(&sctx, __func__);
 465
 466          return ret;
 467 }
 468
 469 void _rtw_write_port_cancel(_adapter *adapter)
 470 {
 471         void (*_write_port_cancel)(struct intf_hdl *pintfhdl);
 472         struct io_priv *pio_priv = &adapter->iopriv;
 473         struct intf_hdl *pintfhdl = &(pio_priv->intf);
 474
 475         _write_port_cancel = pintfhdl->io_ops._write_port_cancel;
 476
 477         RTW_DISABLE_FUNC(adapter, DF_TX_BIT);
 478
 479         if(_write_port_cancel)
 480                 _write_port_cancel(pintfhdl);
 481 }
 482 int rtw_init_io_priv(_adapter *padapter, void (*set_intf_ops)(_adapter *padapter,struct _io_ops *pops))
 483 {
 484         struct io_priv  *piopriv = &padapter->iopriv;
 485         struct intf_hdl *pintf = &piopriv->intf;
 486
 487         if (set_intf_ops == NULL)
 488                 return _FAIL;
 489
 490         piopriv->padapter = padapter;
 491         pintf->padapter = padapter;
 492         pintf->pintf_dev = adapter_to_dvobj(padapter);
 493
 494         set_intf_ops(padapter,&pintf->io_ops);
 495
 496         return _SUCCESS;
 497 }
 498
 499 /*
 500 * Increase and check if the continual_io_error of this @param dvobjprive is larger than MAX_CONTINUAL_IO_ERR
 501 * @return _TRUE:
 502 * @return _FALSE:
 503 */
 504 int rtw_inc_and_chk_continual_io_error(struct dvobj_priv *dvobj)
 505 {
 506         int ret = _FALSE;
 507         int value;
 508         if( (value=ATOMIC_INC_RETURN(&dvobj->continual_io_error)) > MAX_CONTINUAL_IO_ERR) {
 509                 DBG_871X("[dvobj:%p][ERROR] continual_io_error:%d > %d\n", dvobj, value, MAX_CONTINUAL_IO_ERR);
 510                 ret = _TRUE;
 511         } else {
 512                 //DBG_871X("[dvobj:%p] continual_io_error:%d\n", dvobj, value);
 513         }
 514         return ret;
 515 }
 516
 517 /*
 518 * Set the continual_io_error of this @param dvobjprive to 0
 519 */
 520 void rtw_reset_continual_io_error(struct dvobj_priv *dvobj)
 521 {
 522         ATOMIC_SET(&dvobj->continual_io_error, 0);
 523 }
 524
 525 #ifdef DBG_IO
 526
 527 u32 read_sniff_ranges[][2] = {
 528         //{0x520, 0x523},
 529 };
 530
 531 u32 write_sniff_ranges[][2] = {
 532         //{0x520, 0x523},
 533         //{0x4c, 0x4c},
 534 };
 535
 536 int read_sniff_num = sizeof(read_sniff_ranges)/sizeof(u32)/2;
 537 int write_sniff_num = sizeof(write_sniff_ranges)/sizeof(u32)/2;
 538
 539 bool match_read_sniff_ranges(u32 addr, u16 len)
 540 {
 541         int i;
 542         for (i = 0; i<read_sniff_num; i++) {
 543                 if (addr + len > read_sniff_ranges[i][0] && addr <= read_sniff_ranges[i][1])
 544                         return _TRUE;
 545         }
 546
 547         return _FALSE;
 548 }
 549
 550 bool match_write_sniff_ranges(u32 addr, u16 len)
 551 {
 552         int i;
 553         for (i = 0; i<write_sniff_num; i++) {
 554                 if (addr + len > write_sniff_ranges[i][0] && addr <= write_sniff_ranges[i][1])
 555                         return _TRUE;
 556         }
 557
 558         return _FALSE;
 559 }
 560
 561 struct rf_sniff_ent {
 562         u8 path;
 563         u16 reg;
 564         u32 mask;
 565 };
 566
 567 struct rf_sniff_ent rf_read_sniff_ranges[] = {
 568         /* example for all path addr 0x55 with all RF Reg mask */
 569         /* {MAX_RF_PATH, 0x55, bRFRegOffsetMask}, */
 570 };
 571
 572 struct rf_sniff_ent rf_write_sniff_ranges[] = {
 573         /* example for all path addr 0x55 with all RF Reg mask */
 574         /* {MAX_RF_PATH, 0x55, bRFRegOffsetMask}, */
 575 };
 576
 577 int rf_read_sniff_num = sizeof(rf_read_sniff_ranges)/sizeof(struct rf_sniff_ent);
 578 int rf_write_sniff_num = sizeof(rf_write_sniff_ranges)/sizeof(struct rf_sniff_ent);
 579
 580 bool match_rf_read_sniff_ranges(u8 path, u32 addr, u32 mask)
 581 {
 582         int i;
 583
 584         for (i = 0; i < rf_read_sniff_num; i++) {
 585                 if (rf_read_sniff_ranges[i].path == MAX_RF_PATH || rf_read_sniff_ranges[i].path == path)
 586                         if (addr == rf_read_sniff_ranges[i].reg && (mask & rf_read_sniff_ranges[i].mask))
 587                                 return _TRUE;
 588         }
 589
 590         return _FALSE;
 591 }
 592
 593 bool match_rf_write_sniff_ranges(u8 path, u32 addr, u32 mask)
 594 {
 595         int i;
 596
 597         for (i = 0; i < rf_write_sniff_num; i++) {
 598                 if (rf_write_sniff_ranges[i].path == MAX_RF_PATH || rf_write_sniff_ranges[i].path == path)
 599                         if (addr == rf_write_sniff_ranges[i].reg && (mask & rf_write_sniff_ranges[i].mask))
 600                                 return _TRUE;
 601         }
 602
 603         return _FALSE;
 604 }
 605
 606 u8 dbg_rtw_read8(_adapter *adapter, u32 addr, const char *caller, const int line)
 607 {
 608         u8 val = _rtw_read8(adapter, addr);
 609
 610         if (match_read_sniff_ranges(addr, 1))
 611                 DBG_871X("DBG_IO %s:%d rtw_read8(0x%04x) return 0x%02x\n", caller, line, addr, val);
 612
 613         return val;
 614 }
 615
 616 u16 dbg_rtw_read16(_adapter *adapter, u32 addr, const char *caller, const int line)
 617 {
 618         u16 val = _rtw_read16(adapter, addr);
 619
 620         if (match_read_sniff_ranges(addr, 2))
 621                 DBG_871X("DBG_IO %s:%d rtw_read16(0x%04x) return 0x%04x\n", caller, line, addr, val);
 622
 623         return val;
 624 }
 625
 626 u32 dbg_rtw_read32(_adapter *adapter, u32 addr, const char *caller, const int line)
 627 {
 628         u32 val = _rtw_read32(adapter, addr);
 629
 630         if (match_read_sniff_ranges(addr, 4))
 631                 DBG_871X("DBG_IO %s:%d rtw_read32(0x%04x) return 0x%08x\n", caller, line, addr, val);
 632
 633         return val;
 634 }
 635
 636 int dbg_rtw_write8(_adapter *adapter, u32 addr, u8 val, const char *caller, const int line)
 637 {
 638         if (match_write_sniff_ranges(addr, 1))
 639                 DBG_871X("DBG_IO %s:%d rtw_write8(0x%04x, 0x%02x)\n", caller, line, addr, val);
 640
 641         return _rtw_write8(adapter, addr, val);
 642 }
 643 int dbg_rtw_write16(_adapter *adapter, u32 addr, u16 val, const char *caller, const int line)
 644 {
 645         if (match_write_sniff_ranges(addr, 2))
 646                 DBG_871X("DBG_IO %s:%d rtw_write16(0x%04x, 0x%04x)\n", caller, line, addr, val);
 647
 648         return _rtw_write16(adapter, addr, val);
 649 }
 650 int dbg_rtw_write32(_adapter *adapter, u32 addr, u32 val, const char *caller, const int line)
 651 {
 652         if (match_write_sniff_ranges(addr, 4))
 653                 DBG_871X("DBG_IO %s:%d rtw_write32(0x%04x, 0x%08x)\n", caller, line, addr, val);
 654
 655         return _rtw_write32(adapter, addr, val);
 656 }
 657 int dbg_rtw_writeN(_adapter *adapter, u32 addr ,u32 length , u8 *data, const char *caller, const int line)
 658 {
 659         if (match_write_sniff_ranges(addr, length))
 660                 DBG_871X("DBG_IO %s:%d rtw_writeN(0x%04x, %u)\n", caller, line, addr, length);
 661
 662         return _rtw_writeN(adapter, addr, length, data);
 663 }
 664
 665 #ifdef CONFIG_SDIO_HCI
 666 u8 dbg_rtw_sd_f0_read8(_adapter *adapter, u32 addr, const char *caller, const int line)
 667 {
 668         u8 val = _rtw_sd_f0_read8(adapter, addr);
 669
 670         #if 0
 671         if (match_read_sniff_ranges(addr, 1))
 672                 DBG_871X("DBG_IO %s:%d rtw_sd_f0_read8(0x%04x) return 0x%02x\n", caller, line, addr, val);
 673         #endif
 674
 675         return val;
 676 }
 677
 678 #ifdef CONFIG_SDIO_INDIRECT_ACCESS
 679 u8 dbg_rtw_sd_iread8(_adapter *adapter, u32 addr, const char *caller, const int line)
 680 {
 681         u8 val = rtw_sd_iread8(adapter, addr);
 682
 683         if (match_read_sniff_ranges(addr, 1))
 684                 DBG_871X("DBG_IO %s:%d rtw_sd_iread8(0x%04x) return 0x%02x\n", caller, line, addr, val);
 685
 686         return val;
 687 }
 688
 689 u16 dbg_rtw_sd_iread16(_adapter *adapter, u32 addr, const char *caller, const int line)
 690 {
 691         u16 val = _rtw_sd_iread16(adapter, addr);
 692
 693         if (match_read_sniff_ranges(addr, 2))
 694                 DBG_871X("DBG_IO %s:%d rtw_sd_iread16(0x%04x) return 0x%04x\n", caller, line, addr, val);
 695
 696         return val;
 697 }
 698
 699 u32 dbg_rtw_sd_iread32(_adapter *adapter, u32 addr, const char *caller, const int line)
 700 {
 701         u32 val = _rtw_sd_iread32(adapter, addr);
 702
 703         if (match_read_sniff_ranges(addr, 4))
 704                 DBG_871X("DBG_IO %s:%d rtw_sd_iread32(0x%04x) return 0x%08x\n", caller, line, addr, val);
 705
 706         return val;
 707 }
 708
 709 int dbg_rtw_sd_iwrite8(_adapter *adapter, u32 addr, u8 val, const char *caller, const int line)
 710 {
 711         if (match_write_sniff_ranges(addr, 1))
 712                 DBG_871X("DBG_IO %s:%d rtw_sd_iwrite8(0x%04x, 0x%02x)\n", caller, line, addr, val);
 713
 714         return _rtw_sd_iwrite8(adapter, addr, val);
 715 }
 716 int dbg_rtw_sd_iwrite16(_adapter *adapter, u32 addr, u16 val, const char *caller, const int line)
 717 {
 718         if (match_write_sniff_ranges(addr, 2))
 719                 DBG_871X("DBG_IO %s:%d rtw_sd_iwrite16(0x%04x, 0x%04x)\n", caller, line, addr, val);
 720
 721         return _rtw_sd_iwrite16(adapter, addr, val);
 722 }
 723 int dbg_rtw_sd_iwrite32(_adapter *adapter, u32 addr, u32 val, const char *caller, const int line)
 724 {
 725         if (match_write_sniff_ranges(addr, 4))
 726                 DBG_871X("DBG_IO %s:%d rtw_sd_iwrite32(0x%04x, 0x%08x)\n", caller, line, addr, val);
 727
 728         return _rtw_sd_iwrite32(adapter, addr, val);
 729 }
 730
 731 #endif /* CONFIG_SDIO_INDIRECT_ACCESS */
 732
 733 #endif /* CONFIG_SDIO_HCI */
 734
 735 #endif