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