1 2 3#include <linux/kernel.h> 4#include <linux/moduleparam.h> 5#include <linux/slab.h> 6#include <linux/firmware.h> 7#include <linux/netdevice.h> 8#include <linux/delay.h> 9#include <linux/mmc/card.h> 10#include <linux/mmc/sdio_func.h> 11#include <linux/mmc/sdio_ids.h> 12#include <linux/mmc/sdio.h> 13#include <linux/mmc/host.h> 14 15#include "host.h" 16#include "decl.h" 17#include "defs.h" 18#include "dev.h" 19#include "cmd.h" 20#include "if_sdio.h" 21 22/* The if_sdio_remove() callback function is called when 23 * user removes this module from kernel space or ejects 24 * the card from the slot. The driver handles these 2 cases 25 * differently for SD8688 combo chip. 26 * If the user is removing the module, the FUNC_SHUTDOWN 27 * command for SD8688 is sent to the firmware. 28 * If the card is removed, there is no need to send this command. 29 * 30 * The variable 'user_rmmod' is used to distinguish these two 31 * scenarios. This flag is initialized as FALSE in case the card 32 * is removed, and will be set to TRUE for module removal when 33 * module_exit function is called. 34 */ 35static u8 user_rmmod; 36 37static char *lbs_helper_name = NULL; 38module_param_named(helper_name, lbs_helper_name, charp, 0644); 39 40static char *lbs_fw_name = NULL; 41module_param_named(fw_name, lbs_fw_name, charp, 0644); 42 43static const struct sdio_device_id if_sdio_ids[] = { 44 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 45 SDIO_DEVICE_ID_MARVELL_LIBERTAS) }, 46 { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, 47 SDIO_DEVICE_ID_MARVELL_8688WLAN) }, 48 { /* end: all zeroes */ }, 49}; 50 51MODULE_DEVICE_TABLE(sdio, if_sdio_ids); 52 53struct if_sdio_model { 54 int model; 55 const char *helper; 56 const char *firmware; 57}; 58 59static struct if_sdio_model if_sdio_models[] = { 60 { 61 /* 8385 */ 62 .model = IF_SDIO_MODEL_8385, 63 .helper = "sd8385_helper.bin", 64 .firmware = "sd8385.bin", 65 }, 66 { 67 /* 8686 */ 68 .model = IF_SDIO_MODEL_8686, 69 .helper = "sd8686_helper.bin", 70 .firmware = "sd8686.bin", 71 }, 72 { 73 /* 8688 */ 74 .model = IF_SDIO_MODEL_8688, 75 .helper = "sd8688_helper.bin", 76 .firmware = "sd8688.bin", 77 }, 78}; 79MODULE_FIRMWARE("sd8385_helper.bin"); 80MODULE_FIRMWARE("sd8385.bin"); 81MODULE_FIRMWARE("sd8686_helper.bin"); 82MODULE_FIRMWARE("sd8686.bin"); 83MODULE_FIRMWARE("sd8688_helper.bin"); 84MODULE_FIRMWARE("sd8688.bin"); 85 86struct if_sdio_packet { 87 struct if_sdio_packet *next; 88 u16 nb; 89 u8 buffer[0] __attribute__((aligned(4))); 90}; 91 92struct if_sdio_card { 93 struct sdio_func *func; 94 struct lbs_private *priv; 95 96 int model; 97 unsigned long ioport; 98 unsigned int scratch_reg; 99 100 const char *helper; 101 const char *firmware; 102 bool helper_allocated; 103 bool firmware_allocated; 104 105 u8 buffer[65536] __attribute__((aligned(4))); 106 107 spinlock_t lock; 108 struct if_sdio_packet *packets; 109 110 struct workqueue_struct *workqueue; 111 struct work_struct packet_worker; 112 113 u8 rx_unit; 114}; 115 116/********************************************************************/ 117/* I/O */ 118/********************************************************************/ 119 120/* 121 * For SD8385/SD8686, this function reads firmware status after 122 * the image is downloaded, or reads RX packet length when 123 * interrupt (with IF_SDIO_H_INT_UPLD bit set) is received. 124 * For SD8688, this function reads firmware status only. 125 */ 126static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err) 127{ 128 int ret; 129 u16 scratch; 130 131 scratch = sdio_readb(card->func, card->scratch_reg, &ret); 132 if (!ret) 133 scratch |= sdio_readb(card->func, card->scratch_reg + 1, 134 &ret) << 8; 135 136 if (err) 137 *err = ret; 138 139 if (ret) 140 return 0xffff; 141 142 return scratch; 143} 144 145static u8 if_sdio_read_rx_unit(struct if_sdio_card *card) 146{ 147 int ret; 148 u8 rx_unit; 149 150 rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret); 151 152 if (ret) 153 rx_unit = 0; 154 155 return rx_unit; 156} 157 158static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err) 159{ 160 int ret; 161 u16 rx_len; 162 163 switch (card->model) { 164 case IF_SDIO_MODEL_8385: 165 case IF_SDIO_MODEL_8686: 166 rx_len = if_sdio_read_scratch(card, &ret); 167 break; 168 case IF_SDIO_MODEL_8688: 169 default: /* for newer chipsets */ 170 rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret); 171 if (!ret) 172 rx_len <<= card->rx_unit; 173 else 174 rx_len = 0xffff; /* invalid length */ 175 176 break; 177 } 178 179 if (err) 180 *err = ret; 181 182 return rx_len; 183} 184 185static int if_sdio_handle_cmd(struct if_sdio_card *card, 186 u8 *buffer, unsigned size) 187{ 188 struct lbs_private *priv = card->priv; 189 int ret; 190 unsigned long flags; 191 u8 i; 192 193 lbs_deb_enter(LBS_DEB_SDIO); 194 195 if (size > LBS_CMD_BUFFER_SIZE) { 196 lbs_deb_sdio("response packet too large (%d bytes)\n", 197 (int)size); 198 ret = -E2BIG; 199 goto out; 200 } 201 202 spin_lock_irqsave(&priv->driver_lock, flags); 203 204 i = (priv->resp_idx == 0) ? 1 : 0; 205 BUG_ON(priv->resp_len[i]); 206 priv->resp_len[i] = size; 207 memcpy(priv->resp_buf[i], buffer, size); 208 lbs_notify_command_response(priv, i); 209 210 spin_unlock_irqrestore(&card->priv->driver_lock, flags); 211 212 ret = 0; 213 214out: 215 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 216 return ret; 217} 218 219static int if_sdio_handle_data(struct if_sdio_card *card, 220 u8 *buffer, unsigned size) 221{ 222 int ret; 223 struct sk_buff *skb; 224 char *data; 225 226 lbs_deb_enter(LBS_DEB_SDIO); 227 228 if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) { 229 lbs_deb_sdio("response packet too large (%d bytes)\n", 230 (int)size); 231 ret = -E2BIG; 232 goto out; 233 } 234 235 skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN); 236 if (!skb) { 237 ret = -ENOMEM; 238 goto out; 239 } 240 241 skb_reserve(skb, NET_IP_ALIGN); 242 243 data = skb_put(skb, size); 244 245 memcpy(data, buffer, size); 246 247 lbs_process_rxed_packet(card->priv, skb); 248 249 ret = 0; 250 251out: 252 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 253 254 return ret; 255} 256 257static int if_sdio_handle_event(struct if_sdio_card *card, 258 u8 *buffer, unsigned size) 259{ 260 int ret; 261 u32 event; 262 263 lbs_deb_enter(LBS_DEB_SDIO); 264 265 if (card->model == IF_SDIO_MODEL_8385) { 266 event = sdio_readb(card->func, IF_SDIO_EVENT, &ret); 267 if (ret) 268 goto out; 269 270 /* right shift 3 bits to get the event id */ 271 event >>= 3; 272 } else { 273 if (size < 4) { 274 lbs_deb_sdio("event packet too small (%d bytes)\n", 275 (int)size); 276 ret = -EINVAL; 277 goto out; 278 } 279 event = buffer[3] << 24; 280 event |= buffer[2] << 16; 281 event |= buffer[1] << 8; 282 event |= buffer[0] << 0; 283 } 284 285 lbs_queue_event(card->priv, event & 0xFF); 286 ret = 0; 287 288out: 289 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 290 291 return ret; 292} 293 294static int if_sdio_wait_status(struct if_sdio_card *card, const u8 condition) 295{ 296 u8 status; 297 unsigned long timeout; 298 int ret = 0; 299 300 timeout = jiffies + HZ; 301 while (1) { 302 status = sdio_readb(card->func, IF_SDIO_STATUS, &ret); 303 if (ret) 304 return ret; 305 if ((status & condition) == condition) 306 break; 307 if (time_after(jiffies, timeout)) 308 return -ETIMEDOUT; 309 mdelay(1); 310 } 311 return ret; 312} 313 314static int if_sdio_card_to_host(struct if_sdio_card *card) 315{ 316 int ret; 317 u16 size, type, chunk; 318 319 lbs_deb_enter(LBS_DEB_SDIO); 320 321 size = if_sdio_read_rx_len(card, &ret); 322 if (ret) 323 goto out; 324 325 if (size < 4) { 326 lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n", 327 (int)size); 328 ret = -EINVAL; 329 goto out; 330 } 331 332 ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY); 333 if (ret) 334 goto out; 335 336 /* 337 * The transfer must be in one transaction or the firmware 338 * goes suicidal. There's no way to guarantee that for all 339 * controllers, but we can at least try. 340 */ 341 chunk = sdio_align_size(card->func, size); 342 343 ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk); 344 if (ret) 345 goto out; 346 347 chunk = card->buffer[0] | (card->buffer[1] << 8); 348 type = card->buffer[2] | (card->buffer[3] << 8); 349 350 lbs_deb_sdio("packet of type %d and size %d bytes\n", 351 (int)type, (int)chunk); 352 353 if (chunk > size) { 354 lbs_deb_sdio("packet fragment (%d > %d)\n", 355 (int)chunk, (int)size); 356 ret = -EINVAL; 357 goto out; 358 } 359 360 if (chunk < size) { 361 lbs_deb_sdio("packet fragment (%d < %d)\n", 362 (int)chunk, (int)size); 363 } 364 365 switch (type) { 366 case MVMS_CMD: 367 ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4); 368 if (ret) 369 goto out; 370 break; 371 case MVMS_DAT: 372 ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4); 373 if (ret) 374 goto out; 375 break; 376 case MVMS_EVENT: 377 ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4); 378 if (ret) 379 goto out; 380 break; 381 default: 382 lbs_deb_sdio("invalid type (%d) from firmware\n", 383 (int)type); 384 ret = -EINVAL; 385 goto out; 386 } 387 388out: 389 if (ret) 390 lbs_pr_err("problem fetching packet from firmware\n"); 391 392 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 393 394 return ret; 395} 396 397static void if_sdio_host_to_card_worker(struct work_struct *work) 398{ 399 struct if_sdio_card *card; 400 struct if_sdio_packet *packet; 401 int ret; 402 unsigned long flags; 403 404 lbs_deb_enter(LBS_DEB_SDIO); 405 406 card = container_of(work, struct if_sdio_card, packet_worker); 407 408 while (1) { 409 spin_lock_irqsave(&card->lock, flags); 410 packet = card->packets; 411 if (packet) 412 card->packets = packet->next; 413 spin_unlock_irqrestore(&card->lock, flags); 414 415 if (!packet) 416 break; 417 418 sdio_claim_host(card->func); 419 420 ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY); 421 if (ret == 0) { 422 ret = sdio_writesb(card->func, card->ioport, 423 packet->buffer, packet->nb); 424 } 425 426 if (ret) 427 lbs_pr_err("error %d sending packet to firmware\n", ret); 428 429 sdio_release_host(card->func); 430 431 kfree(packet); 432 } 433 434 lbs_deb_leave(LBS_DEB_SDIO); 435} 436 437/********************************************************************/ 438/* Firmware */ 439/********************************************************************/ 440 441#define FW_DL_READY_STATUS (IF_SDIO_IO_RDY | IF_SDIO_DL_RDY) 442 443static int if_sdio_prog_helper(struct if_sdio_card *card) 444{ 445 int ret; 446 const struct firmware *fw; 447 unsigned long timeout; 448 u8 *chunk_buffer; 449 u32 chunk_size; 450 const u8 *firmware; 451 size_t size; 452 453 lbs_deb_enter(LBS_DEB_SDIO); 454 455 ret = request_firmware(&fw, card->helper, &card->func->dev); 456 if (ret) { 457 lbs_pr_err("can't load helper firmware\n"); 458 goto out; 459 } 460 461 chunk_buffer = kzalloc(64, GFP_KERNEL); 462 if (!chunk_buffer) { 463 ret = -ENOMEM; 464 goto release_fw; 465 } 466 467 sdio_claim_host(card->func); 468 469 ret = sdio_set_block_size(card->func, 32); 470 if (ret) 471 goto release; 472 473 firmware = fw->data; 474 size = fw->size; 475 476 while (size) { 477 ret = if_sdio_wait_status(card, FW_DL_READY_STATUS); 478 if (ret) 479 goto release; 480 481 /* On some platforms (like Davinci) the chip needs more time 482 * between helper blocks. 483 */ 484 mdelay(2); 485 486 chunk_size = min(size, (size_t)60); 487 488 *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size); 489 memcpy(chunk_buffer + 4, firmware, chunk_size); 490/* 491 lbs_deb_sdio("sending %d bytes chunk\n", chunk_size); 492*/ 493 ret = sdio_writesb(card->func, card->ioport, 494 chunk_buffer, 64); 495 if (ret) 496 goto release; 497 498 firmware += chunk_size; 499 size -= chunk_size; 500 } 501 502 /* an empty block marks the end of the transfer */ 503 memset(chunk_buffer, 0, 4); 504 ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64); 505 if (ret) 506 goto release; 507 508 lbs_deb_sdio("waiting for helper to boot...\n"); 509 510 /* wait for the helper to boot by looking at the size register */ 511 timeout = jiffies + HZ; 512 while (1) { 513 u16 req_size; 514 515 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret); 516 if (ret) 517 goto release; 518 519 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8; 520 if (ret) 521 goto release; 522 523 if (req_size != 0) 524 break; 525 526 if (time_after(jiffies, timeout)) { 527 ret = -ETIMEDOUT; 528 goto release; 529 } 530 531 msleep(10); 532 } 533 534 ret = 0; 535 536release: 537 sdio_release_host(card->func); 538 kfree(chunk_buffer); 539release_fw: 540 release_firmware(fw); 541 542out: 543 if (ret) 544 lbs_pr_err("failed to load helper firmware\n"); 545 546 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 547 548 return ret; 549} 550 551static int if_sdio_prog_real(struct if_sdio_card *card) 552{ 553 int ret; 554 const struct firmware *fw; 555 unsigned long timeout; 556 u8 *chunk_buffer; 557 u32 chunk_size; 558 const u8 *firmware; 559 size_t size, req_size; 560 561 lbs_deb_enter(LBS_DEB_SDIO); 562 563 ret = request_firmware(&fw, card->firmware, &card->func->dev); 564 if (ret) { 565 lbs_pr_err("can't load firmware\n"); 566 goto out; 567 } 568 569 chunk_buffer = kzalloc(512, GFP_KERNEL); 570 if (!chunk_buffer) { 571 ret = -ENOMEM; 572 goto release_fw; 573 } 574 575 sdio_claim_host(card->func); 576 577 ret = sdio_set_block_size(card->func, 32); 578 if (ret) 579 goto release; 580 581 firmware = fw->data; 582 size = fw->size; 583 584 while (size) { 585 ret = if_sdio_wait_status(card, FW_DL_READY_STATUS); 586 if (ret) 587 goto release; 588 589 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret); 590 if (ret) 591 goto release; 592 593 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8; 594 if (ret) 595 goto release; 596/* 597 lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size); 598*/ 599 if (req_size == 0) { 600 lbs_deb_sdio("firmware helper gave up early\n"); 601 ret = -EIO; 602 goto release; 603 } 604 605 if (req_size & 0x01) { 606 lbs_deb_sdio("firmware helper signalled error\n"); 607 ret = -EIO; 608 goto release; 609 } 610 611 if (req_size > size) 612 req_size = size; 613 614 while (req_size) { 615 chunk_size = min(req_size, (size_t)512); 616 617 memcpy(chunk_buffer, firmware, chunk_size); 618/* 619 lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n", 620 chunk_size, (chunk_size + 31) / 32 * 32); 621*/ 622 ret = sdio_writesb(card->func, card->ioport, 623 chunk_buffer, roundup(chunk_size, 32)); 624 if (ret) 625 goto release; 626 627 firmware += chunk_size; 628 size -= chunk_size; 629 req_size -= chunk_size; 630 } 631 } 632 633 ret = 0; 634 635 lbs_deb_sdio("waiting for firmware to boot...\n"); 636 637 /* wait for the firmware to boot */ 638 timeout = jiffies + HZ; 639 while (1) { 640 u16 scratch; 641 642 scratch = if_sdio_read_scratch(card, &ret); 643 if (ret) 644 goto release; 645 646 if (scratch == IF_SDIO_FIRMWARE_OK) 647 break; 648 649 if (time_after(jiffies, timeout)) { 650 ret = -ETIMEDOUT; 651 goto release; 652 } 653 654 msleep(10); 655 } 656 657 ret = 0; 658 659release: 660 sdio_release_host(card->func); 661 kfree(chunk_buffer); 662release_fw: 663 release_firmware(fw); 664 665out: 666 if (ret) 667 lbs_pr_err("failed to load firmware\n"); 668 669 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 670 671 return ret; 672} 673 674static int if_sdio_prog_firmware(struct if_sdio_card *card) 675{ 676 int ret; 677 u16 scratch; 678 679 lbs_deb_enter(LBS_DEB_SDIO); 680 681 sdio_claim_host(card->func); 682 scratch = if_sdio_read_scratch(card, &ret); 683 sdio_release_host(card->func); 684 685 if (ret) 686 goto out; 687 688 lbs_deb_sdio("firmware status = %#x\n", scratch); 689 690 if (scratch == IF_SDIO_FIRMWARE_OK) { 691 lbs_deb_sdio("firmware already loaded\n"); 692 goto success; 693 } 694 695 ret = if_sdio_prog_helper(card); 696 if (ret) 697 goto out; 698 699 ret = if_sdio_prog_real(card); 700 if (ret) 701 goto out; 702 703success: 704 sdio_claim_host(card->func); 705 sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE); 706 sdio_release_host(card->func); 707 ret = 0; 708 709out: 710 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 711 712 return ret; 713} 714 715/*******************************************************************/ 716/* Libertas callbacks */ 717/*******************************************************************/ 718 719static int if_sdio_host_to_card(struct lbs_private *priv, 720 u8 type, u8 *buf, u16 nb) 721{ 722 int ret; 723 struct if_sdio_card *card; 724 struct if_sdio_packet *packet, *cur; 725 u16 size; 726 unsigned long flags; 727 728 lbs_deb_enter_args(LBS_DEB_SDIO, "type %d, bytes %d", type, nb); 729 730 card = priv->card; 731 732 if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) { 733 ret = -EINVAL; 734 goto out; 735 } 736 737 /* 738 * The transfer must be in one transaction or the firmware 739 * goes suicidal. There's no way to guarantee that for all 740 * controllers, but we can at least try. 741 */ 742 size = sdio_align_size(card->func, nb + 4); 743 744 packet = kzalloc(sizeof(struct if_sdio_packet) + size, 745 GFP_ATOMIC); 746 if (!packet) { 747 ret = -ENOMEM; 748 goto out; 749 } 750 751 packet->next = NULL; 752 packet->nb = size; 753 754 /* 755 * SDIO specific header. 756 */ 757 packet->buffer[0] = (nb + 4) & 0xff; 758 packet->buffer[1] = ((nb + 4) >> 8) & 0xff; 759 packet->buffer[2] = type; 760 packet->buffer[3] = 0; 761 762 memcpy(packet->buffer + 4, buf, nb); 763 764 spin_lock_irqsave(&card->lock, flags); 765 766 if (!card->packets) 767 card->packets = packet; 768 else { 769 cur = card->packets; 770 while (cur->next) 771 cur = cur->next; 772 cur->next = packet; 773 } 774 775 switch (type) { 776 case MVMS_CMD: 777 priv->dnld_sent = DNLD_CMD_SENT; 778 break; 779 case MVMS_DAT: 780 priv->dnld_sent = DNLD_DATA_SENT; 781 break; 782 default: 783 lbs_deb_sdio("unknown packet type %d\n", (int)type); 784 } 785 786 spin_unlock_irqrestore(&card->lock, flags); 787 788 queue_work(card->workqueue, &card->packet_worker); 789 790 ret = 0; 791 792out: 793 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 794 795 return ret; 796} 797 798static int if_sdio_enter_deep_sleep(struct lbs_private *priv) 799{ 800 int ret = -1; 801 struct cmd_header cmd; 802 803 memset(&cmd, 0, sizeof(cmd)); 804 805 lbs_deb_sdio("send DEEP_SLEEP command\n"); 806 ret = __lbs_cmd(priv, CMD_802_11_DEEP_SLEEP, &cmd, sizeof(cmd), 807 lbs_cmd_copyback, (unsigned long) &cmd); 808 if (ret) 809 lbs_pr_err("DEEP_SLEEP cmd failed\n"); 810 811 mdelay(200); 812 return ret; 813} 814 815static int if_sdio_exit_deep_sleep(struct lbs_private *priv) 816{ 817 struct if_sdio_card *card = priv->card; 818 int ret = -1; 819 820 lbs_deb_enter(LBS_DEB_SDIO); 821 sdio_claim_host(card->func); 822 823 sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret); 824 if (ret) 825 lbs_pr_err("sdio_writeb failed!\n"); 826 827 sdio_release_host(card->func); 828 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 829 return ret; 830} 831 832static int if_sdio_reset_deep_sleep_wakeup(struct lbs_private *priv) 833{ 834 struct if_sdio_card *card = priv->card; 835 int ret = -1; 836 837 lbs_deb_enter(LBS_DEB_SDIO); 838 sdio_claim_host(card->func); 839 840 sdio_writeb(card->func, 0, CONFIGURATION_REG, &ret); 841 if (ret) 842 lbs_pr_err("sdio_writeb failed!\n"); 843 844 sdio_release_host(card->func); 845 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 846 return ret; 847 848} 849 850/*******************************************************************/ 851/* SDIO callbacks */ 852/*******************************************************************/ 853 854static void if_sdio_interrupt(struct sdio_func *func) 855{ 856 int ret; 857 struct if_sdio_card *card; 858 u8 cause; 859 860 lbs_deb_enter(LBS_DEB_SDIO); 861 862 card = sdio_get_drvdata(func); 863 864 cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret); 865 if (ret) 866 goto out; 867 868 lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause); 869 870 sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret); 871 if (ret) 872 goto out; 873 874 /* 875 * Ignore the define name, this really means the card has 876 * successfully received the command. 877 */ 878 card->priv->is_activity_detected = 1; 879 if (cause & IF_SDIO_H_INT_DNLD) 880 lbs_host_to_card_done(card->priv); 881 882 883 if (cause & IF_SDIO_H_INT_UPLD) { 884 ret = if_sdio_card_to_host(card); 885 if (ret) 886 goto out; 887 } 888 889 ret = 0; 890 891out: 892 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 893} 894 895static int if_sdio_probe(struct sdio_func *func, 896 const struct sdio_device_id *id) 897{ 898 struct if_sdio_card *card; 899 struct lbs_private *priv; 900 int ret, i; 901 unsigned int model; 902 struct if_sdio_packet *packet; 903 struct mmc_host *host = func->card->host; 904 905 lbs_deb_enter(LBS_DEB_SDIO); 906 907 for (i = 0;i < func->card->num_info;i++) { 908 if (sscanf(func->card->info[i], 909 "802.11 SDIO ID: %x", &model) == 1) 910 break; 911 if (sscanf(func->card->info[i], 912 "ID: %x", &model) == 1) 913 break; 914 if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) { 915 model = IF_SDIO_MODEL_8385; 916 break; 917 } 918 } 919 920 if (i == func->card->num_info) { 921 lbs_pr_err("unable to identify card model\n"); 922 return -ENODEV; 923 } 924 925 card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL); 926 if (!card) 927 return -ENOMEM; 928 929 card->func = func; 930 card->model = model; 931 932 switch (card->model) { 933 case IF_SDIO_MODEL_8385: 934 card->scratch_reg = IF_SDIO_SCRATCH_OLD; 935 break; 936 case IF_SDIO_MODEL_8686: 937 card->scratch_reg = IF_SDIO_SCRATCH; 938 break; 939 case IF_SDIO_MODEL_8688: 940 default: /* for newer chipsets */ 941 card->scratch_reg = IF_SDIO_FW_STATUS; 942 break; 943 } 944 945 spin_lock_init(&card->lock); 946 card->workqueue = create_workqueue("libertas_sdio"); 947 INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker); 948 949 for (i = 0;i < ARRAY_SIZE(if_sdio_models);i++) { 950 if (card->model == if_sdio_models[i].model) 951 break; 952 } 953 954 if (i == ARRAY_SIZE(if_sdio_models)) { 955 lbs_pr_err("unknown card model 0x%x\n", card->model); 956 ret = -ENODEV; 957 goto free; 958 } 959 960 card->helper = if_sdio_models[i].helper; 961 card->firmware = if_sdio_models[i].firmware; 962 963 kparam_block_sysfs_write(helper_name); 964 if (lbs_helper_name) { 965 char *helper = kstrdup(lbs_helper_name, GFP_KERNEL); 966 if (!helper) { 967 kparam_unblock_sysfs_write(helper_name); 968 ret = -ENOMEM; 969 goto free; 970 } 971 lbs_deb_sdio("overriding helper firmware: %s\n", 972 lbs_helper_name); 973 card->helper = helper; 974 card->helper_allocated = true; 975 } 976 kparam_unblock_sysfs_write(helper_name); 977 978 kparam_block_sysfs_write(fw_name); 979 if (lbs_fw_name) { 980 char *fw_name = kstrdup(lbs_fw_name, GFP_KERNEL); 981 if (!fw_name) { 982 kparam_unblock_sysfs_write(fw_name); 983 ret = -ENOMEM; 984 goto free; 985 } 986 lbs_deb_sdio("overriding firmware: %s\n", lbs_fw_name); 987 card->firmware = fw_name; 988 card->firmware_allocated = true; 989 } 990 kparam_unblock_sysfs_write(fw_name); 991 992 sdio_claim_host(func); 993 994 ret = sdio_enable_func(func); 995 if (ret) 996 goto release; 997 998 ret = sdio_claim_irq(func, if_sdio_interrupt); 999 if (ret) 1000 goto disable; 1001 1002 /* For 1-bit transfers to the 8686 model, we need to enable the 1003 * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0 1004 * bit to allow access to non-vendor registers. */ 1005 if ((card->model == IF_SDIO_MODEL_8686) && 1006 (host->caps & MMC_CAP_SDIO_IRQ) && 1007 (host->ios.bus_width == MMC_BUS_WIDTH_1)) { 1008 u8 reg; 1009 1010 func->card->quirks |= MMC_QUIRK_LENIENT_FN0; 1011 reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret); 1012 if (ret) 1013 goto release_int; 1014 1015 reg |= SDIO_BUS_ECSI; 1016 sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret); 1017 if (ret) 1018 goto release_int; 1019 } 1020 1021 card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret); 1022 if (ret) 1023 goto release_int; 1024 1025 card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8; 1026 if (ret) 1027 goto release_int; 1028 1029 card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16; 1030 if (ret) 1031 goto release_int; 1032 1033 sdio_release_host(func); 1034 1035 sdio_set_drvdata(func, card); 1036 1037 lbs_deb_sdio("class = 0x%X, vendor = 0x%X, " 1038 "device = 0x%X, model = 0x%X, ioport = 0x%X\n", 1039 func->class, func->vendor, func->device, 1040 model, (unsigned)card->ioport); 1041 1042 ret = if_sdio_prog_firmware(card); 1043 if (ret) 1044 goto reclaim; 1045 1046 priv = lbs_add_card(card, &func->dev); 1047 if (!priv) { 1048 ret = -ENOMEM; 1049 goto reclaim; 1050 } 1051 1052 card->priv = priv; 1053 1054 priv->card = card; 1055 priv->hw_host_to_card = if_sdio_host_to_card; 1056 priv->enter_deep_sleep = if_sdio_enter_deep_sleep; 1057 priv->exit_deep_sleep = if_sdio_exit_deep_sleep; 1058 priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup; 1059 1060 priv->fw_ready = 1; 1061 1062 sdio_claim_host(func); 1063 1064 /* 1065 * Get rx_unit if the chip is SD8688 or newer. 1066 * SD8385 & SD8686 do not have rx_unit. 1067 */ 1068 if ((card->model != IF_SDIO_MODEL_8385) 1069 && (card->model != IF_SDIO_MODEL_8686)) 1070 card->rx_unit = if_sdio_read_rx_unit(card); 1071 else 1072 card->rx_unit = 0; 1073 1074 /* 1075 * Enable interrupts now that everything is set up 1076 */ 1077 sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret); 1078 sdio_release_host(func); 1079 if (ret) 1080 goto reclaim; 1081 1082 /* 1083 * FUNC_INIT is required for SD8688 WLAN/BT multiple functions 1084 */ 1085 if (card->model == IF_SDIO_MODEL_8688) { 1086 struct cmd_header cmd; 1087 1088 memset(&cmd, 0, sizeof(cmd)); 1089 1090 lbs_deb_sdio("send function INIT command\n"); 1091 if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd), 1092 lbs_cmd_copyback, (unsigned long) &cmd)) 1093 lbs_pr_alert("CMD_FUNC_INIT cmd failed\n"); 1094 } 1095 1096 ret = lbs_start_card(priv); 1097 if (ret) 1098 goto err_activate_card; 1099 1100out: 1101 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 1102 1103 return ret; 1104 1105err_activate_card: 1106 flush_workqueue(card->workqueue); 1107 lbs_remove_card(priv); 1108reclaim: 1109 sdio_claim_host(func); 1110release_int: 1111 sdio_release_irq(func); 1112disable: 1113 sdio_disable_func(func); 1114release: 1115 sdio_release_host(func); 1116free: 1117 destroy_workqueue(card->workqueue); 1118 while (card->packets) { 1119 packet = card->packets; 1120 card->packets = card->packets->next; 1121 kfree(packet); 1122 } 1123 1124 if (card->helper_allocated) 1125 kfree(card->helper); 1126 if (card->firmware_allocated) 1127 kfree(card->firmware); 1128 kfree(card); 1129 1130 goto out; 1131} 1132 1133static void if_sdio_remove(struct sdio_func *func) 1134{ 1135 struct if_sdio_card *card; 1136 struct if_sdio_packet *packet; 1137 1138 lbs_deb_enter(LBS_DEB_SDIO); 1139 1140 card = sdio_get_drvdata(func); 1141 1142 if (user_rmmod && (card->model == IF_SDIO_MODEL_8688)) { 1143 /* 1144 * FUNC_SHUTDOWN is required for SD8688 WLAN/BT 1145 * multiple functions 1146 */ 1147 struct cmd_header cmd; 1148 1149 memset(&cmd, 0, sizeof(cmd)); 1150 1151 lbs_deb_sdio("send function SHUTDOWN command\n"); 1152 if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN, 1153 &cmd, sizeof(cmd), lbs_cmd_copyback, 1154 (unsigned long) &cmd)) 1155 lbs_pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n"); 1156 } 1157 1158 1159 lbs_deb_sdio("call remove card\n"); 1160 lbs_stop_card(card->priv); 1161 lbs_remove_card(card->priv); 1162 card->priv->surpriseremoved = 1; 1163 1164 flush_workqueue(card->workqueue); 1165 destroy_workqueue(card->workqueue); 1166 1167 sdio_claim_host(func); 1168 sdio_release_irq(func); 1169 sdio_disable_func(func); 1170 sdio_release_host(func); 1171 1172 while (card->packets) { 1173 packet = card->packets; 1174 card->packets = card->packets->next; 1175 kfree(packet); 1176 } 1177 1178 if (card->helper_allocated) 1179 kfree(card->helper); 1180 if (card->firmware_allocated) 1181 kfree(card->firmware); 1182 kfree(card); 1183 1184 lbs_deb_leave(LBS_DEB_SDIO); 1185} 1186 1187static int if_sdio_suspend(struct device *dev) 1188{ 1189 struct sdio_func *func = dev_to_sdio_func(dev); 1190 int ret; 1191 struct if_sdio_card *card = sdio_get_drvdata(func); 1192 1193 mmc_pm_flag_t flags = sdio_get_host_pm_caps(func); 1194 1195 lbs_pr_info("%s: suspend: PM flags = 0x%x\n", 1196 sdio_func_id(func), flags); 1197 1198 /* If we aren't being asked to wake on anything, we should bail out 1199 * and let the SD stack power down the card. 1200 */ 1201 if (card->priv->wol_criteria == EHS_REMOVE_WAKEUP) { 1202 lbs_pr_info("Suspend without wake params -- " 1203 "powering down card."); 1204 return -ENOSYS; 1205 } 1206 1207 if (!(flags & MMC_PM_KEEP_POWER)) { 1208 lbs_pr_err("%s: cannot remain alive while host is suspended\n", 1209 sdio_func_id(func)); 1210 return -ENOSYS; 1211 } 1212 1213 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 1214 if (ret) 1215 return ret; 1216 1217 ret = lbs_suspend(card->priv); 1218 if (ret) 1219 return ret; 1220 1221 return sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ); 1222} 1223 1224static int if_sdio_resume(struct device *dev) 1225{ 1226 struct sdio_func *func = dev_to_sdio_func(dev); 1227 struct if_sdio_card *card = sdio_get_drvdata(func); 1228 int ret; 1229 1230 lbs_pr_info("%s: resume: we're back\n", sdio_func_id(func)); 1231 1232 ret = lbs_resume(card->priv); 1233 1234 return ret; 1235} 1236 1237static const struct dev_pm_ops if_sdio_pm_ops = { 1238 .suspend = if_sdio_suspend, 1239 .resume = if_sdio_resume, 1240}; 1241 1242static struct sdio_driver if_sdio_driver = { 1243 .name = "libertas_sdio", 1244 .id_table = if_sdio_ids, 1245 .probe = if_sdio_probe, 1246 .remove = if_sdio_remove, 1247 .drv = { 1248 .pm = &if_sdio_pm_ops, 1249 }, 1250}; 1251 1252/*******************************************************************/ 1253/* Module functions */ 1254/*******************************************************************/ 1255 1256static int __init if_sdio_init_module(void) 1257{ 1258 int ret = 0; 1259 1260 lbs_deb_enter(LBS_DEB_SDIO); 1261 1262 printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n"); 1263 printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n"); 1264 1265 ret = sdio_register_driver(&if_sdio_driver); 1266 1267 /* Clear the flag in case user removes the card. */ 1268 user_rmmod = 0; 1269 1270 lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret); 1271 1272 return ret; 1273} 1274 1275static void __exit if_sdio_exit_module(void) 1276{ 1277 lbs_deb_enter(LBS_DEB_SDIO); 1278 1279 /* Set the flag as user is removing this module. */ 1280 user_rmmod = 1; 1281 1282 sdio_unregister_driver(&if_sdio_driver); 1283 1284 lbs_deb_leave(LBS_DEB_SDIO); 1285} 1286 1287module_init(if_sdio_init_module); 1288module_exit(if_sdio_exit_module); 1289 1290MODULE_DESCRIPTION("Libertas SDIO WLAN Driver"); 1291MODULE_AUTHOR("Pierre Ossman"); 1292MODULE_LICENSE("GPL"); 1293