drivers/staging/wilc1000/wilc_sdio.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
   4  * All rights reserved.
   5  */
   6
   7 #include <linux/mmc/sdio_func.h>
   8 #include <linux/mmc/host.h>
   9
  10 #include "wilc_wfi_netdevice.h"
  11
  12 #define SDIO_MODALIAS "wilc1000_sdio"
  13
  14 #define SDIO_VENDOR_ID_WILC 0x0296
  15 #define SDIO_DEVICE_ID_WILC 0x5347
  16
  17 static const struct sdio_device_id wilc_sdio_ids[] = {
  18         { SDIO_DEVICE(SDIO_VENDOR_ID_WILC, SDIO_DEVICE_ID_WILC) },
  19         { },
  20 };
  21 MODULE_DEVICE_TABLE(sdio, wilc_sdio_ids);
  22
  23 #define WILC_SDIO_BLOCK_SIZE 512
  24
  25 struct wilc_sdio {
  26         bool irq_gpio;
  27         u32 block_size;
  28         int nint;
  29 /* Max num interrupts allowed in registers 0xf7, 0xf8 */
  30 #define MAX_NUN_INT_THRPT_ENH2 (5)
  31         int has_thrpt_enh3;
  32 };
  33
  34 static struct wilc_sdio g_sdio;
  35 static const struct wilc_hif_func wilc_hif_sdio;
  36
  37 static int sdio_write_reg(struct wilc *wilc, u32 addr, u32 data);
  38 static int sdio_read_reg(struct wilc *wilc, u32 addr, u32 *data);
  39 static int sdio_init(struct wilc *wilc, bool resume);
  40
  41 static void wilc_sdio_interrupt(struct sdio_func *func)
  42 {
  43         sdio_release_host(func);
  44         wilc_handle_isr(sdio_get_drvdata(func));
  45         sdio_claim_host(func);
  46 }
  47
  48 static int wilc_sdio_cmd52(struct wilc *wilc, struct sdio_cmd52 *cmd)
  49 {
  50         struct sdio_func *func = container_of(wilc->dev, struct sdio_func, dev);
  51         int ret;
  52         u8 data;
  53
  54         sdio_claim_host(func);
  55
  56         func->num = cmd->function;
  57         if (cmd->read_write) {  /* write */
  58                 if (cmd->raw) {
  59                         sdio_writeb(func, cmd->data, cmd->address, &ret);
  60                         data = sdio_readb(func, cmd->address, &ret);
  61                         cmd->data = data;
  62                 } else {
  63                         sdio_writeb(func, cmd->data, cmd->address, &ret);
  64                 }
  65         } else {        /* read */
  66                 data = sdio_readb(func, cmd->address, &ret);
  67                 cmd->data = data;
  68         }
  69
  70         sdio_release_host(func);
  71
  72         if (ret)
  73                 dev_err(&func->dev, "%s..failed, err(%d)\n", __func__, ret);
  74         return ret;
  75 }
  76
  77 static int wilc_sdio_cmd53(struct wilc *wilc, struct sdio_cmd53 *cmd)
  78 {
  79         struct sdio_func *func = container_of(wilc->dev, struct sdio_func, dev);
  80         int size, ret;
  81
  82         sdio_claim_host(func);
  83
  84         func->num = cmd->function;
  85         func->cur_blksize = cmd->block_size;
  86         if (cmd->block_mode)
  87                 size = cmd->count * cmd->block_size;
  88         else
  89                 size = cmd->count;
  90
  91         if (cmd->read_write) {  /* write */
  92                 ret = sdio_memcpy_toio(func, cmd->address,
  93                                        (void *)cmd->buffer, size);
  94         } else {        /* read */
  95                 ret = sdio_memcpy_fromio(func, (void *)cmd->buffer,
  96                                          cmd->address,  size);
  97         }
  98
  99         sdio_release_host(func);
 100
 101         if (ret)
 102                 dev_err(&func->dev, "%s..failed, err(%d)\n", __func__,  ret);
 103
 104         return ret;
 105 }
 106
 107 static int linux_sdio_probe(struct sdio_func *func,
 108                             const struct sdio_device_id *id)
 109 {
 110         struct wilc *wilc;
 111         int ret;
 112         struct gpio_desc *gpio = NULL;
 113
 114         if (IS_ENABLED(CONFIG_WILC1000_HW_OOB_INTR)) {
 115                 gpio = gpiod_get(&func->dev, "irq", GPIOD_IN);
 116                 if (IS_ERR(gpio)) {
 117                         /* get the GPIO descriptor from hardcode GPIO number */
 118                         gpio = gpio_to_desc(GPIO_NUM);
 119                         if (!gpio)
 120                                 dev_err(&func->dev, "failed to get irq gpio\n");
 121                 }
 122         }
 123
 124         dev_dbg(&func->dev, "Initializing netdev\n");
 125         ret = wilc_netdev_init(&wilc, &func->dev, HIF_SDIO, &wilc_hif_sdio);
 126         if (ret) {
 127                 dev_err(&func->dev, "Couldn't initialize netdev\n");
 128                 return ret;
 129         }
 130         sdio_set_drvdata(func, wilc);
 131         wilc->dev = &func->dev;
 132         wilc->gpio_irq = gpio;
 133
 134         dev_info(&func->dev, "Driver Initializing success\n");
 135         return 0;
 136 }
 137
 138 static void linux_sdio_remove(struct sdio_func *func)
 139 {
 140         struct wilc *wilc = sdio_get_drvdata(func);
 141
 142         /* free the GPIO in module remove */
 143         if (wilc->gpio_irq)
 144                 gpiod_put(wilc->gpio_irq);
 145         wilc_netdev_cleanup(wilc);
 146 }
 147
 148 static int sdio_reset(struct wilc *wilc)
 149 {
 150         struct sdio_cmd52 cmd;
 151         int ret;
 152         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 153
 154         cmd.read_write = 1;
 155         cmd.function = 0;
 156         cmd.raw = 0;
 157         cmd.address = 0x6;
 158         cmd.data = 0x8;
 159         ret = wilc_sdio_cmd52(wilc, &cmd);
 160         if (ret) {
 161                 dev_err(&func->dev, "Fail cmd 52, reset cmd ...\n");
 162                 return ret;
 163         }
 164         return 0;
 165 }
 166
 167 static int wilc_sdio_suspend(struct device *dev)
 168 {
 169         struct sdio_func *func = dev_to_sdio_func(dev);
 170         struct wilc *wilc = sdio_get_drvdata(func);
 171         int ret;
 172
 173         dev_info(dev, "sdio suspend\n");
 174         chip_wakeup(wilc);
 175
 176         if (!wilc->suspend_event) {
 177                 wilc_chip_sleep_manually(wilc);
 178         } else {
 179                 host_sleep_notify(wilc);
 180                 chip_allow_sleep(wilc);
 181         }
 182
 183         ret = sdio_reset(wilc);
 184         if (ret) {
 185                 dev_err(&func->dev, "Fail reset sdio\n");
 186                 return ret;
 187         }
 188         sdio_claim_host(func);
 189
 190         return 0;
 191 }
 192
 193 static int wilc_sdio_resume(struct device *dev)
 194 {
 195         struct sdio_func *func = dev_to_sdio_func(dev);
 196         struct wilc *wilc = sdio_get_drvdata(func);
 197
 198         dev_info(dev, "sdio resume\n");
 199         sdio_release_host(func);
 200         chip_wakeup(wilc);
 201         sdio_init(wilc, true);
 202
 203         if (wilc->suspend_event)
 204                 host_wakeup_notify(wilc);
 205
 206         chip_allow_sleep(wilc);
 207
 208         return 0;
 209 }
 210
 211 static const struct of_device_id wilc_of_match[] = {
 212         { .compatible = "microchip,wilc1000-sdio", },
 213         { /* sentinel */ }
 214 };
 215 MODULE_DEVICE_TABLE(of, wilc_of_match);
 216
 217 static const struct dev_pm_ops wilc_sdio_pm_ops = {
 218         .suspend = wilc_sdio_suspend,
 219         .resume = wilc_sdio_resume,
 220 };
 221
 222 static struct sdio_driver wilc_sdio_driver = {
 223         .name           = SDIO_MODALIAS,
 224         .id_table       = wilc_sdio_ids,
 225         .probe          = linux_sdio_probe,
 226         .remove         = linux_sdio_remove,
 227         .drv = {
 228                 .pm = &wilc_sdio_pm_ops,
 229                 .of_match_table = wilc_of_match,
 230         }
 231 };
 232 module_driver(wilc_sdio_driver,
 233               sdio_register_driver,
 234               sdio_unregister_driver);
 235 MODULE_LICENSE("GPL");
 236
 237 static int wilc_sdio_enable_interrupt(struct wilc *dev)
 238 {
 239         struct sdio_func *func = container_of(dev->dev, struct sdio_func, dev);
 240         int ret = 0;
 241
 242         sdio_claim_host(func);
 243         ret = sdio_claim_irq(func, wilc_sdio_interrupt);
 244         sdio_release_host(func);
 245
 246         if (ret < 0) {
 247                 dev_err(&func->dev, "can't claim sdio_irq, err(%d)\n", ret);
 248                 ret = -EIO;
 249         }
 250         return ret;
 251 }
 252
 253 static void wilc_sdio_disable_interrupt(struct wilc *dev)
 254 {
 255         struct sdio_func *func = container_of(dev->dev, struct sdio_func, dev);
 256         int ret;
 257
 258         sdio_claim_host(func);
 259         ret = sdio_release_irq(func);
 260         if (ret < 0)
 261                 dev_err(&func->dev, "can't release sdio_irq, err(%d)\n", ret);
 262         sdio_release_host(func);
 263 }
 264
 265 /********************************************
 266  *
 267  *      Function 0
 268  *
 269  ********************************************/
 270
 271 static int sdio_set_func0_csa_address(struct wilc *wilc, u32 adr)
 272 {
 273         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 274         struct sdio_cmd52 cmd;
 275         int ret;
 276
 277         /**
 278          *      Review: BIG ENDIAN
 279          **/
 280         cmd.read_write = 1;
 281         cmd.function = 0;
 282         cmd.raw = 0;
 283         cmd.address = 0x10c;
 284         cmd.data = (u8)adr;
 285         ret = wilc_sdio_cmd52(wilc, &cmd);
 286         if (ret) {
 287                 dev_err(&func->dev, "Failed cmd52, set 0x10c data...\n");
 288                 goto fail;
 289         }
 290
 291         cmd.address = 0x10d;
 292         cmd.data = (u8)(adr >> 8);
 293         ret = wilc_sdio_cmd52(wilc, &cmd);
 294         if (ret) {
 295                 dev_err(&func->dev, "Failed cmd52, set 0x10d data...\n");
 296                 goto fail;
 297         }
 298
 299         cmd.address = 0x10e;
 300         cmd.data = (u8)(adr >> 16);
 301         ret = wilc_sdio_cmd52(wilc, &cmd);
 302         if (ret) {
 303                 dev_err(&func->dev, "Failed cmd52, set 0x10e data...\n");
 304                 goto fail;
 305         }
 306
 307         return 1;
 308 fail:
 309         return 0;
 310 }
 311
 312 static int sdio_set_func0_block_size(struct wilc *wilc, u32 block_size)
 313 {
 314         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 315         struct sdio_cmd52 cmd;
 316         int ret;
 317
 318         cmd.read_write = 1;
 319         cmd.function = 0;
 320         cmd.raw = 0;
 321         cmd.address = 0x10;
 322         cmd.data = (u8)block_size;
 323         ret = wilc_sdio_cmd52(wilc, &cmd);
 324         if (ret) {
 325                 dev_err(&func->dev, "Failed cmd52, set 0x10 data...\n");
 326                 goto fail;
 327         }
 328
 329         cmd.address = 0x11;
 330         cmd.data = (u8)(block_size >> 8);
 331         ret = wilc_sdio_cmd52(wilc, &cmd);
 332         if (ret) {
 333                 dev_err(&func->dev, "Failed cmd52, set 0x11 data...\n");
 334                 goto fail;
 335         }
 336
 337         return 1;
 338 fail:
 339         return 0;
 340 }
 341
 342 /********************************************
 343  *
 344  *      Function 1
 345  *
 346  ********************************************/
 347
 348 static int sdio_set_func1_block_size(struct wilc *wilc, u32 block_size)
 349 {
 350         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 351         struct sdio_cmd52 cmd;
 352         int ret;
 353
 354         cmd.read_write = 1;
 355         cmd.function = 0;
 356         cmd.raw = 0;
 357         cmd.address = 0x110;
 358         cmd.data = (u8)block_size;
 359         ret = wilc_sdio_cmd52(wilc, &cmd);
 360         if (ret) {
 361                 dev_err(&func->dev, "Failed cmd52, set 0x110 data...\n");
 362                 goto fail;
 363         }
 364         cmd.address = 0x111;
 365         cmd.data = (u8)(block_size >> 8);
 366         ret = wilc_sdio_cmd52(wilc, &cmd);
 367         if (ret) {
 368                 dev_err(&func->dev, "Failed cmd52, set 0x111 data...\n");
 369                 goto fail;
 370         }
 371
 372         return 1;
 373 fail:
 374         return 0;
 375 }
 376
 377 /********************************************
 378  *
 379  *      Sdio interfaces
 380  *
 381  ********************************************/
 382 static int sdio_write_reg(struct wilc *wilc, u32 addr, u32 data)
 383 {
 384         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 385         int ret;
 386
 387         cpu_to_le32s(&data);
 388
 389         if (addr >= 0xf0 && addr <= 0xff) {
 390                 struct sdio_cmd52 cmd;
 391
 392                 cmd.read_write = 1;
 393                 cmd.function = 0;
 394                 cmd.raw = 0;
 395                 cmd.address = addr;
 396                 cmd.data = data;
 397                 ret = wilc_sdio_cmd52(wilc, &cmd);
 398                 if (ret) {
 399                         dev_err(&func->dev,
 400                                 "Failed cmd 52, read reg (%08x) ...\n", addr);
 401                         goto fail;
 402                 }
 403         } else {
 404                 struct sdio_cmd53 cmd;
 405
 406                 /**
 407                  *      set the AHB address
 408                  **/
 409                 if (!sdio_set_func0_csa_address(wilc, addr))
 410                         goto fail;
 411
 412                 cmd.read_write = 1;
 413                 cmd.function = 0;
 414                 cmd.address = 0x10f;
 415                 cmd.block_mode = 0;
 416                 cmd.increment = 1;
 417                 cmd.count = 4;
 418                 cmd.buffer = (u8 *)&data;
 419                 cmd.block_size = g_sdio.block_size;
 420                 ret = wilc_sdio_cmd53(wilc, &cmd);
 421                 if (ret) {
 422                         dev_err(&func->dev,
 423                                 "Failed cmd53, write reg (%08x)...\n", addr);
 424                         goto fail;
 425                 }
 426         }
 427
 428         return 1;
 429
 430 fail:
 431
 432         return 0;
 433 }
 434
 435 static int sdio_write(struct wilc *wilc, u32 addr, u8 *buf, u32 size)
 436 {
 437         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 438         u32 block_size = g_sdio.block_size;
 439         struct sdio_cmd53 cmd;
 440         int nblk, nleft, ret;
 441
 442         cmd.read_write = 1;
 443         if (addr > 0) {
 444                 /**
 445                  *      has to be word aligned...
 446                  **/
 447                 if (size & 0x3) {
 448                         size += 4;
 449                         size &= ~0x3;
 450                 }
 451
 452                 /**
 453                  *      func 0 access
 454                  **/
 455                 cmd.function = 0;
 456                 cmd.address = 0x10f;
 457         } else {
 458                 /**
 459                  *      has to be word aligned...
 460                  **/
 461                 if (size & 0x3) {
 462                         size += 4;
 463                         size &= ~0x3;
 464                 }
 465
 466                 /**
 467                  *      func 1 access
 468                  **/
 469                 cmd.function = 1;
 470                 cmd.address = 0;
 471         }
 472
 473         nblk = size / block_size;
 474         nleft = size % block_size;
 475
 476         if (nblk > 0) {
 477                 cmd.block_mode = 1;
 478                 cmd.increment = 1;
 479                 cmd.count = nblk;
 480                 cmd.buffer = buf;
 481                 cmd.block_size = block_size;
 482                 if (addr > 0) {
 483                         if (!sdio_set_func0_csa_address(wilc, addr))
 484                                 goto fail;
 485                 }
 486                 ret = wilc_sdio_cmd53(wilc, &cmd);
 487                 if (ret) {
 488                         dev_err(&func->dev,
 489                                 "Failed cmd53 [%x], block send...\n", addr);
 490                         goto fail;
 491                 }
 492                 if (addr > 0)
 493                         addr += nblk * block_size;
 494                 buf += nblk * block_size;
 495         }
 496
 497         if (nleft > 0) {
 498                 cmd.block_mode = 0;
 499                 cmd.increment = 1;
 500                 cmd.count = nleft;
 501                 cmd.buffer = buf;
 502
 503                 cmd.block_size = block_size;
 504
 505                 if (addr > 0) {
 506                         if (!sdio_set_func0_csa_address(wilc, addr))
 507                                 goto fail;
 508                 }
 509                 ret = wilc_sdio_cmd53(wilc, &cmd);
 510                 if (ret) {
 511                         dev_err(&func->dev,
 512                                 "Failed cmd53 [%x], bytes send...\n", addr);
 513                         goto fail;
 514                 }
 515         }
 516
 517         return 1;
 518
 519 fail:
 520
 521         return 0;
 522 }
 523
 524 static int sdio_read_reg(struct wilc *wilc, u32 addr, u32 *data)
 525 {
 526         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 527         int ret;
 528
 529         if (addr >= 0xf0 && addr <= 0xff) {
 530                 struct sdio_cmd52 cmd;
 531
 532                 cmd.read_write = 0;
 533                 cmd.function = 0;
 534                 cmd.raw = 0;
 535                 cmd.address = addr;
 536                 ret = wilc_sdio_cmd52(wilc, &cmd);
 537                 if (ret) {
 538                         dev_err(&func->dev,
 539                                 "Failed cmd 52, read reg (%08x) ...\n", addr);
 540                         goto fail;
 541                 }
 542                 *data = cmd.data;
 543         } else {
 544                 struct sdio_cmd53 cmd;
 545
 546                 if (!sdio_set_func0_csa_address(wilc, addr))
 547                         goto fail;
 548
 549                 cmd.read_write = 0;
 550                 cmd.function = 0;
 551                 cmd.address = 0x10f;
 552                 cmd.block_mode = 0;
 553                 cmd.increment = 1;
 554                 cmd.count = 4;
 555                 cmd.buffer = (u8 *)data;
 556
 557                 cmd.block_size = g_sdio.block_size;
 558                 ret = wilc_sdio_cmd53(wilc, &cmd);
 559                 if (ret) {
 560                         dev_err(&func->dev,
 561                                 "Failed cmd53, read reg (%08x)...\n", addr);
 562                         goto fail;
 563                 }
 564         }
 565
 566         le32_to_cpus(data);
 567
 568         return 1;
 569
 570 fail:
 571
 572         return 0;
 573 }
 574
 575 static int sdio_read(struct wilc *wilc, u32 addr, u8 *buf, u32 size)
 576 {
 577         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 578         u32 block_size = g_sdio.block_size;
 579         struct sdio_cmd53 cmd;
 580         int nblk, nleft, ret;
 581
 582         cmd.read_write = 0;
 583         if (addr > 0) {
 584                 /**
 585                  *      has to be word aligned...
 586                  **/
 587                 if (size & 0x3) {
 588                         size += 4;
 589                         size &= ~0x3;
 590                 }
 591
 592                 /**
 593                  *      func 0 access
 594                  **/
 595                 cmd.function = 0;
 596                 cmd.address = 0x10f;
 597         } else {
 598                 /**
 599                  *      has to be word aligned...
 600                  **/
 601                 if (size & 0x3) {
 602                         size += 4;
 603                         size &= ~0x3;
 604                 }
 605
 606                 /**
 607                  *      func 1 access
 608                  **/
 609                 cmd.function = 1;
 610                 cmd.address = 0;
 611         }
 612
 613         nblk = size / block_size;
 614         nleft = size % block_size;
 615
 616         if (nblk > 0) {
 617                 cmd.block_mode = 1;
 618                 cmd.increment = 1;
 619                 cmd.count = nblk;
 620                 cmd.buffer = buf;
 621                 cmd.block_size = block_size;
 622                 if (addr > 0) {
 623                         if (!sdio_set_func0_csa_address(wilc, addr))
 624                                 goto fail;
 625                 }
 626                 ret = wilc_sdio_cmd53(wilc, &cmd);
 627                 if (ret) {
 628                         dev_err(&func->dev,
 629                                 "Failed cmd53 [%x], block read...\n", addr);
 630                         goto fail;
 631                 }
 632                 if (addr > 0)
 633                         addr += nblk * block_size;
 634                 buf += nblk * block_size;
 635         }       /* if (nblk > 0) */
 636
 637         if (nleft > 0) {
 638                 cmd.block_mode = 0;
 639                 cmd.increment = 1;
 640                 cmd.count = nleft;
 641                 cmd.buffer = buf;
 642
 643                 cmd.block_size = block_size;
 644
 645                 if (addr > 0) {
 646                         if (!sdio_set_func0_csa_address(wilc, addr))
 647                                 goto fail;
 648                 }
 649                 ret = wilc_sdio_cmd53(wilc, &cmd);
 650                 if (ret) {
 651                         dev_err(&func->dev,
 652                                 "Failed cmd53 [%x], bytes read...\n", addr);
 653                         goto fail;
 654                 }
 655         }
 656
 657         return 1;
 658
 659 fail:
 660
 661         return 0;
 662 }
 663
 664 /********************************************
 665  *
 666  *      Bus interfaces
 667  *
 668  ********************************************/
 669
 670 static int sdio_deinit(struct wilc *wilc)
 671 {
 672         return 1;
 673 }
 674
 675 static int sdio_init(struct wilc *wilc, bool resume)
 676 {
 677         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 678         struct sdio_cmd52 cmd;
 679         int loop, ret;
 680         u32 chipid;
 681
 682         if (!resume) {
 683                 memset(&g_sdio, 0, sizeof(struct wilc_sdio));
 684                 g_sdio.irq_gpio = wilc->dev_irq_num;
 685         }
 686
 687         /**
 688          *      function 0 csa enable
 689          **/
 690         cmd.read_write = 1;
 691         cmd.function = 0;
 692         cmd.raw = 1;
 693         cmd.address = 0x100;
 694         cmd.data = 0x80;
 695         ret = wilc_sdio_cmd52(wilc, &cmd);
 696         if (ret) {
 697                 dev_err(&func->dev, "Fail cmd 52, enable csa...\n");
 698                 goto fail;
 699         }
 700
 701         /**
 702          *      function 0 block size
 703          **/
 704         if (!sdio_set_func0_block_size(wilc, WILC_SDIO_BLOCK_SIZE)) {
 705                 dev_err(&func->dev, "Fail cmd 52, set func 0 block size...\n");
 706                 goto fail;
 707         }
 708         g_sdio.block_size = WILC_SDIO_BLOCK_SIZE;
 709
 710         /**
 711          *      enable func1 IO
 712          **/
 713         cmd.read_write = 1;
 714         cmd.function = 0;
 715         cmd.raw = 1;
 716         cmd.address = 0x2;
 717         cmd.data = 0x2;
 718         ret = wilc_sdio_cmd52(wilc, &cmd);
 719         if (ret) {
 720                 dev_err(&func->dev,
 721                         "Fail cmd 52, set IOE register...\n");
 722                 goto fail;
 723         }
 724
 725         /**
 726          *      make sure func 1 is up
 727          **/
 728         cmd.read_write = 0;
 729         cmd.function = 0;
 730         cmd.raw = 0;
 731         cmd.address = 0x3;
 732         loop = 3;
 733         do {
 734                 cmd.data = 0;
 735                 ret = wilc_sdio_cmd52(wilc, &cmd);
 736                 if (ret) {
 737                         dev_err(&func->dev,
 738                                 "Fail cmd 52, get IOR register...\n");
 739                         goto fail;
 740                 }
 741                 if (cmd.data == 0x2)
 742                         break;
 743         } while (loop--);
 744
 745         if (loop <= 0) {
 746                 dev_err(&func->dev, "Fail func 1 is not ready...\n");
 747                 goto fail;
 748         }
 749
 750         /**
 751          *      func 1 is ready, set func 1 block size
 752          **/
 753         if (!sdio_set_func1_block_size(wilc, WILC_SDIO_BLOCK_SIZE)) {
 754                 dev_err(&func->dev, "Fail set func 1 block size...\n");
 755                 goto fail;
 756         }
 757
 758         /**
 759          *      func 1 interrupt enable
 760          **/
 761         cmd.read_write = 1;
 762         cmd.function = 0;
 763         cmd.raw = 1;
 764         cmd.address = 0x4;
 765         cmd.data = 0x3;
 766         ret = wilc_sdio_cmd52(wilc, &cmd);
 767         if (ret) {
 768                 dev_err(&func->dev, "Fail cmd 52, set IEN register...\n");
 769                 goto fail;
 770         }
 771
 772         /**
 773          *      make sure can read back chip id correctly
 774          **/
 775         if (!resume) {
 776                 if (!sdio_read_reg(wilc, 0x1000, &chipid)) {
 777                         dev_err(&func->dev, "Fail cmd read chip id...\n");
 778                         goto fail;
 779                 }
 780                 dev_err(&func->dev, "chipid (%08x)\n", chipid);
 781                 if ((chipid & 0xfff) > 0x2a0)
 782                         g_sdio.has_thrpt_enh3 = 1;
 783                 else
 784                         g_sdio.has_thrpt_enh3 = 0;
 785                 dev_info(&func->dev, "has_thrpt_enh3 = %d...\n",
 786                          g_sdio.has_thrpt_enh3);
 787         }
 788
 789         return 1;
 790
 791 fail:
 792
 793         return 0;
 794 }
 795
 796 static int sdio_read_size(struct wilc *wilc, u32 *size)
 797 {
 798         u32 tmp;
 799         struct sdio_cmd52 cmd;
 800
 801         /**
 802          *      Read DMA count in words
 803          **/
 804         cmd.read_write = 0;
 805         cmd.function = 0;
 806         cmd.raw = 0;
 807         cmd.address = 0xf2;
 808         cmd.data = 0;
 809         wilc_sdio_cmd52(wilc, &cmd);
 810         tmp = cmd.data;
 811
 812         cmd.address = 0xf3;
 813         cmd.data = 0;
 814         wilc_sdio_cmd52(wilc, &cmd);
 815         tmp |= (cmd.data << 8);
 816
 817         *size = tmp;
 818         return 1;
 819 }
 820
 821 static int sdio_read_int(struct wilc *wilc, u32 *int_status)
 822 {
 823         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 824         u32 tmp;
 825         struct sdio_cmd52 cmd;
 826
 827         sdio_read_size(wilc, &tmp);
 828
 829         /**
 830          *      Read IRQ flags
 831          **/
 832         if (!g_sdio.irq_gpio) {
 833                 int i;
 834
 835                 cmd.read_write = 0;
 836                 cmd.function = 1;
 837                 cmd.address = 0x04;
 838                 cmd.data = 0;
 839                 wilc_sdio_cmd52(wilc, &cmd);
 840
 841                 if (cmd.data & BIT(0))
 842                         tmp |= INT_0;
 843                 if (cmd.data & BIT(2))
 844                         tmp |= INT_1;
 845                 if (cmd.data & BIT(3))
 846                         tmp |= INT_2;
 847                 if (cmd.data & BIT(4))
 848                         tmp |= INT_3;
 849                 if (cmd.data & BIT(5))
 850                         tmp |= INT_4;
 851                 if (cmd.data & BIT(6))
 852                         tmp |= INT_5;
 853                 for (i = g_sdio.nint; i < MAX_NUM_INT; i++) {
 854                         if ((tmp >> (IRG_FLAGS_OFFSET + i)) & 0x1) {
 855                                 dev_err(&func->dev,
 856                                         "Unexpected interrupt (1) : tmp=%x, data=%x\n",
 857                                         tmp, cmd.data);
 858                                 break;
 859                         }
 860                 }
 861         } else {
 862                 u32 irq_flags;
 863
 864                 cmd.read_write = 0;
 865                 cmd.function = 0;
 866                 cmd.raw = 0;
 867                 cmd.address = 0xf7;
 868                 cmd.data = 0;
 869                 wilc_sdio_cmd52(wilc, &cmd);
 870                 irq_flags = cmd.data & 0x1f;
 871                 tmp |= ((irq_flags >> 0) << IRG_FLAGS_OFFSET);
 872         }
 873
 874         *int_status = tmp;
 875
 876         return 1;
 877 }
 878
 879 static int sdio_clear_int_ext(struct wilc *wilc, u32 val)
 880 {
 881         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 882         int ret;
 883         int vmm_ctl;
 884
 885         if (g_sdio.has_thrpt_enh3) {
 886                 u32 reg;
 887
 888                 if (g_sdio.irq_gpio) {
 889                         u32 flags;
 890
 891                         flags = val & (BIT(MAX_NUN_INT_THRPT_ENH2) - 1);
 892                         reg = flags;
 893                 } else {
 894                         reg = 0;
 895                 }
 896                 /* select VMM table 0 */
 897                 if (val & SEL_VMM_TBL0)
 898                         reg |= BIT(5);
 899                 /* select VMM table 1 */
 900                 if (val & SEL_VMM_TBL1)
 901                         reg |= BIT(6);
 902                 /* enable VMM */
 903                 if (val & EN_VMM)
 904                         reg |= BIT(7);
 905                 if (reg) {
 906                         struct sdio_cmd52 cmd;
 907
 908                         cmd.read_write = 1;
 909                         cmd.function = 0;
 910                         cmd.raw = 0;
 911                         cmd.address = 0xf8;
 912                         cmd.data = reg;
 913
 914                         ret = wilc_sdio_cmd52(wilc, &cmd);
 915                         if (ret) {
 916                                 dev_err(&func->dev,
 917                                         "Failed cmd52, set 0xf8 data (%d) ...\n",
 918                                         __LINE__);
 919                                 goto fail;
 920                         }
 921                 }
 922                 return 1;
 923         }
 924         if (g_sdio.irq_gpio) {
 925                 /* has_thrpt_enh2 uses register 0xf8 to clear interrupts. */
 926                 /*
 927                  * Cannot clear multiple interrupts.
 928                  * Must clear each interrupt individually.
 929                  */
 930                 u32 flags;
 931
 932                 flags = val & (BIT(MAX_NUM_INT) - 1);
 933                 if (flags) {
 934                         int i;
 935
 936                         ret = 1;
 937                         for (i = 0; i < g_sdio.nint; i++) {
 938                                 if (flags & 1) {
 939                                         struct sdio_cmd52 cmd;
 940
 941                                         cmd.read_write = 1;
 942                                         cmd.function = 0;
 943                                         cmd.raw = 0;
 944                                         cmd.address = 0xf8;
 945                                         cmd.data = BIT(i);
 946
 947                                         ret = wilc_sdio_cmd52(wilc, &cmd);
 948                                         if (ret) {
 949                                                 dev_err(&func->dev,
 950                                                         "Failed cmd52, set 0xf8 data (%d) ...\n",
 951                                                         __LINE__);
 952                                                 goto fail;
 953                                         }
 954                                 }
 955                                 if (!ret)
 956                                         break;
 957                                 flags >>= 1;
 958                         }
 959                         if (!ret)
 960                                 goto fail;
 961                         for (i = g_sdio.nint; i < MAX_NUM_INT; i++) {
 962                                 if (flags & 1)
 963                                         dev_err(&func->dev,
 964                                                 "Unexpected interrupt cleared %d...\n",
 965                                                 i);
 966                                 flags >>= 1;
 967                         }
 968                 }
 969         }
 970
 971         vmm_ctl = 0;
 972         /* select VMM table 0 */
 973         if (val & SEL_VMM_TBL0)
 974                 vmm_ctl |= BIT(0);
 975         /* select VMM table 1 */
 976         if (val & SEL_VMM_TBL1)
 977                 vmm_ctl |= BIT(1);
 978         /* enable VMM */
 979         if (val & EN_VMM)
 980                 vmm_ctl |= BIT(2);
 981
 982         if (vmm_ctl) {
 983                 struct sdio_cmd52 cmd;
 984
 985                 cmd.read_write = 1;
 986                 cmd.function = 0;
 987                 cmd.raw = 0;
 988                 cmd.address = 0xf6;
 989                 cmd.data = vmm_ctl;
 990                 ret = wilc_sdio_cmd52(wilc, &cmd);
 991                 if (ret) {
 992                         dev_err(&func->dev,
 993                                 "Failed cmd52, set 0xf6 data (%d) ...\n",
 994                                 __LINE__);
 995                         goto fail;
 996                 }
 997         }
 998         return 1;
 999 fail:
1000         return 0;
1001 }
1002
1003 static int sdio_sync_ext(struct wilc *wilc, int nint)
1004 {
1005         struct sdio_func *func = dev_to_sdio_func(wilc->dev);
1006         u32 reg;
1007
1008         if (nint > MAX_NUM_INT) {
1009                 dev_err(&func->dev, "Too many interrupts (%d)...\n", nint);
1010                 return 0;
1011         }
1012         if (nint > MAX_NUN_INT_THRPT_ENH2) {
1013                 dev_err(&func->dev,
1014                         "Cannot support more than 5 interrupts when has_thrpt_enh2=1.\n");
1015                 return 0;
1016         }
1017
1018         g_sdio.nint = nint;
1019
1020         /**
1021          *      Disable power sequencer
1022          **/
1023         if (!sdio_read_reg(wilc, WILC_MISC, &reg)) {
1024                 dev_err(&func->dev, "Failed read misc reg...\n");
1025                 return 0;
1026         }
1027
1028         reg &= ~BIT(8);
1029         if (!sdio_write_reg(wilc, WILC_MISC, reg)) {
1030                 dev_err(&func->dev, "Failed write misc reg...\n");
1031                 return 0;
1032         }
1033
1034         if (g_sdio.irq_gpio) {
1035                 u32 reg;
1036                 int ret, i;
1037
1038                 /**
1039                  *      interrupt pin mux select
1040                  **/
1041                 ret = sdio_read_reg(wilc, WILC_PIN_MUX_0, &reg);
1042                 if (!ret) {
1043                         dev_err(&func->dev, "Failed read reg (%08x)...\n",
1044                                 WILC_PIN_MUX_0);
1045                         return 0;
1046                 }
1047                 reg |= BIT(8);
1048                 ret = sdio_write_reg(wilc, WILC_PIN_MUX_0, reg);
1049                 if (!ret) {
1050                         dev_err(&func->dev, "Failed write reg (%08x)...\n",
1051                                 WILC_PIN_MUX_0);
1052                         return 0;
1053                 }
1054
1055                 /**
1056                  *      interrupt enable
1057                  **/
1058                 ret = sdio_read_reg(wilc, WILC_INTR_ENABLE, &reg);
1059                 if (!ret) {
1060                         dev_err(&func->dev, "Failed read reg (%08x)...\n",
1061                                 WILC_INTR_ENABLE);
1062                         return 0;
1063                 }
1064
1065                 for (i = 0; (i < 5) && (nint > 0); i++, nint--)
1066                         reg |= BIT((27 + i));
1067                 ret = sdio_write_reg(wilc, WILC_INTR_ENABLE, reg);
1068                 if (!ret) {
1069                         dev_err(&func->dev, "Failed write reg (%08x)...\n",
1070                                 WILC_INTR_ENABLE);
1071                         return 0;
1072                 }
1073                 if (nint) {
1074                         ret = sdio_read_reg(wilc, WILC_INTR2_ENABLE, &reg);
1075                         if (!ret) {
1076                                 dev_err(&func->dev,
1077                                         "Failed read reg (%08x)...\n",
1078                                         WILC_INTR2_ENABLE);
1079                                 return 0;
1080                         }
1081
1082                         for (i = 0; (i < 3) && (nint > 0); i++, nint--)
1083                                 reg |= BIT(i);
1084
1085                         ret = sdio_read_reg(wilc, WILC_INTR2_ENABLE, &reg);
1086                         if (!ret) {
1087                                 dev_err(&func->dev,
1088                                         "Failed write reg (%08x)...\n",
1089                                         WILC_INTR2_ENABLE);
1090                                 return 0;
1091                         }
1092                 }
1093         }
1094         return 1;
1095 }
1096
1097 /* Global sdio HIF function table */
1098 static const struct wilc_hif_func wilc_hif_sdio = {
1099         .hif_init = sdio_init,
1100         .hif_deinit = sdio_deinit,
1101         .hif_read_reg = sdio_read_reg,
1102         .hif_write_reg = sdio_write_reg,
1103         .hif_block_rx = sdio_read,
1104         .hif_block_tx = sdio_write,
1105         .hif_read_int = sdio_read_int,
1106         .hif_clear_int_ext = sdio_clear_int_ext,
1107         .hif_read_size = sdio_read_size,
1108         .hif_block_tx_ext = sdio_write,
1109         .hif_block_rx_ext = sdio_read,
1110         .hif_sync_ext = sdio_sync_ext,
1111         .enable_interrupt = wilc_sdio_enable_interrupt,
1112         .disable_interrupt = wilc_sdio_disable_interrupt,
1113 };
1114