1 /** 2 * Copyright (c) 2014 Redpine Signals Inc. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 * 16 */ 17 18 #include <linux/module.h> 19 #include "rsi_sdio.h" 20 #include "rsi_common.h" 21 #include "rsi_coex.h" 22 #include "rsi_hal.h" 23 24 /* Default operating mode is wlan STA + BT */ 25 static u16 dev_oper_mode = DEV_OPMODE_STA_BT_DUAL; 26 module_param(dev_oper_mode, ushort, 0444); 27 MODULE_PARM_DESC(dev_oper_mode, 28 "1[Wi-Fi], 4[BT], 8[BT LE], 5[Wi-Fi STA + BT classic]\n" 29 "9[Wi-Fi STA + BT LE], 13[Wi-Fi STA + BT classic + BT LE]\n" 30 "6[AP + BT classic], 14[AP + BT classic + BT LE]"); 31 32 /** 33 * rsi_sdio_set_cmd52_arg() - This function prepares cmd 52 read/write arg. 34 * @rw: Read/write 35 * @func: function number 36 * @raw: indicates whether to perform read after write 37 * @address: address to which to read/write 38 * @writedata: data to write 39 * 40 * Return: argument 41 */ 42 static u32 rsi_sdio_set_cmd52_arg(bool rw, 43 u8 func, 44 u8 raw, 45 u32 address, 46 u8 writedata) 47 { 48 return ((rw & 1) << 31) | ((func & 0x7) << 28) | 49 ((raw & 1) << 27) | (1 << 26) | 50 ((address & 0x1FFFF) << 9) | (1 << 8) | 51 (writedata & 0xFF); 52 } 53 54 /** 55 * rsi_cmd52writebyte() - This function issues cmd52 byte write onto the card. 56 * @card: Pointer to the mmc_card. 57 * @address: Address to write. 58 * @byte: Data to write. 59 * 60 * Return: Write status. 61 */ 62 static int rsi_cmd52writebyte(struct mmc_card *card, 63 u32 address, 64 u8 byte) 65 { 66 struct mmc_command io_cmd; 67 u32 arg; 68 69 memset(&io_cmd, 0, sizeof(io_cmd)); 70 arg = rsi_sdio_set_cmd52_arg(1, 0, 0, address, byte); 71 io_cmd.opcode = SD_IO_RW_DIRECT; 72 io_cmd.arg = arg; 73 io_cmd.flags = MMC_RSP_R5 | MMC_CMD_AC; 74 75 return mmc_wait_for_cmd(card->host, &io_cmd, 0); 76 } 77 78 /** 79 * rsi_cmd52readbyte() - This function issues cmd52 byte read onto the card. 80 * @card: Pointer to the mmc_card. 81 * @address: Address to read from. 82 * @byte: Variable to store read value. 83 * 84 * Return: Read status. 85 */ 86 static int rsi_cmd52readbyte(struct mmc_card *card, 87 u32 address, 88 u8 *byte) 89 { 90 struct mmc_command io_cmd; 91 u32 arg; 92 int err; 93 94 memset(&io_cmd, 0, sizeof(io_cmd)); 95 arg = rsi_sdio_set_cmd52_arg(0, 0, 0, address, 0); 96 io_cmd.opcode = SD_IO_RW_DIRECT; 97 io_cmd.arg = arg; 98 io_cmd.flags = MMC_RSP_R5 | MMC_CMD_AC; 99 100 err = mmc_wait_for_cmd(card->host, &io_cmd, 0); 101 if ((!err) && (byte)) 102 *byte = io_cmd.resp[0] & 0xFF; 103 return err; 104 } 105 106 /** 107 * rsi_issue_sdiocommand() - This function issues sdio commands. 108 * @func: Pointer to the sdio_func structure. 109 * @opcode: Opcode value. 110 * @arg: Arguments to pass. 111 * @flags: Flags which are set. 112 * @resp: Pointer to store response. 113 * 114 * Return: err: command status as 0 or -1. 115 */ 116 static int rsi_issue_sdiocommand(struct sdio_func *func, 117 u32 opcode, 118 u32 arg, 119 u32 flags, 120 u32 *resp) 121 { 122 struct mmc_command cmd; 123 struct mmc_host *host; 124 int err; 125 126 host = func->card->host; 127 128 memset(&cmd, 0, sizeof(struct mmc_command)); 129 cmd.opcode = opcode; 130 cmd.arg = arg; 131 cmd.flags = flags; 132 err = mmc_wait_for_cmd(host, &cmd, 3); 133 134 if ((!err) && (resp)) 135 *resp = cmd.resp[0]; 136 137 return err; 138 } 139 140 /** 141 * rsi_handle_interrupt() - This function is called upon the occurrence 142 * of an interrupt. 143 * @function: Pointer to the sdio_func structure. 144 * 145 * Return: None. 146 */ 147 static void rsi_handle_interrupt(struct sdio_func *function) 148 { 149 struct rsi_hw *adapter = sdio_get_drvdata(function); 150 struct rsi_91x_sdiodev *dev = 151 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 152 153 if (adapter->priv->fsm_state == FSM_FW_NOT_LOADED) 154 return; 155 156 dev->sdio_irq_task = current; 157 rsi_interrupt_handler(adapter); 158 dev->sdio_irq_task = NULL; 159 } 160 161 /** 162 * rsi_reset_card() - This function resets and re-initializes the card. 163 * @pfunction: Pointer to the sdio_func structure. 164 * 165 * Return: None. 166 */ 167 static void rsi_reset_card(struct sdio_func *pfunction) 168 { 169 int ret = 0; 170 int err; 171 struct mmc_card *card = pfunction->card; 172 struct mmc_host *host = card->host; 173 u8 cmd52_resp; 174 u32 clock, resp, i; 175 u16 rca; 176 177 /* Reset 9110 chip */ 178 ret = rsi_cmd52writebyte(pfunction->card, 179 SDIO_CCCR_ABORT, 180 (1 << 3)); 181 182 /* Card will not send any response as it is getting reset immediately 183 * Hence expect a timeout status from host controller 184 */ 185 if (ret != -ETIMEDOUT) 186 rsi_dbg(ERR_ZONE, "%s: Reset failed : %d\n", __func__, ret); 187 188 /* Wait for few milli seconds to get rid of residue charges if any */ 189 msleep(20); 190 191 /* Initialize the SDIO card */ 192 host->ios.chip_select = MMC_CS_DONTCARE; 193 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; 194 host->ios.power_mode = MMC_POWER_UP; 195 host->ios.bus_width = MMC_BUS_WIDTH_1; 196 host->ios.timing = MMC_TIMING_LEGACY; 197 host->ops->set_ios(host, &host->ios); 198 199 /* 200 * This delay should be sufficient to allow the power supply 201 * to reach the minimum voltage. 202 */ 203 msleep(20); 204 205 host->ios.clock = host->f_min; 206 host->ios.power_mode = MMC_POWER_ON; 207 host->ops->set_ios(host, &host->ios); 208 209 /* 210 * This delay must be at least 74 clock sizes, or 1 ms, or the 211 * time required to reach a stable voltage. 212 */ 213 msleep(20); 214 215 /* Issue CMD0. Goto idle state */ 216 host->ios.chip_select = MMC_CS_HIGH; 217 host->ops->set_ios(host, &host->ios); 218 msleep(20); 219 err = rsi_issue_sdiocommand(pfunction, 220 MMC_GO_IDLE_STATE, 221 0, 222 (MMC_RSP_NONE | MMC_CMD_BC), 223 NULL); 224 host->ios.chip_select = MMC_CS_DONTCARE; 225 host->ops->set_ios(host, &host->ios); 226 msleep(20); 227 host->use_spi_crc = 0; 228 229 if (err) 230 rsi_dbg(ERR_ZONE, "%s: CMD0 failed : %d\n", __func__, err); 231 232 /* Issue CMD5, arg = 0 */ 233 if (!host->ocr_avail) { 234 err = rsi_issue_sdiocommand(pfunction, SD_IO_SEND_OP_COND, 0, 235 (MMC_RSP_R4 | MMC_CMD_BCR), &resp); 236 if (err) 237 rsi_dbg(ERR_ZONE, "%s: CMD5 failed : %d\n", 238 __func__, err); 239 240 host->ocr_avail = resp; 241 } 242 /* Issue CMD5, arg = ocr. Wait till card is ready */ 243 for (i = 0; i < 100; i++) { 244 err = rsi_issue_sdiocommand(pfunction, SD_IO_SEND_OP_COND, 245 host->ocr_avail, 246 (MMC_RSP_R4 | MMC_CMD_BCR), &resp); 247 if (err) { 248 rsi_dbg(ERR_ZONE, "%s: CMD5 failed : %d\n", 249 __func__, err); 250 break; 251 } 252 253 if (resp & MMC_CARD_BUSY) 254 break; 255 msleep(20); 256 } 257 258 if ((i == 100) || (err)) { 259 rsi_dbg(ERR_ZONE, "%s: card in not ready : %d %d\n", 260 __func__, i, err); 261 return; 262 } 263 264 /* Issue CMD3, get RCA */ 265 err = rsi_issue_sdiocommand(pfunction, 266 SD_SEND_RELATIVE_ADDR, 267 0, 268 (MMC_RSP_R6 | MMC_CMD_BCR), 269 &resp); 270 if (err) { 271 rsi_dbg(ERR_ZONE, "%s: CMD3 failed : %d\n", __func__, err); 272 return; 273 } 274 rca = resp >> 16; 275 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL; 276 host->ops->set_ios(host, &host->ios); 277 278 /* Issue CMD7, select card */ 279 err = rsi_issue_sdiocommand(pfunction, 280 MMC_SELECT_CARD, 281 (rca << 16), 282 (MMC_RSP_R1 | MMC_CMD_AC), 283 NULL); 284 if (err) { 285 rsi_dbg(ERR_ZONE, "%s: CMD7 failed : %d\n", __func__, err); 286 return; 287 } 288 289 /* Enable high speed */ 290 if (card->host->caps & MMC_CAP_SD_HIGHSPEED) { 291 rsi_dbg(ERR_ZONE, "%s: Set high speed mode\n", __func__); 292 err = rsi_cmd52readbyte(card, SDIO_CCCR_SPEED, &cmd52_resp); 293 if (err) { 294 rsi_dbg(ERR_ZONE, "%s: CCCR speed reg read failed: %d\n", 295 __func__, err); 296 } else { 297 err = rsi_cmd52writebyte(card, 298 SDIO_CCCR_SPEED, 299 (cmd52_resp | SDIO_SPEED_EHS)); 300 if (err) { 301 rsi_dbg(ERR_ZONE, 302 "%s: CCR speed regwrite failed %d\n", 303 __func__, err); 304 return; 305 } 306 host->ios.timing = MMC_TIMING_SD_HS; 307 host->ops->set_ios(host, &host->ios); 308 } 309 } 310 311 /* Set clock */ 312 if (mmc_card_hs(card)) 313 clock = 50000000; 314 else 315 clock = card->cis.max_dtr; 316 317 if (clock > host->f_max) 318 clock = host->f_max; 319 320 host->ios.clock = clock; 321 host->ops->set_ios(host, &host->ios); 322 323 if (card->host->caps & MMC_CAP_4_BIT_DATA) { 324 /* CMD52: Set bus width & disable card detect resistor */ 325 err = rsi_cmd52writebyte(card, 326 SDIO_CCCR_IF, 327 (SDIO_BUS_CD_DISABLE | 328 SDIO_BUS_WIDTH_4BIT)); 329 if (err) { 330 rsi_dbg(ERR_ZONE, "%s: Set bus mode failed : %d\n", 331 __func__, err); 332 return; 333 } 334 host->ios.bus_width = MMC_BUS_WIDTH_4; 335 host->ops->set_ios(host, &host->ios); 336 } 337 } 338 339 /** 340 * rsi_setclock() - This function sets the clock frequency. 341 * @adapter: Pointer to the adapter structure. 342 * @freq: Clock frequency. 343 * 344 * Return: None. 345 */ 346 static void rsi_setclock(struct rsi_hw *adapter, u32 freq) 347 { 348 struct rsi_91x_sdiodev *dev = 349 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 350 struct mmc_host *host = dev->pfunction->card->host; 351 u32 clock; 352 353 clock = freq * 1000; 354 if (clock > host->f_max) 355 clock = host->f_max; 356 host->ios.clock = clock; 357 host->ops->set_ios(host, &host->ios); 358 } 359 360 /** 361 * rsi_setblocklength() - This function sets the host block length. 362 * @adapter: Pointer to the adapter structure. 363 * @length: Block length to be set. 364 * 365 * Return: status: 0 on success, -1 on failure. 366 */ 367 static int rsi_setblocklength(struct rsi_hw *adapter, u32 length) 368 { 369 struct rsi_91x_sdiodev *dev = 370 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 371 int status; 372 rsi_dbg(INIT_ZONE, "%s: Setting the block length\n", __func__); 373 374 status = sdio_set_block_size(dev->pfunction, length); 375 dev->pfunction->max_blksize = 256; 376 adapter->block_size = dev->pfunction->max_blksize; 377 378 rsi_dbg(INFO_ZONE, 379 "%s: Operational blk length is %d\n", __func__, length); 380 return status; 381 } 382 383 /** 384 * rsi_setupcard() - This function queries and sets the card's features. 385 * @adapter: Pointer to the adapter structure. 386 * 387 * Return: status: 0 on success, -1 on failure. 388 */ 389 static int rsi_setupcard(struct rsi_hw *adapter) 390 { 391 struct rsi_91x_sdiodev *dev = 392 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 393 int status = 0; 394 395 rsi_setclock(adapter, 50000); 396 397 dev->tx_blk_size = 256; 398 status = rsi_setblocklength(adapter, dev->tx_blk_size); 399 if (status) 400 rsi_dbg(ERR_ZONE, 401 "%s: Unable to set block length\n", __func__); 402 return status; 403 } 404 405 /** 406 * rsi_sdio_read_register() - This function reads one byte of information 407 * from a register. 408 * @adapter: Pointer to the adapter structure. 409 * @addr: Address of the register. 410 * @data: Pointer to the data that stores the data read. 411 * 412 * Return: 0 on success, -1 on failure. 413 */ 414 int rsi_sdio_read_register(struct rsi_hw *adapter, 415 u32 addr, 416 u8 *data) 417 { 418 struct rsi_91x_sdiodev *dev = 419 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 420 u8 fun_num = 0; 421 int status; 422 423 if (likely(dev->sdio_irq_task != current)) 424 sdio_claim_host(dev->pfunction); 425 426 if (fun_num == 0) 427 *data = sdio_f0_readb(dev->pfunction, addr, &status); 428 else 429 *data = sdio_readb(dev->pfunction, addr, &status); 430 431 if (likely(dev->sdio_irq_task != current)) 432 sdio_release_host(dev->pfunction); 433 434 return status; 435 } 436 437 /** 438 * rsi_sdio_write_register() - This function writes one byte of information 439 * into a register. 440 * @adapter: Pointer to the adapter structure. 441 * @function: Function Number. 442 * @addr: Address of the register. 443 * @data: Pointer to the data tha has to be written. 444 * 445 * Return: 0 on success, -1 on failure. 446 */ 447 int rsi_sdio_write_register(struct rsi_hw *adapter, 448 u8 function, 449 u32 addr, 450 u8 *data) 451 { 452 struct rsi_91x_sdiodev *dev = 453 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 454 int status = 0; 455 456 if (likely(dev->sdio_irq_task != current)) 457 sdio_claim_host(dev->pfunction); 458 459 if (function == 0) 460 sdio_f0_writeb(dev->pfunction, *data, addr, &status); 461 else 462 sdio_writeb(dev->pfunction, *data, addr, &status); 463 464 if (likely(dev->sdio_irq_task != current)) 465 sdio_release_host(dev->pfunction); 466 467 return status; 468 } 469 470 /** 471 * rsi_sdio_ack_intr() - This function acks the interrupt received. 472 * @adapter: Pointer to the adapter structure. 473 * @int_bit: Interrupt bit to write into register. 474 * 475 * Return: None. 476 */ 477 void rsi_sdio_ack_intr(struct rsi_hw *adapter, u8 int_bit) 478 { 479 int status; 480 status = rsi_sdio_write_register(adapter, 481 1, 482 (SDIO_FUN1_INTR_CLR_REG | 483 RSI_SD_REQUEST_MASTER), 484 &int_bit); 485 if (status) 486 rsi_dbg(ERR_ZONE, "%s: unable to send ack\n", __func__); 487 } 488 489 490 491 /** 492 * rsi_sdio_read_register_multiple() - This function read multiple bytes of 493 * information from the SD card. 494 * @adapter: Pointer to the adapter structure. 495 * @addr: Address of the register. 496 * @count: Number of multiple bytes to be read. 497 * @data: Pointer to the read data. 498 * 499 * Return: 0 on success, -1 on failure. 500 */ 501 static int rsi_sdio_read_register_multiple(struct rsi_hw *adapter, 502 u32 addr, 503 u8 *data, 504 u16 count) 505 { 506 struct rsi_91x_sdiodev *dev = 507 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 508 u32 status; 509 510 if (likely(dev->sdio_irq_task != current)) 511 sdio_claim_host(dev->pfunction); 512 513 status = sdio_readsb(dev->pfunction, data, addr, count); 514 515 if (likely(dev->sdio_irq_task != current)) 516 sdio_release_host(dev->pfunction); 517 518 if (status != 0) 519 rsi_dbg(ERR_ZONE, "%s: Synch Cmd53 read failed\n", __func__); 520 return status; 521 } 522 523 /** 524 * rsi_sdio_write_register_multiple() - This function writes multiple bytes of 525 * information to the SD card. 526 * @adapter: Pointer to the adapter structure. 527 * @addr: Address of the register. 528 * @data: Pointer to the data that has to be written. 529 * @count: Number of multiple bytes to be written. 530 * 531 * Return: 0 on success, -1 on failure. 532 */ 533 int rsi_sdio_write_register_multiple(struct rsi_hw *adapter, 534 u32 addr, 535 u8 *data, 536 u16 count) 537 { 538 struct rsi_91x_sdiodev *dev = 539 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 540 int status; 541 542 if (dev->write_fail > 1) { 543 rsi_dbg(ERR_ZONE, "%s: Stopping card writes\n", __func__); 544 return 0; 545 } else if (dev->write_fail == 1) { 546 /** 547 * Assuming it is a CRC failure, we want to allow another 548 * card write 549 */ 550 rsi_dbg(ERR_ZONE, "%s: Continue card writes\n", __func__); 551 dev->write_fail++; 552 } 553 554 if (likely(dev->sdio_irq_task != current)) 555 sdio_claim_host(dev->pfunction); 556 557 status = sdio_writesb(dev->pfunction, addr, data, count); 558 559 if (likely(dev->sdio_irq_task != current)) 560 sdio_release_host(dev->pfunction); 561 562 if (status) { 563 rsi_dbg(ERR_ZONE, "%s: Synch Cmd53 write failed %d\n", 564 __func__, status); 565 dev->write_fail = 2; 566 } else { 567 memcpy(dev->prev_desc, data, FRAME_DESC_SZ); 568 } 569 return status; 570 } 571 572 static int rsi_sdio_load_data_master_write(struct rsi_hw *adapter, 573 u32 base_address, 574 u32 instructions_sz, 575 u16 block_size, 576 u8 *ta_firmware) 577 { 578 u32 num_blocks, offset, i; 579 u16 msb_address, lsb_address; 580 u8 *temp_buf; 581 int status; 582 583 num_blocks = instructions_sz / block_size; 584 msb_address = base_address >> 16; 585 586 rsi_dbg(INFO_ZONE, "ins_size: %d, num_blocks: %d\n", 587 instructions_sz, num_blocks); 588 589 temp_buf = kmalloc(block_size, GFP_KERNEL); 590 if (!temp_buf) 591 return -ENOMEM; 592 593 /* Loading DM ms word in the sdio slave */ 594 status = rsi_sdio_master_access_msword(adapter, msb_address); 595 if (status < 0) { 596 rsi_dbg(ERR_ZONE, "%s: Unable to set ms word reg\n", __func__); 597 goto out_free; 598 } 599 600 for (offset = 0, i = 0; i < num_blocks; i++, offset += block_size) { 601 memcpy(temp_buf, ta_firmware + offset, block_size); 602 lsb_address = (u16)base_address; 603 status = rsi_sdio_write_register_multiple 604 (adapter, 605 lsb_address | RSI_SD_REQUEST_MASTER, 606 temp_buf, block_size); 607 if (status < 0) { 608 rsi_dbg(ERR_ZONE, "%s: failed to write\n", __func__); 609 goto out_free; 610 } 611 rsi_dbg(INFO_ZONE, "%s: loading block: %d\n", __func__, i); 612 base_address += block_size; 613 614 if ((base_address >> 16) != msb_address) { 615 msb_address += 1; 616 617 /* Loading DM ms word in the sdio slave */ 618 status = rsi_sdio_master_access_msword(adapter, 619 msb_address); 620 if (status < 0) { 621 rsi_dbg(ERR_ZONE, 622 "%s: Unable to set ms word reg\n", 623 __func__); 624 goto out_free; 625 } 626 } 627 } 628 629 if (instructions_sz % block_size) { 630 memset(temp_buf, 0, block_size); 631 memcpy(temp_buf, ta_firmware + offset, 632 instructions_sz % block_size); 633 lsb_address = (u16)base_address; 634 status = rsi_sdio_write_register_multiple 635 (adapter, 636 lsb_address | RSI_SD_REQUEST_MASTER, 637 temp_buf, 638 instructions_sz % block_size); 639 if (status < 0) 640 goto out_free; 641 rsi_dbg(INFO_ZONE, 642 "Written Last Block in Address 0x%x Successfully\n", 643 offset | RSI_SD_REQUEST_MASTER); 644 } 645 646 status = 0; 647 out_free: 648 kfree(temp_buf); 649 return status; 650 } 651 652 #define FLASH_SIZE_ADDR 0x04000016 653 static int rsi_sdio_master_reg_read(struct rsi_hw *adapter, u32 addr, 654 u32 *read_buf, u16 size) 655 { 656 u32 addr_on_bus, *data; 657 u16 ms_addr; 658 int status; 659 660 data = kzalloc(RSI_MASTER_REG_BUF_SIZE, GFP_KERNEL); 661 if (!data) 662 return -ENOMEM; 663 664 ms_addr = (addr >> 16); 665 status = rsi_sdio_master_access_msword(adapter, ms_addr); 666 if (status < 0) { 667 rsi_dbg(ERR_ZONE, 668 "%s: Unable to set ms word to common reg\n", 669 __func__); 670 goto err; 671 } 672 addr &= 0xFFFF; 673 674 addr_on_bus = (addr & 0xFF000000); 675 if ((addr_on_bus == (FLASH_SIZE_ADDR & 0xFF000000)) || 676 (addr_on_bus == 0x0)) 677 addr_on_bus = (addr & ~(0x3)); 678 else 679 addr_on_bus = addr; 680 681 /* Bring TA out of reset */ 682 status = rsi_sdio_read_register_multiple 683 (adapter, 684 (addr_on_bus | RSI_SD_REQUEST_MASTER), 685 (u8 *)data, 4); 686 if (status < 0) { 687 rsi_dbg(ERR_ZONE, "%s: AHB register read failed\n", __func__); 688 goto err; 689 } 690 if (size == 2) { 691 if ((addr & 0x3) == 0) 692 *read_buf = *data; 693 else 694 *read_buf = (*data >> 16); 695 *read_buf = (*read_buf & 0xFFFF); 696 } else if (size == 1) { 697 if ((addr & 0x3) == 0) 698 *read_buf = *data; 699 else if ((addr & 0x3) == 1) 700 *read_buf = (*data >> 8); 701 else if ((addr & 0x3) == 2) 702 *read_buf = (*data >> 16); 703 else 704 *read_buf = (*data >> 24); 705 *read_buf = (*read_buf & 0xFF); 706 } else { 707 *read_buf = *data; 708 } 709 710 err: 711 kfree(data); 712 return status; 713 } 714 715 static int rsi_sdio_master_reg_write(struct rsi_hw *adapter, 716 unsigned long addr, 717 unsigned long data, u16 size) 718 { 719 unsigned long *data_aligned; 720 int status; 721 722 data_aligned = kzalloc(RSI_MASTER_REG_BUF_SIZE, GFP_KERNEL); 723 if (!data_aligned) 724 return -ENOMEM; 725 726 if (size == 2) { 727 *data_aligned = ((data << 16) | (data & 0xFFFF)); 728 } else if (size == 1) { 729 u32 temp_data = data & 0xFF; 730 731 *data_aligned = ((temp_data << 24) | (temp_data << 16) | 732 (temp_data << 8) | temp_data); 733 } else { 734 *data_aligned = data; 735 } 736 size = 4; 737 738 status = rsi_sdio_master_access_msword(adapter, (addr >> 16)); 739 if (status < 0) { 740 rsi_dbg(ERR_ZONE, 741 "%s: Unable to set ms word to common reg\n", 742 __func__); 743 kfree(data_aligned); 744 return -EIO; 745 } 746 addr = addr & 0xFFFF; 747 748 /* Bring TA out of reset */ 749 status = rsi_sdio_write_register_multiple 750 (adapter, 751 (addr | RSI_SD_REQUEST_MASTER), 752 (u8 *)data_aligned, size); 753 if (status < 0) 754 rsi_dbg(ERR_ZONE, 755 "%s: Unable to do AHB reg write\n", __func__); 756 757 kfree(data_aligned); 758 return status; 759 } 760 761 /** 762 * rsi_sdio_host_intf_write_pkt() - This function writes the packet to device. 763 * @adapter: Pointer to the adapter structure. 764 * @pkt: Pointer to the data to be written on to the device. 765 * @len: length of the data to be written on to the device. 766 * 767 * Return: 0 on success, -1 on failure. 768 */ 769 static int rsi_sdio_host_intf_write_pkt(struct rsi_hw *adapter, 770 u8 *pkt, 771 u32 len) 772 { 773 struct rsi_91x_sdiodev *dev = 774 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 775 u32 block_size = dev->tx_blk_size; 776 u32 num_blocks, address, length; 777 u32 queueno; 778 int status; 779 780 queueno = ((pkt[1] >> 4) & 0xf); 781 if (queueno == RSI_BT_MGMT_Q || queueno == RSI_BT_DATA_Q) 782 queueno = RSI_BT_Q; 783 784 num_blocks = len / block_size; 785 786 if (len % block_size) 787 num_blocks++; 788 789 address = (num_blocks * block_size | (queueno << 12)); 790 length = num_blocks * block_size; 791 792 status = rsi_sdio_write_register_multiple(adapter, 793 address, 794 (u8 *)pkt, 795 length); 796 if (status) 797 rsi_dbg(ERR_ZONE, "%s: Unable to write onto the card: %d\n", 798 __func__, status); 799 rsi_dbg(DATA_TX_ZONE, "%s: Successfully written onto card\n", __func__); 800 return status; 801 } 802 803 /** 804 * rsi_sdio_host_intf_read_pkt() - This function reads the packet 805 from the device. 806 * @adapter: Pointer to the adapter data structure. 807 * @pkt: Pointer to the packet data to be read from the the device. 808 * @length: Length of the data to be read from the device. 809 * 810 * Return: 0 on success, -1 on failure. 811 */ 812 int rsi_sdio_host_intf_read_pkt(struct rsi_hw *adapter, 813 u8 *pkt, 814 u32 length) 815 { 816 int status = -EINVAL; 817 818 if (!length) { 819 rsi_dbg(ERR_ZONE, "%s: Pkt size is zero\n", __func__); 820 return status; 821 } 822 823 status = rsi_sdio_read_register_multiple(adapter, 824 length, 825 (u8 *)pkt, 826 length); /*num of bytes*/ 827 828 if (status) 829 rsi_dbg(ERR_ZONE, "%s: Failed to read frame: %d\n", __func__, 830 status); 831 return status; 832 } 833 834 /** 835 * rsi_init_sdio_interface() - This function does init specific to SDIO. 836 * 837 * @adapter: Pointer to the adapter data structure. 838 * @pkt: Pointer to the packet data to be read from the the device. 839 * 840 * Return: 0 on success, -1 on failure. 841 */ 842 843 static int rsi_init_sdio_interface(struct rsi_hw *adapter, 844 struct sdio_func *pfunction) 845 { 846 struct rsi_91x_sdiodev *rsi_91x_dev; 847 int status = -ENOMEM; 848 849 rsi_91x_dev = kzalloc(sizeof(*rsi_91x_dev), GFP_KERNEL); 850 if (!rsi_91x_dev) 851 return status; 852 853 adapter->rsi_dev = rsi_91x_dev; 854 855 sdio_claim_host(pfunction); 856 857 pfunction->enable_timeout = 100; 858 status = sdio_enable_func(pfunction); 859 if (status) { 860 rsi_dbg(ERR_ZONE, "%s: Failed to enable interface\n", __func__); 861 sdio_release_host(pfunction); 862 return status; 863 } 864 865 rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__); 866 867 rsi_91x_dev->pfunction = pfunction; 868 adapter->device = &pfunction->dev; 869 870 sdio_set_drvdata(pfunction, adapter); 871 872 status = rsi_setupcard(adapter); 873 if (status) { 874 rsi_dbg(ERR_ZONE, "%s: Failed to setup card\n", __func__); 875 goto fail; 876 } 877 878 rsi_dbg(INIT_ZONE, "%s: Setup card successfully\n", __func__); 879 880 status = rsi_init_sdio_slave_regs(adapter); 881 if (status) { 882 rsi_dbg(ERR_ZONE, "%s: Failed to init slave regs\n", __func__); 883 goto fail; 884 } 885 sdio_release_host(pfunction); 886 887 adapter->determine_event_timeout = rsi_sdio_determine_event_timeout; 888 adapter->check_hw_queue_status = rsi_sdio_check_buffer_status; 889 890 #ifdef CONFIG_RSI_DEBUGFS 891 adapter->num_debugfs_entries = MAX_DEBUGFS_ENTRIES; 892 #endif 893 return status; 894 fail: 895 sdio_disable_func(pfunction); 896 sdio_release_host(pfunction); 897 return status; 898 } 899 900 static int rsi_sdio_reinit_device(struct rsi_hw *adapter) 901 { 902 struct rsi_91x_sdiodev *sdev = adapter->rsi_dev; 903 struct sdio_func *pfunction = sdev->pfunction; 904 int ii; 905 906 for (ii = 0; ii < NUM_SOFT_QUEUES; ii++) 907 skb_queue_purge(&adapter->priv->tx_queue[ii]); 908 909 /* Initialize device again */ 910 sdio_claim_host(pfunction); 911 912 sdio_release_irq(pfunction); 913 rsi_reset_card(pfunction); 914 915 sdio_enable_func(pfunction); 916 rsi_setupcard(adapter); 917 rsi_init_sdio_slave_regs(adapter); 918 sdio_claim_irq(pfunction, rsi_handle_interrupt); 919 rsi_hal_device_init(adapter); 920 921 sdio_release_host(pfunction); 922 923 return 0; 924 } 925 926 static struct rsi_host_intf_ops sdio_host_intf_ops = { 927 .write_pkt = rsi_sdio_host_intf_write_pkt, 928 .read_pkt = rsi_sdio_host_intf_read_pkt, 929 .master_access_msword = rsi_sdio_master_access_msword, 930 .read_reg_multiple = rsi_sdio_read_register_multiple, 931 .write_reg_multiple = rsi_sdio_write_register_multiple, 932 .master_reg_read = rsi_sdio_master_reg_read, 933 .master_reg_write = rsi_sdio_master_reg_write, 934 .load_data_master_write = rsi_sdio_load_data_master_write, 935 .reinit_device = rsi_sdio_reinit_device, 936 }; 937 938 /** 939 * rsi_probe() - This function is called by kernel when the driver provided 940 * Vendor and device IDs are matched. All the initialization 941 * work is done here. 942 * @pfunction: Pointer to the sdio_func structure. 943 * @id: Pointer to sdio_device_id structure. 944 * 945 * Return: 0 on success, 1 on failure. 946 */ 947 static int rsi_probe(struct sdio_func *pfunction, 948 const struct sdio_device_id *id) 949 { 950 struct rsi_hw *adapter; 951 struct rsi_91x_sdiodev *sdev; 952 int status; 953 954 rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__); 955 956 adapter = rsi_91x_init(dev_oper_mode); 957 if (!adapter) { 958 rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n", 959 __func__); 960 return -EINVAL; 961 } 962 adapter->rsi_host_intf = RSI_HOST_INTF_SDIO; 963 adapter->host_intf_ops = &sdio_host_intf_ops; 964 965 if (rsi_init_sdio_interface(adapter, pfunction)) { 966 rsi_dbg(ERR_ZONE, "%s: Failed to init sdio interface\n", 967 __func__); 968 status = -EIO; 969 goto fail_free_adapter; 970 } 971 sdev = (struct rsi_91x_sdiodev *)adapter->rsi_dev; 972 rsi_init_event(&sdev->rx_thread.event); 973 status = rsi_create_kthread(adapter->priv, &sdev->rx_thread, 974 rsi_sdio_rx_thread, "SDIO-RX-Thread"); 975 if (status) { 976 rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__); 977 goto fail_kill_thread; 978 } 979 skb_queue_head_init(&sdev->rx_q.head); 980 sdev->rx_q.num_rx_pkts = 0; 981 982 sdio_claim_host(pfunction); 983 if (sdio_claim_irq(pfunction, rsi_handle_interrupt)) { 984 rsi_dbg(ERR_ZONE, "%s: Failed to request IRQ\n", __func__); 985 sdio_release_host(pfunction); 986 status = -EIO; 987 goto fail_claim_irq; 988 } 989 sdio_release_host(pfunction); 990 rsi_dbg(INIT_ZONE, "%s: Registered Interrupt handler\n", __func__); 991 992 if (rsi_hal_device_init(adapter)) { 993 rsi_dbg(ERR_ZONE, "%s: Failed in device init\n", __func__); 994 status = -EINVAL; 995 goto fail_dev_init; 996 } 997 rsi_dbg(INFO_ZONE, "===> RSI Device Init Done <===\n"); 998 999 if (rsi_sdio_master_access_msword(adapter, MISC_CFG_BASE_ADDR)) { 1000 rsi_dbg(ERR_ZONE, "%s: Unable to set ms word reg\n", __func__); 1001 status = -EIO; 1002 goto fail_dev_init; 1003 } 1004 1005 adapter->priv->hibernate_resume = false; 1006 adapter->priv->reinit_hw = false; 1007 return 0; 1008 1009 fail_dev_init: 1010 sdio_claim_host(pfunction); 1011 sdio_release_irq(pfunction); 1012 sdio_release_host(pfunction); 1013 fail_claim_irq: 1014 rsi_kill_thread(&sdev->rx_thread); 1015 fail_kill_thread: 1016 sdio_claim_host(pfunction); 1017 sdio_disable_func(pfunction); 1018 sdio_release_host(pfunction); 1019 fail_free_adapter: 1020 rsi_91x_deinit(adapter); 1021 rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__); 1022 return status; 1023 } 1024 1025 static void ulp_read_write(struct rsi_hw *adapter, u16 addr, u32 data, 1026 u16 len_in_bits) 1027 { 1028 rsi_sdio_master_reg_write(adapter, RSI_GSPI_DATA_REG1, 1029 ((addr << 6) | ((data >> 16) & 0xffff)), 2); 1030 rsi_sdio_master_reg_write(adapter, RSI_GSPI_DATA_REG0, 1031 (data & 0xffff), 2); 1032 rsi_sdio_master_reg_write(adapter, RSI_GSPI_CTRL_REG0, 1033 RSI_GSPI_CTRL_REG0_VALUE, 2); 1034 rsi_sdio_master_reg_write(adapter, RSI_GSPI_CTRL_REG1, 1035 ((len_in_bits - 1) | RSI_GSPI_TRIG), 2); 1036 msleep(20); 1037 } 1038 1039 /*This function resets and re-initializes the chip.*/ 1040 static void rsi_reset_chip(struct rsi_hw *adapter) 1041 { 1042 u8 *data; 1043 u8 sdio_interrupt_status = 0; 1044 u8 request = 1; 1045 int ret; 1046 1047 data = kzalloc(sizeof(u32), GFP_KERNEL); 1048 if (!data) 1049 return; 1050 1051 rsi_dbg(INFO_ZONE, "Writing disable to wakeup register\n"); 1052 ret = rsi_sdio_write_register(adapter, 0, SDIO_WAKEUP_REG, &request); 1053 if (ret < 0) { 1054 rsi_dbg(ERR_ZONE, 1055 "%s: Failed to write SDIO wakeup register\n", __func__); 1056 goto err; 1057 } 1058 msleep(20); 1059 ret = rsi_sdio_read_register(adapter, RSI_FN1_INT_REGISTER, 1060 &sdio_interrupt_status); 1061 if (ret < 0) { 1062 rsi_dbg(ERR_ZONE, "%s: Failed to Read Intr Status Register\n", 1063 __func__); 1064 goto err; 1065 } 1066 rsi_dbg(INFO_ZONE, "%s: Intr Status Register value = %d\n", 1067 __func__, sdio_interrupt_status); 1068 1069 /* Put Thread-Arch processor on hold */ 1070 if (rsi_sdio_master_access_msword(adapter, TA_BASE_ADDR)) { 1071 rsi_dbg(ERR_ZONE, 1072 "%s: Unable to set ms word to common reg\n", 1073 __func__); 1074 goto err; 1075 } 1076 1077 put_unaligned_le32(TA_HOLD_THREAD_VALUE, data); 1078 if (rsi_sdio_write_register_multiple(adapter, TA_HOLD_THREAD_REG | 1079 RSI_SD_REQUEST_MASTER, 1080 data, 4)) { 1081 rsi_dbg(ERR_ZONE, 1082 "%s: Unable to hold Thread-Arch processor threads\n", 1083 __func__); 1084 goto err; 1085 } 1086 1087 /* This msleep will ensure Thread-Arch processor to go to hold 1088 * and any pending dma transfers to rf spi in device to finish. 1089 */ 1090 msleep(100); 1091 1092 ulp_read_write(adapter, RSI_ULP_RESET_REG, RSI_ULP_WRITE_0, 32); 1093 ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_1, RSI_ULP_WRITE_2, 32); 1094 ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_2, RSI_ULP_WRITE_0, 32); 1095 ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_1, RSI_ULP_WRITE_50, 1096 32); 1097 ulp_read_write(adapter, RSI_WATCH_DOG_DELAY_TIMER_2, RSI_ULP_WRITE_0, 1098 32); 1099 ulp_read_write(adapter, RSI_WATCH_DOG_TIMER_ENABLE, 1100 RSI_ULP_TIMER_ENABLE, 32); 1101 /* This msleep will be sufficient for the ulp 1102 * read write operations to complete for chip reset. 1103 */ 1104 msleep(500); 1105 err: 1106 kfree(data); 1107 return; 1108 } 1109 1110 /** 1111 * rsi_disconnect() - This function performs the reverse of the probe function. 1112 * @pfunction: Pointer to the sdio_func structure. 1113 * 1114 * Return: void. 1115 */ 1116 static void rsi_disconnect(struct sdio_func *pfunction) 1117 { 1118 struct rsi_hw *adapter = sdio_get_drvdata(pfunction); 1119 struct rsi_91x_sdiodev *dev; 1120 1121 if (!adapter) 1122 return; 1123 1124 dev = (struct rsi_91x_sdiodev *)adapter->rsi_dev; 1125 1126 rsi_kill_thread(&dev->rx_thread); 1127 sdio_claim_host(pfunction); 1128 sdio_release_irq(pfunction); 1129 sdio_release_host(pfunction); 1130 mdelay(10); 1131 1132 rsi_mac80211_detach(adapter); 1133 mdelay(10); 1134 1135 if (IS_ENABLED(CONFIG_RSI_COEX) && adapter->priv->coex_mode > 1 && 1136 adapter->priv->bt_adapter) { 1137 rsi_bt_ops.detach(adapter->priv->bt_adapter); 1138 adapter->priv->bt_adapter = NULL; 1139 } 1140 1141 /* Reset Chip */ 1142 rsi_reset_chip(adapter); 1143 1144 /* Resetting to take care of the case, where-in driver is re-loaded */ 1145 sdio_claim_host(pfunction); 1146 rsi_reset_card(pfunction); 1147 sdio_disable_func(pfunction); 1148 sdio_release_host(pfunction); 1149 dev->write_fail = 2; 1150 rsi_91x_deinit(adapter); 1151 rsi_dbg(ERR_ZONE, "##### RSI SDIO device disconnected #####\n"); 1152 1153 } 1154 1155 #ifdef CONFIG_PM 1156 static int rsi_set_sdio_pm_caps(struct rsi_hw *adapter) 1157 { 1158 struct rsi_91x_sdiodev *dev = 1159 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 1160 struct sdio_func *func = dev->pfunction; 1161 int ret; 1162 1163 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 1164 if (ret) 1165 rsi_dbg(ERR_ZONE, "Set sdio keep pwr flag failed: %d\n", ret); 1166 1167 return ret; 1168 } 1169 1170 static int rsi_sdio_disable_interrupts(struct sdio_func *pfunc) 1171 { 1172 struct rsi_hw *adapter = sdio_get_drvdata(pfunc); 1173 u8 isr_status = 0, data = 0; 1174 int ret; 1175 unsigned long t1; 1176 1177 rsi_dbg(INFO_ZONE, "Waiting for interrupts to be cleared.."); 1178 t1 = jiffies; 1179 do { 1180 rsi_sdio_read_register(adapter, RSI_FN1_INT_REGISTER, 1181 &isr_status); 1182 rsi_dbg(INFO_ZONE, "."); 1183 } while ((isr_status) && (jiffies_to_msecs(jiffies - t1) < 20)); 1184 rsi_dbg(INFO_ZONE, "Interrupts cleared\n"); 1185 1186 sdio_claim_host(pfunc); 1187 ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data); 1188 if (ret < 0) { 1189 rsi_dbg(ERR_ZONE, 1190 "%s: Failed to read int enable register\n", 1191 __func__); 1192 goto done; 1193 } 1194 1195 data &= RSI_INT_ENABLE_MASK; 1196 ret = rsi_cmd52writebyte(pfunc->card, RSI_INT_ENABLE_REGISTER, data); 1197 if (ret < 0) { 1198 rsi_dbg(ERR_ZONE, 1199 "%s: Failed to write to int enable register\n", 1200 __func__); 1201 goto done; 1202 } 1203 ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data); 1204 if (ret < 0) { 1205 rsi_dbg(ERR_ZONE, 1206 "%s: Failed to read int enable register\n", 1207 __func__); 1208 goto done; 1209 } 1210 rsi_dbg(INFO_ZONE, "int enable reg content = %x\n", data); 1211 1212 done: 1213 sdio_release_host(pfunc); 1214 return ret; 1215 } 1216 1217 static int rsi_sdio_enable_interrupts(struct sdio_func *pfunc) 1218 { 1219 u8 data; 1220 int ret; 1221 struct rsi_hw *adapter = sdio_get_drvdata(pfunc); 1222 struct rsi_common *common = adapter->priv; 1223 1224 sdio_claim_host(pfunc); 1225 ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data); 1226 if (ret < 0) { 1227 rsi_dbg(ERR_ZONE, 1228 "%s: Failed to read int enable register\n", __func__); 1229 goto done; 1230 } 1231 1232 data |= ~RSI_INT_ENABLE_MASK & 0xff; 1233 1234 ret = rsi_cmd52writebyte(pfunc->card, RSI_INT_ENABLE_REGISTER, data); 1235 if (ret < 0) { 1236 rsi_dbg(ERR_ZONE, 1237 "%s: Failed to write to int enable register\n", 1238 __func__); 1239 goto done; 1240 } 1241 1242 if ((common->wow_flags & RSI_WOW_ENABLED) && 1243 (common->wow_flags & RSI_WOW_NO_CONNECTION)) 1244 rsi_dbg(ERR_ZONE, 1245 "##### Device can not wake up through WLAN\n"); 1246 1247 ret = rsi_cmd52readbyte(pfunc->card, RSI_INT_ENABLE_REGISTER, &data); 1248 if (ret < 0) { 1249 rsi_dbg(ERR_ZONE, 1250 "%s: Failed to read int enable register\n", __func__); 1251 goto done; 1252 } 1253 rsi_dbg(INFO_ZONE, "int enable reg content = %x\n", data); 1254 1255 done: 1256 sdio_release_host(pfunc); 1257 return ret; 1258 } 1259 1260 static int rsi_suspend(struct device *dev) 1261 { 1262 int ret; 1263 struct sdio_func *pfunction = dev_to_sdio_func(dev); 1264 struct rsi_hw *adapter = sdio_get_drvdata(pfunction); 1265 struct rsi_common *common; 1266 1267 if (!adapter) { 1268 rsi_dbg(ERR_ZONE, "Device is not ready\n"); 1269 return -ENODEV; 1270 } 1271 common = adapter->priv; 1272 rsi_sdio_disable_interrupts(pfunction); 1273 1274 ret = rsi_set_sdio_pm_caps(adapter); 1275 if (ret) 1276 rsi_dbg(INFO_ZONE, 1277 "Setting power management caps failed\n"); 1278 common->fsm_state = FSM_CARD_NOT_READY; 1279 1280 return 0; 1281 } 1282 1283 static int rsi_resume(struct device *dev) 1284 { 1285 struct sdio_func *pfunction = dev_to_sdio_func(dev); 1286 struct rsi_hw *adapter = sdio_get_drvdata(pfunction); 1287 struct rsi_common *common = adapter->priv; 1288 1289 common->fsm_state = FSM_MAC_INIT_DONE; 1290 rsi_sdio_enable_interrupts(pfunction); 1291 1292 return 0; 1293 } 1294 1295 static int rsi_freeze(struct device *dev) 1296 { 1297 int ret; 1298 struct sdio_func *pfunction = dev_to_sdio_func(dev); 1299 struct rsi_hw *adapter = sdio_get_drvdata(pfunction); 1300 struct rsi_common *common; 1301 struct rsi_91x_sdiodev *sdev; 1302 1303 rsi_dbg(INFO_ZONE, "SDIO Bus freeze ===>\n"); 1304 1305 if (!adapter) { 1306 rsi_dbg(ERR_ZONE, "Device is not ready\n"); 1307 return -ENODEV; 1308 } 1309 common = adapter->priv; 1310 sdev = (struct rsi_91x_sdiodev *)adapter->rsi_dev; 1311 1312 if ((common->wow_flags & RSI_WOW_ENABLED) && 1313 (common->wow_flags & RSI_WOW_NO_CONNECTION)) 1314 rsi_dbg(ERR_ZONE, 1315 "##### Device can not wake up through WLAN\n"); 1316 1317 if (IS_ENABLED(CONFIG_RSI_COEX) && common->coex_mode > 1 && 1318 common->bt_adapter) { 1319 rsi_bt_ops.detach(common->bt_adapter); 1320 common->bt_adapter = NULL; 1321 } 1322 1323 ret = rsi_sdio_disable_interrupts(pfunction); 1324 1325 if (sdev->write_fail) 1326 rsi_dbg(INFO_ZONE, "###### Device is not ready #######\n"); 1327 1328 ret = rsi_set_sdio_pm_caps(adapter); 1329 if (ret) 1330 rsi_dbg(INFO_ZONE, "Setting power management caps failed\n"); 1331 1332 rsi_dbg(INFO_ZONE, "***** RSI module freezed *****\n"); 1333 1334 return 0; 1335 } 1336 1337 static int rsi_thaw(struct device *dev) 1338 { 1339 struct sdio_func *pfunction = dev_to_sdio_func(dev); 1340 struct rsi_hw *adapter = sdio_get_drvdata(pfunction); 1341 struct rsi_common *common = adapter->priv; 1342 1343 rsi_dbg(ERR_ZONE, "SDIO Bus thaw =====>\n"); 1344 1345 common->hibernate_resume = true; 1346 common->fsm_state = FSM_CARD_NOT_READY; 1347 common->iface_down = true; 1348 1349 rsi_sdio_enable_interrupts(pfunction); 1350 1351 rsi_dbg(INFO_ZONE, "***** RSI module thaw done *****\n"); 1352 1353 return 0; 1354 } 1355 1356 static void rsi_shutdown(struct device *dev) 1357 { 1358 struct sdio_func *pfunction = dev_to_sdio_func(dev); 1359 struct rsi_hw *adapter = sdio_get_drvdata(pfunction); 1360 struct rsi_91x_sdiodev *sdev = 1361 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 1362 struct ieee80211_hw *hw = adapter->hw; 1363 struct cfg80211_wowlan *wowlan = hw->wiphy->wowlan_config; 1364 1365 rsi_dbg(ERR_ZONE, "SDIO Bus shutdown =====>\n"); 1366 1367 if (rsi_config_wowlan(adapter, wowlan)) 1368 rsi_dbg(ERR_ZONE, "Failed to configure WoWLAN\n"); 1369 1370 if (IS_ENABLED(CONFIG_RSI_COEX) && adapter->priv->coex_mode > 1 && 1371 adapter->priv->bt_adapter) { 1372 rsi_bt_ops.detach(adapter->priv->bt_adapter); 1373 adapter->priv->bt_adapter = NULL; 1374 } 1375 1376 rsi_sdio_disable_interrupts(sdev->pfunction); 1377 1378 if (sdev->write_fail) 1379 rsi_dbg(INFO_ZONE, "###### Device is not ready #######\n"); 1380 1381 if (rsi_set_sdio_pm_caps(adapter)) 1382 rsi_dbg(INFO_ZONE, "Setting power management caps failed\n"); 1383 1384 rsi_dbg(INFO_ZONE, "***** RSI module shut down *****\n"); 1385 } 1386 1387 static int rsi_restore(struct device *dev) 1388 { 1389 struct sdio_func *pfunction = dev_to_sdio_func(dev); 1390 struct rsi_hw *adapter = sdio_get_drvdata(pfunction); 1391 struct rsi_common *common = adapter->priv; 1392 1393 rsi_dbg(INFO_ZONE, "SDIO Bus restore ======>\n"); 1394 common->hibernate_resume = true; 1395 common->fsm_state = FSM_FW_NOT_LOADED; 1396 common->iface_down = true; 1397 1398 adapter->sc_nvifs = 0; 1399 adapter->ps_state = PS_NONE; 1400 1401 common->wow_flags = 0; 1402 common->iface_down = false; 1403 1404 rsi_dbg(INFO_ZONE, "RSI module restored\n"); 1405 1406 return 0; 1407 } 1408 static const struct dev_pm_ops rsi_pm_ops = { 1409 .suspend = rsi_suspend, 1410 .resume = rsi_resume, 1411 .freeze = rsi_freeze, 1412 .thaw = rsi_thaw, 1413 .restore = rsi_restore, 1414 }; 1415 #endif 1416 1417 static const struct sdio_device_id rsi_dev_table[] = { 1418 { SDIO_DEVICE(RSI_SDIO_VID_9113, RSI_SDIO_PID_9113) }, 1419 { /* Blank */}, 1420 }; 1421 1422 static struct sdio_driver rsi_driver = { 1423 .name = "RSI-SDIO WLAN", 1424 .probe = rsi_probe, 1425 .remove = rsi_disconnect, 1426 .id_table = rsi_dev_table, 1427 #ifdef CONFIG_PM 1428 .drv = { 1429 .pm = &rsi_pm_ops, 1430 .shutdown = rsi_shutdown, 1431 } 1432 #endif 1433 }; 1434 1435 /** 1436 * rsi_module_init() - This function registers the sdio module. 1437 * @void: Void. 1438 * 1439 * Return: 0 on success. 1440 */ 1441 static int rsi_module_init(void) 1442 { 1443 int ret; 1444 1445 ret = sdio_register_driver(&rsi_driver); 1446 rsi_dbg(INIT_ZONE, "%s: Registering driver\n", __func__); 1447 return ret; 1448 } 1449 1450 /** 1451 * rsi_module_exit() - This function unregisters the sdio module. 1452 * @void: Void. 1453 * 1454 * Return: None. 1455 */ 1456 static void rsi_module_exit(void) 1457 { 1458 sdio_unregister_driver(&rsi_driver); 1459 rsi_dbg(INFO_ZONE, "%s: Unregistering driver\n", __func__); 1460 } 1461 1462 module_init(rsi_module_init); 1463 module_exit(rsi_module_exit); 1464 1465 MODULE_AUTHOR("Redpine Signals Inc"); 1466 MODULE_DESCRIPTION("Common SDIO layer for RSI drivers"); 1467 MODULE_SUPPORTED_DEVICE("RSI-91x"); 1468 MODULE_DEVICE_TABLE(sdio, rsi_dev_table); 1469 MODULE_FIRMWARE(FIRMWARE_RSI9113); 1470 MODULE_VERSION("0.1"); 1471 MODULE_LICENSE("Dual BSD/GPL"); 1472