drivers/net/wireless/rockchip_wlan/rtl8723bs/os_dep/linux/sdio_ops_linux.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 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 #define _SDIO_OPS_LINUX_C_
  20
  21 #include <drv_types.h>
  22
  23 static bool rtw_sdio_claim_host_needed(struct sdio_func *func)
  24 {
  25         struct dvobj_priv *dvobj = sdio_get_drvdata(func);
  26         PSDIO_DATA sdio_data = &dvobj->intf_data;
  27
  28         if (sdio_data->sys_sdio_irq_thd && sdio_data->sys_sdio_irq_thd == current)
  29                 return _FALSE;
  30         return _TRUE;
  31 }
  32
  33 inline void rtw_sdio_set_irq_thd(struct dvobj_priv *dvobj, _thread_hdl_ thd_hdl)
  34 {
  35         PSDIO_DATA sdio_data = &dvobj->intf_data;
  36
  37         sdio_data->sys_sdio_irq_thd = thd_hdl;
  38 }
  39
  40 u8 sd_f0_read8(struct intf_hdl *pintfhdl,u32 addr, s32 *err)
  41 {
  42         PADAPTER padapter;
  43         struct dvobj_priv *psdiodev;
  44         PSDIO_DATA psdio;
  45
  46         u8 v=0;
  47         struct sdio_func *func;
  48         bool claim_needed;
  49
  50 _func_enter_;
  51
  52         padapter = pintfhdl->padapter;
  53         psdiodev = pintfhdl->pintf_dev;
  54         psdio = &psdiodev->intf_data;
  55
  56         if (rtw_is_surprise_removed(padapter)) {
  57                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
  58                 return v;
  59         }
  60
  61         func = psdio->func;
  62         claim_needed = rtw_sdio_claim_host_needed(func);
  63
  64         if (claim_needed)
  65                 sdio_claim_host(func);
  66         v = sdio_f0_readb(func, addr, err);
  67         if (claim_needed)
  68                 sdio_release_host(func);
  69         if (err && *err)
  70                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x\n", __func__, *err, addr);
  71
  72 _func_exit_;
  73
  74         return v;
  75 }
  76
  77 void sd_f0_write8(struct intf_hdl *pintfhdl, u32 addr, u8 v, s32 *err)
  78 {
  79         PADAPTER padapter;
  80         struct dvobj_priv *psdiodev;
  81         PSDIO_DATA psdio;
  82
  83         struct sdio_func *func;
  84         bool claim_needed;
  85
  86 _func_enter_;
  87         padapter = pintfhdl->padapter;
  88         psdiodev = pintfhdl->pintf_dev;
  89         psdio = &psdiodev->intf_data;
  90
  91         if (rtw_is_surprise_removed(padapter)) {
  92                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
  93                 return;
  94         }
  95
  96         func = psdio->func;
  97         claim_needed = rtw_sdio_claim_host_needed(func);
  98
  99         if (claim_needed)
 100                 sdio_claim_host(func);
 101         sdio_f0_writeb(func, v, addr, err);
 102         if (claim_needed)
 103                 sdio_release_host(func);
 104         if (err && *err)
 105                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%02x\n", __func__, *err, addr, v);
 106
 107 _func_exit_;
 108 }
 109
 110 /*
 111  * Return:
 112  *      0               Success
 113  *      others  Fail
 114  */
 115 s32 _sd_cmd52_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
 116 {
 117         PADAPTER padapter;
 118         struct dvobj_priv *psdiodev;
 119         PSDIO_DATA psdio;
 120
 121         int err=0, i;
 122         struct sdio_func *func;
 123
 124 _func_enter_;
 125         padapter = pintfhdl->padapter;
 126         psdiodev = pintfhdl->pintf_dev;
 127         psdio = &psdiodev->intf_data;
 128
 129         if (rtw_is_surprise_removed(padapter)) {
 130                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 131                 return err;
 132         }
 133
 134         func = psdio->func;
 135
 136         for (i = 0; i < cnt; i++) {
 137                 pdata[i] = sdio_readb(func, addr+i, &err);
 138                 if (err) {
 139                         DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x\n", __func__, err, addr+i);
 140                         break;
 141                 }
 142         }
 143
 144 _func_exit_;
 145
 146         return err;
 147 }
 148
 149 /*
 150  * Return:
 151  *      0               Success
 152  *      others  Fail
 153  */
 154 s32 sd_cmd52_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
 155 {
 156         PADAPTER padapter;
 157         struct dvobj_priv *psdiodev;
 158         PSDIO_DATA psdio;
 159
 160         int err=0, i;
 161         struct sdio_func *func;
 162         bool claim_needed;
 163
 164 _func_enter_;
 165         padapter = pintfhdl->padapter;
 166         psdiodev = pintfhdl->pintf_dev;
 167         psdio = &psdiodev->intf_data;
 168
 169         if (rtw_is_surprise_removed(padapter)) {
 170                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 171                 return err;
 172         }
 173
 174         func = psdio->func;
 175         claim_needed = rtw_sdio_claim_host_needed(func);
 176
 177         if (claim_needed)
 178                 sdio_claim_host(func);
 179         err = _sd_cmd52_read(pintfhdl, addr, cnt, pdata);
 180         if (claim_needed)
 181                 sdio_release_host(func);
 182
 183 _func_exit_;
 184
 185         return err;
 186 }
 187
 188 /*
 189  * Return:
 190  *      0               Success
 191  *      others  Fail
 192  */
 193 s32 _sd_cmd52_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
 194 {
 195         PADAPTER padapter;
 196         struct dvobj_priv *psdiodev;
 197         PSDIO_DATA psdio;
 198
 199         int err=0, i;
 200         struct sdio_func *func;
 201
 202 _func_enter_;
 203         padapter = pintfhdl->padapter;
 204         psdiodev = pintfhdl->pintf_dev;
 205         psdio = &psdiodev->intf_data;
 206
 207         if (rtw_is_surprise_removed(padapter)) {
 208                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 209                 return err;
 210         }
 211
 212         func = psdio->func;
 213
 214         for (i = 0; i < cnt; i++) {
 215                 sdio_writeb(func, pdata[i], addr+i, &err);
 216                 if (err) {
 217                         DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%02x\n", __func__, err, addr+i, pdata[i]);
 218                         break;
 219                 }
 220         }
 221
 222 _func_exit_;
 223
 224         return err;
 225 }
 226
 227 /*
 228  * Return:
 229  *      0               Success
 230  *      others  Fail
 231  */
 232 s32 sd_cmd52_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
 233 {
 234         PADAPTER padapter;
 235         struct dvobj_priv *psdiodev;
 236         PSDIO_DATA psdio;
 237
 238         int err=0, i;
 239         struct sdio_func *func;
 240         bool claim_needed;
 241
 242 _func_enter_;
 243         padapter = pintfhdl->padapter;
 244         psdiodev = pintfhdl->pintf_dev;
 245         psdio = &psdiodev->intf_data;
 246
 247         if (rtw_is_surprise_removed(padapter)) {
 248                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 249                 return err;
 250         }
 251
 252         func = psdio->func;
 253         claim_needed = rtw_sdio_claim_host_needed(func);
 254
 255         if (claim_needed)
 256                 sdio_claim_host(func);
 257         err = _sd_cmd52_write(pintfhdl, addr, cnt, pdata);
 258         if (claim_needed)
 259                 sdio_release_host(func);
 260
 261 _func_exit_;
 262
 263         return err;
 264 }
 265
 266 u8 _sd_read8(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
 267 {
 268         PADAPTER padapter;
 269         struct dvobj_priv *psdiodev;
 270         PSDIO_DATA psdio;
 271
 272         u8 v=0;
 273         struct sdio_func *func;
 274
 275 _func_enter_;
 276         padapter = pintfhdl->padapter;
 277         psdiodev = pintfhdl->pintf_dev;
 278         psdio = &psdiodev->intf_data;
 279
 280         if (rtw_is_surprise_removed(padapter)) {
 281                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 282                 return v;
 283         }
 284
 285         func = psdio->func;
 286
 287         v = sdio_readb(func, addr, err);
 288
 289         if (err && *err)
 290                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x\n", __func__, *err, addr);
 291
 292 _func_exit_;
 293
 294         return v;
 295 }
 296
 297 u8 sd_read8(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
 298 {
 299         PADAPTER padapter;
 300         struct dvobj_priv *psdiodev;
 301         PSDIO_DATA psdio;
 302
 303         u8 v=0;
 304         struct sdio_func *func;
 305         bool claim_needed;
 306
 307 _func_enter_;
 308         padapter = pintfhdl->padapter;
 309         psdiodev = pintfhdl->pintf_dev;
 310         psdio = &psdiodev->intf_data;
 311
 312         if (rtw_is_surprise_removed(padapter)) {
 313                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 314                 return v;
 315         }
 316
 317         func = psdio->func;
 318         claim_needed = rtw_sdio_claim_host_needed(func);
 319
 320         if (claim_needed)
 321                 sdio_claim_host(func);
 322         v = sdio_readb(func, addr, err);
 323         if (claim_needed)
 324                 sdio_release_host(func);
 325         if (err && *err)
 326                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x\n", __func__, *err, addr);
 327
 328 _func_exit_;
 329
 330         return v;
 331 }
 332
 333 u16 sd_read16(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
 334 {
 335         PADAPTER padapter;
 336         struct dvobj_priv *psdiodev;
 337         PSDIO_DATA psdio;
 338
 339         u16 v=0;
 340         struct sdio_func *func;
 341         bool claim_needed;
 342
 343 _func_enter_;
 344         padapter = pintfhdl->padapter;
 345         psdiodev = pintfhdl->pintf_dev;
 346         psdio = &psdiodev->intf_data;
 347
 348         if (rtw_is_surprise_removed(padapter)) {
 349                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 350                 return v;
 351         }
 352
 353         func = psdio->func;
 354         claim_needed = rtw_sdio_claim_host_needed(func);
 355
 356         if (claim_needed)
 357                 sdio_claim_host(func);
 358         v = sdio_readw(func, addr, err);
 359         if (claim_needed)
 360                 sdio_release_host(func);
 361         if (err && *err)
 362                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x\n", __func__, *err, addr);
 363
 364 _func_exit_;
 365
 366         return  v;
 367 }
 368
 369 u32 _sd_read32(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
 370 {
 371         PADAPTER padapter;
 372         struct dvobj_priv *psdiodev;
 373         PSDIO_DATA psdio;
 374
 375         u32 v=0;
 376         struct sdio_func *func;
 377
 378 _func_enter_;
 379         padapter = pintfhdl->padapter;
 380         psdiodev = pintfhdl->pintf_dev;
 381         psdio = &psdiodev->intf_data;
 382
 383         if (rtw_is_surprise_removed(padapter)) {
 384                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 385                 return v;
 386         }
 387
 388         func = psdio->func;
 389
 390         v = sdio_readl(func, addr, err);
 391
 392         if (err && *err)
 393         {
 394                 int i;
 395
 396                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x\n", __func__, *err, addr, v);
 397
 398                 *err = 0;
 399                 for(i=0; i<SD_IO_TRY_CNT; i++)
 400                 {
 401                         //sdio_claim_host(func);
 402                         v = sdio_readl(func, addr, err);
 403                         //sdio_release_host(func);
 404                         if (*err == 0){
 405                                 rtw_reset_continual_io_error(psdiodev);
 406                                 break;
 407                         }
 408                         else{
 409                                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 410                                 if(( -ESHUTDOWN == *err ) || ( -ENODEV == *err))
 411                                 {
 412                                         rtw_set_surprise_removed(padapter);
 413                                 }
 414
 415                                 if(rtw_inc_and_chk_continual_io_error(psdiodev) == _TRUE ){
 416                                         rtw_set_surprise_removed(padapter);
 417                                         break;
 418                                 }
 419
 420                         }
 421                 }
 422
 423                 if (i==SD_IO_TRY_CNT)
 424                         DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 425                 else
 426                         DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 427
 428         }
 429
 430 _func_exit_;
 431
 432         return  v;
 433 }
 434
 435 u32 sd_read32(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
 436 {
 437         PADAPTER padapter;
 438         struct dvobj_priv *psdiodev;
 439         PSDIO_DATA psdio;
 440
 441         u32 v=0;
 442         struct sdio_func *func;
 443         bool claim_needed;
 444
 445 _func_enter_;
 446         padapter = pintfhdl->padapter;
 447         psdiodev = pintfhdl->pintf_dev;
 448         psdio = &psdiodev->intf_data;
 449
 450         if (rtw_is_surprise_removed(padapter)) {
 451                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 452                 return v;
 453         }
 454
 455         func = psdio->func;
 456         claim_needed = rtw_sdio_claim_host_needed(func);
 457
 458         if (claim_needed)
 459                 sdio_claim_host(func);
 460         v = sdio_readl(func, addr, err);
 461         if (claim_needed)
 462                 sdio_release_host(func);
 463
 464         if (err && *err)
 465         {
 466                 int i;
 467
 468                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x\n", __func__, *err, addr, v);
 469
 470                 *err = 0;
 471                 for(i=0; i<SD_IO_TRY_CNT; i++)
 472                 {
 473                         if (claim_needed) sdio_claim_host(func);
 474                         v = sdio_readl(func, addr, err);
 475                         if (claim_needed) sdio_release_host(func);
 476
 477                         if (*err == 0){
 478                                 rtw_reset_continual_io_error(psdiodev);
 479                                 break;
 480                         }else{
 481                                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 482                                 if(( -ESHUTDOWN == *err ) || ( -ENODEV == *err)){
 483                                         rtw_set_surprise_removed(padapter);
 484                                 }
 485
 486                                 if(rtw_inc_and_chk_continual_io_error(psdiodev) == _TRUE ){
 487                                         rtw_set_surprise_removed(padapter);
 488                                         break;
 489                                 }
 490                         }
 491                 }
 492
 493                 if (i==SD_IO_TRY_CNT)
 494                         DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 495                 else
 496                         DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 497
 498         }
 499
 500 _func_exit_;
 501
 502         return  v;
 503 }
 504
 505 void sd_write8(struct intf_hdl *pintfhdl, u32 addr, u8 v, s32 *err)
 506 {
 507         PADAPTER padapter;
 508         struct dvobj_priv *psdiodev;
 509         PSDIO_DATA psdio;
 510
 511         struct sdio_func *func;
 512         bool claim_needed;
 513
 514 _func_enter_;
 515
 516         padapter = pintfhdl->padapter;
 517         psdiodev = pintfhdl->pintf_dev;
 518         psdio = &psdiodev->intf_data;
 519
 520         if (rtw_is_surprise_removed(padapter)) {
 521                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 522                 return ;
 523         }
 524
 525         func = psdio->func;
 526         claim_needed = rtw_sdio_claim_host_needed(func);
 527
 528         if (claim_needed)
 529                 sdio_claim_host(func);
 530         sdio_writeb(func, v, addr, err);
 531         if (claim_needed)
 532                 sdio_release_host(func);
 533         if (err && *err)
 534                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%02x\n", __func__, *err, addr, v);
 535
 536 _func_exit_;
 537 }
 538
 539 void sd_write16(struct intf_hdl *pintfhdl, u32 addr, u16 v, s32 *err)
 540 {
 541         PADAPTER padapter;
 542         struct dvobj_priv *psdiodev;
 543         PSDIO_DATA psdio;
 544
 545         struct sdio_func *func;
 546         bool claim_needed;
 547
 548 _func_enter_;
 549         padapter = pintfhdl->padapter;
 550         psdiodev = pintfhdl->pintf_dev;
 551         psdio = &psdiodev->intf_data;
 552
 553         if (rtw_is_surprise_removed(padapter)) {
 554                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 555                 return ;
 556         }
 557
 558         func = psdio->func;
 559         claim_needed = rtw_sdio_claim_host_needed(func);
 560
 561         if (claim_needed)
 562                 sdio_claim_host(func);
 563         sdio_writew(func, v, addr, err);
 564         if (claim_needed)
 565                 sdio_release_host(func);
 566         if (err && *err)
 567                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%04x\n", __func__, *err, addr, v);
 568
 569 _func_exit_;
 570 }
 571
 572 void _sd_write32(struct intf_hdl *pintfhdl, u32 addr, u32 v, s32 *err)
 573 {
 574         PADAPTER padapter;
 575         struct dvobj_priv *psdiodev;
 576         PSDIO_DATA psdio;
 577
 578         struct sdio_func *func;
 579
 580 _func_enter_;
 581         padapter = pintfhdl->padapter;
 582         psdiodev = pintfhdl->pintf_dev;
 583         psdio = &psdiodev->intf_data;
 584
 585         if (rtw_is_surprise_removed(padapter)) {
 586                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 587                 return ;
 588         }
 589
 590         func = psdio->func;
 591
 592         sdio_writel(func, v, addr, err);
 593
 594         if (err && *err)
 595         {
 596                 int i;
 597
 598                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x\n", __func__, *err, addr, v);
 599
 600                 *err = 0;
 601                 for(i=0; i<SD_IO_TRY_CNT; i++)
 602                 {
 603                         sdio_writel(func, v, addr, err);
 604                         if (*err == 0){
 605                                 rtw_reset_continual_io_error(psdiodev);
 606                                 break;
 607                         }else{
 608                                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 609                                 if(( -ESHUTDOWN == *err ) || ( -ENODEV == *err)){
 610                                         rtw_set_surprise_removed(padapter);
 611                                 }
 612
 613                                 if(rtw_inc_and_chk_continual_io_error(psdiodev) == _TRUE ){
 614                                         rtw_set_surprise_removed(padapter);
 615                                         break;
 616                                 }
 617                         }
 618                 }
 619
 620                 if (i==SD_IO_TRY_CNT)
 621                         DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
 622                 else
 623                         DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
 624
 625         }
 626
 627 _func_exit_;
 628 }
 629
 630 void sd_write32(struct intf_hdl *pintfhdl, u32 addr, u32 v, s32 *err)
 631 {
 632         PADAPTER padapter;
 633         struct dvobj_priv *psdiodev;
 634         PSDIO_DATA psdio;
 635         struct sdio_func *func;
 636         bool claim_needed;
 637
 638 _func_enter_;
 639         padapter = pintfhdl->padapter;
 640         psdiodev = pintfhdl->pintf_dev;
 641         psdio = &psdiodev->intf_data;
 642
 643         if (rtw_is_surprise_removed(padapter)) {
 644                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 645                 return ;
 646         }
 647
 648         func = psdio->func;
 649         claim_needed = rtw_sdio_claim_host_needed(func);
 650
 651         if (claim_needed)
 652                 sdio_claim_host(func);
 653         sdio_writel(func, v, addr, err);
 654         if (claim_needed)
 655                 sdio_release_host(func);
 656
 657         if (err && *err)
 658         {
 659                 int i;
 660
 661                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x\n", __func__, *err, addr, v);
 662
 663                 *err = 0;
 664                 for(i=0; i<SD_IO_TRY_CNT; i++)
 665                 {
 666                         if (claim_needed) sdio_claim_host(func);
 667                         sdio_writel(func, v, addr, err);
 668                         if (claim_needed) sdio_release_host(func);
 669                         if (*err == 0){
 670                                 rtw_reset_continual_io_error(psdiodev);
 671                                 break;
 672                         }else{
 673                                 DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
 674                                 if(( -ESHUTDOWN == *err ) || ( -ENODEV == *err)){
 675                                         rtw_set_surprise_removed(padapter);
 676                                 }
 677
 678                                 if(rtw_inc_and_chk_continual_io_error(psdiodev) == _TRUE ){
 679                                         rtw_set_surprise_removed(padapter);
 680                                         break;
 681                                 }
 682                         }
 683                 }
 684
 685                 if (i==SD_IO_TRY_CNT)
 686                         DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
 687                 else
 688                         DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
 689         }
 690
 691 _func_exit_;
 692 }
 693
 694 /*
 695  * Use CMD53 to read data from SDIO device.
 696  * This function MUST be called after sdio_claim_host() or
 697  * in SDIO ISR(host had been claimed).
 698  *
 699  * Parameters:
 700  *      psdio   pointer of SDIO_DATA
 701  *      addr    address to read
 702  *      cnt             amount to read
 703  *      pdata   pointer to put data, this should be a "DMA:able scratch buffer"!
 704  *
 705  * Return:
 706  *      0               Success
 707  *      others  Fail
 708  */
 709 s32 _sd_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
 710 {
 711         PADAPTER padapter;
 712         struct dvobj_priv *psdiodev;
 713         PSDIO_DATA psdio;
 714
 715         int err= -EPERM;
 716         struct sdio_func *func;
 717
 718 _func_enter_;
 719         padapter = pintfhdl->padapter;
 720         psdiodev = pintfhdl->pintf_dev;
 721         psdio = &psdiodev->intf_data;
 722
 723         if (rtw_is_surprise_removed(padapter)) {
 724                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 725                 return err;
 726         }
 727
 728         func = psdio->func;
 729
 730         if (unlikely((cnt==1) || (cnt==2)))
 731         {
 732                 int i;
 733                 u8 *pbuf = (u8*)pdata;
 734
 735                 for (i = 0; i < cnt; i++)
 736                 {
 737                         *(pbuf+i) = sdio_readb(func, addr+i, &err);
 738
 739                         if (err) {
 740                                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x\n", __func__, err, addr);
 741                                 break;
 742                         }
 743                 }
 744                 return err;
 745         }
 746
 747         err = sdio_memcpy_fromio(func, pdata, addr, cnt);
 748         if (err) {
 749                 DBG_871X(KERN_ERR "%s: FAIL(%d)! ADDR=%#x Size=%d\n", __func__, err, addr, cnt);
 750         }
 751
 752 _func_exit_;
 753
 754         return err;
 755 }
 756
 757 /*
 758  * Use CMD53 to read data from SDIO device.
 759  *
 760  * Parameters:
 761  *      psdio   pointer of SDIO_DATA
 762  *      addr    address to read
 763  *      cnt             amount to read
 764  *      pdata   pointer to put data, this should be a "DMA:able scratch buffer"!
 765  *
 766  * Return:
 767  *      0               Success
 768  *      others  Fail
 769  */
 770 s32 sd_read(struct intf_hdl * pintfhdl, u32 addr, u32 cnt, void *pdata)
 771 {
 772         PADAPTER padapter;
 773         struct dvobj_priv *psdiodev;
 774         PSDIO_DATA psdio;
 775
 776         struct sdio_func *func;
 777         bool claim_needed;
 778         s32 err= -EPERM;
 779
 780 _func_enter_;
 781         padapter = pintfhdl->padapter;
 782         psdiodev = pintfhdl->pintf_dev;
 783         psdio = &psdiodev->intf_data;
 784
 785         if (rtw_is_surprise_removed(padapter)) {
 786                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 787                 return err;
 788         }
 789         func = psdio->func;
 790         claim_needed = rtw_sdio_claim_host_needed(func);
 791
 792         if (claim_needed)
 793                 sdio_claim_host(func);
 794         err = _sd_read(pintfhdl, addr, cnt, pdata);
 795         if (claim_needed)
 796                 sdio_release_host(func);
 797 _func_exit_;
 798         return err;
 799 }
 800
 801 /*
 802  * Use CMD53 to write data to SDIO device.
 803  * This function MUST be called after sdio_claim_host() or
 804  * in SDIO ISR(host had been claimed).
 805  *
 806  * Parameters:
 807  *      psdio   pointer of SDIO_DATA
 808  *      addr    address to write
 809  *      cnt             amount to write
 810  *      pdata   data pointer, this should be a "DMA:able scratch buffer"!
 811  *
 812  * Return:
 813  *      0               Success
 814  *      others  Fail
 815  */
 816 s32 _sd_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
 817 {
 818         PADAPTER padapter;
 819         struct dvobj_priv *psdiodev;
 820         PSDIO_DATA psdio;
 821
 822         struct sdio_func *func;
 823         u32 size;
 824         s32 err=-EPERM;
 825
 826 _func_enter_;
 827         padapter = pintfhdl->padapter;
 828         psdiodev = pintfhdl->pintf_dev;
 829         psdio = &psdiodev->intf_data;
 830
 831         if (rtw_is_surprise_removed(padapter)) {
 832                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 833                 return err;
 834         }
 835
 836         func = psdio->func;
 837 //      size = sdio_align_size(func, cnt);
 838
 839         if (unlikely((cnt==1) || (cnt==2)))
 840         {
 841                 int i;
 842                 u8 *pbuf = (u8*)pdata;
 843
 844                 for (i = 0; i < cnt; i++)
 845                 {
 846                         sdio_writeb(func, *(pbuf+i), addr+i, &err);
 847                         if (err) {
 848                                 DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%02x\n", __func__, err, addr, *(pbuf+i));
 849                                 break;
 850                         }
 851                 }
 852
 853                 return err;
 854         }
 855
 856         size = cnt;
 857         err = sdio_memcpy_toio(func, addr, pdata, size);
 858         if (err) {
 859                 DBG_871X(KERN_ERR "%s: FAIL(%d)! ADDR=%#x Size=%d(%d)\n", __func__, err, addr, cnt, size);
 860         }
 861
 862 _func_exit_;
 863
 864         return err;
 865 }
 866
 867 /*
 868  * Use CMD53 to write data to SDIO device.
 869  *
 870  * Parameters:
 871  *  psdio       pointer of SDIO_DATA
 872  *  addr        address to write
 873  *  cnt         amount to write
 874  *  pdata       data pointer, this should be a "DMA:able scratch buffer"!
 875  *
 876  * Return:
 877  *  0           Success
 878  *  others      Fail
 879  */
 880 s32 sd_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
 881 {
 882         PADAPTER padapter;
 883         struct dvobj_priv *psdiodev;
 884         PSDIO_DATA psdio;
 885
 886         struct sdio_func *func;
 887         bool claim_needed;
 888         s32 err=-EPERM;
 889 _func_enter_;
 890         padapter = pintfhdl->padapter;
 891         psdiodev = pintfhdl->pintf_dev;
 892         psdio = &psdiodev->intf_data;
 893
 894         if (rtw_is_surprise_removed(padapter)) {
 895                 //DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n",__FUNCTION__);
 896                 return err;
 897         }
 898
 899         func = psdio->func;
 900         claim_needed = rtw_sdio_claim_host_needed(func);
 901
 902         if (claim_needed)
 903                 sdio_claim_host(func);
 904         err = _sd_write(pintfhdl, addr, cnt, pdata);
 905         if (claim_needed)
 906                 sdio_release_host(func);
 907 _func_exit_;
 908         return err;
 909 }
 910