2 * @brief This file contains SDIO IF (interface) module
5 * Copyright (C) 2007-2012, Marvell International Ltd.
7 * This software file (the "File") is distributed by Marvell International
8 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
9 * (the "License"). You may use, redistribute and/or modify this File in
10 * accordance with the terms and conditions of the License, a copy of which
11 * is available along with the File in the gpl.txt file or by writing to
12 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
13 * 02111-1307 or on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
15 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
17 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
18 * this warranty disclaimer.
22 #include <linux/firmware.h>
23 #include <linux/mmc/sdio_func.h>
28 /** define marvell vendor id */
29 #define MARVELL_VENDOR_ID 0x02df
31 /** Max retry number of CMD53 write */
32 #define MAX_WRITE_IOMEM_RETRY 2
35 /** request firmware nowait */
36 static int req_fw_nowait;
37 static int multi_fn = BIT(2);
38 /** Default firmware name */
39 #define DEFAULT_FW_NAME "mrvl/sd8797_uapsta.bin"
41 /** Function number 2 */
43 /** Device ID for SD8797 FN2 */
44 #define SD_DEVICE_ID_8797_BT_FN2 0x912A
45 /** Device ID for SD8797 FN3 */
46 #define SD_DEVICE_ID_8797_BT_FN3 0x912B
48 /** Array of SDIO device ids when multi_fn=0x12 */
49 static const struct sdio_device_id bt_ids[] = {
50 {SDIO_DEVICE(MARVELL_VENDOR_ID, SD_DEVICE_ID_8797_BT_FN2)},
54 MODULE_DEVICE_TABLE(sdio, bt_ids);
56 /********************************************************
58 ********************************************************/
59 /** unregiser bus driver flag */
61 #ifdef SDIO_SUSPEND_RESUME
63 extern int mbt_pm_keep_power;
66 /********************************************************
68 ********************************************************/
71 * @brief This function gets rx_unit value
73 * @param priv A pointer to bt_private structure
74 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
77 sd_get_rx_unit(bt_private * priv)
79 int ret = BT_STATUS_SUCCESS;
81 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
85 reg = sdio_readb(card->func, CARD_RX_UNIT_REG, &ret);
86 if (ret == BT_STATUS_SUCCESS)
87 priv->bt_dev.rx_unit = reg;
94 * @brief This function reads fwstatus registers
96 * @param priv A pointer to bt_private structure
97 * @param dat A pointer to keep returned data
98 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
101 sd_read_firmware_status(bt_private * priv, u16 * dat)
103 int ret = BT_STATUS_SUCCESS;
106 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
110 fws0 = sdio_readb(card->func, CARD_FW_STATUS0_REG, &ret);
113 return BT_STATUS_FAILURE;
116 fws1 = sdio_readb(card->func, CARD_FW_STATUS1_REG, &ret);
119 return BT_STATUS_FAILURE;
122 *dat = (((u16) fws1) << 8) | fws0;
125 return BT_STATUS_SUCCESS;
129 * @brief This function reads rx length
131 * @param priv A pointer to bt_private structure
132 * @param dat A pointer to keep returned data
133 * @return BT_STATUS_SUCCESS or other error no.
136 sd_read_rx_len(bt_private * priv, u16 * dat)
138 int ret = BT_STATUS_SUCCESS;
140 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
144 reg = sdio_readb(card->func, CARD_RX_LEN_REG, &ret);
145 if (ret == BT_STATUS_SUCCESS)
146 *dat = (u16) reg << priv->bt_dev.rx_unit;
153 * @brief This function enables the host interrupts mask
155 * @param priv A pointer to bt_private structure
156 * @param mask the interrupt mask
157 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
160 sd_enable_host_int_mask(bt_private * priv, u8 mask)
162 int ret = BT_STATUS_SUCCESS;
163 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
167 sdio_writeb(card->func, mask, HOST_INT_MASK_REG, &ret);
169 PRINTM(WARN, "BT: Unable to enable the host interrupt!\n");
170 ret = BT_STATUS_FAILURE;
177 /** @brief This function disables the host interrupts mask.
179 * @param priv A pointer to bt_private structure
180 * @param mask the interrupt mask
181 * @return BT_STATUS_SUCCESS or other error no.
184 sd_disable_host_int_mask(bt_private * priv, u8 mask)
186 int ret = BT_STATUS_FAILURE;
188 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
192 /* Read back the host_int_mask register */
193 host_int_mask = sdio_readb(card->func, HOST_INT_MASK_REG, &ret);
197 /* Update with the mask and write back to the register */
198 host_int_mask &= ~mask;
199 sdio_writeb(card->func, host_int_mask, HOST_INT_MASK_REG, &ret);
201 PRINTM(WARN, "BT: Unable to diable the host interrupt!\n");
204 ret = BT_STATUS_SUCCESS;
211 * @brief This function polls the card status register
213 * @param priv A pointer to bt_private structure
214 * @param bits the bit mask
215 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
218 sd_poll_card_status(bt_private * priv, u8 bits)
222 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
227 for (tries = 0; tries < MAX_POLL_TRIES * 1000; tries++) {
228 cs = sdio_readb(card->func, CARD_STATUS_REG, &rval);
231 if (rval == 0 && (cs & bits) == bits) {
233 return BT_STATUS_SUCCESS;
238 "BT: sdio_poll_card_status failed (%d), tries = %d, cs = 0x%x\n",
242 return BT_STATUS_FAILURE;
246 * @brief This function reads updates the Cmd52 value in dev structure
248 * @param priv A pointer to bt_private structure
249 * @return BT_STATUS_SUCCESS or other error no.
252 sd_read_cmd52_val(bt_private * priv)
254 int ret = BT_STATUS_SUCCESS;
256 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
260 func = priv->bt_dev.cmd52_func;
261 reg = priv->bt_dev.cmd52_reg;
262 sdio_claim_host(card->func);
264 val = sdio_readb(card->func, reg, &ret);
266 val = sdio_f0_readb(card->func, reg, &ret);
267 sdio_release_host(card->func);
269 PRINTM(ERROR, "BT: Cannot read value from func %d reg %d\n",
272 priv->bt_dev.cmd52_val = val;
280 * @brief This function updates card reg based on the Cmd52 value in dev structure
282 * @param priv A pointer to bt_private structure
283 * @param func Stores func variable
284 * @param reg Stores reg variable
285 * @param val Stores val variable
286 * @return BT_STATUS_SUCCESS or other error no.
289 sd_write_cmd52_val(bt_private * priv, int func, int reg, int val)
291 int ret = BT_STATUS_SUCCESS;
292 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
297 /* Perform actual write only if val is provided */
298 sdio_claim_host(card->func);
300 sdio_writeb(card->func, val, reg, &ret);
302 sdio_f0_writeb(card->func, val, reg, &ret);
303 sdio_release_host(card->func);
306 "BT: Cannot write value (0x%x) to func %d reg %d\n",
310 priv->bt_dev.cmd52_val = val;
313 /* Save current func and reg for future read */
314 priv->bt_dev.cmd52_func = func;
315 priv->bt_dev.cmd52_reg = reg;
323 * @brief This function probes the card
325 * @param func A pointer to sdio_func structure.
326 * @param id A pointer to structure sdio_device_id
327 * @return BT_STATUS_SUCCESS/BT_STATUS_FAILURE or other error no.
330 sd_probe_card(struct sdio_func *func, const struct sdio_device_id *id)
332 int ret = BT_STATUS_SUCCESS;
333 bt_private *priv = NULL;
334 struct sdio_mmc_card *card = NULL;
338 PRINTM(INFO, "BT: vendor=0x%x,device=0x%x,class=%d,fn=%d\n", id->vendor,
339 id->device, id->class, func->num);
340 card = kzalloc(sizeof(struct sdio_mmc_card), GFP_KERNEL);
346 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
347 /* wait for chip fully wake up */
348 if (!func->enable_timeout)
349 func->enable_timeout = 200;
351 sdio_claim_host(func);
352 ret = sdio_enable_func(func);
354 sdio_disable_func(func);
355 sdio_release_host(func);
356 PRINTM(FATAL, "BT: sdio_enable_func() failed: ret=%d\n", ret);
361 sdio_release_host(func);
362 priv = bt_add_card(card);
364 sdio_claim_host(func);
365 sdio_disable_func(func);
366 sdio_release_host(func);
367 ret = BT_STATUS_FAILURE;
376 * @brief This function checks if the firmware is ready to accept
379 * @param priv A pointer to bt_private structure
380 * @param pollnum Number of times to poll fw status
381 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
384 sd_verify_fw_download(bt_private * priv, int pollnum)
386 int ret = BT_STATUS_FAILURE;
387 u16 firmwarestat = 0;
392 /* Wait for firmware initialization event */
393 for (tries = 0; tries < pollnum; tries++) {
394 if (sd_read_firmware_status(priv, &firmwarestat) < 0)
396 if (firmwarestat == FIRMWARE_READY) {
397 PRINTM(MSG, "BT FW is active(%d)\n", tries);
398 ret = BT_STATUS_SUCCESS;
403 if ((pollnum > 1) && (ret != BT_STATUS_SUCCESS))
405 "Fail to poll firmware status: firmwarestat=0x%x\n",
412 * @brief Transfers firmware to card
414 * @param priv A Pointer to bt_private structure
415 * @return BT_STATUS_SUCCESS/BT_STATUS_FAILURE or other error no.
418 sd_init_fw_dpc(bt_private * priv)
420 struct sdio_mmc_card *card = (struct sdio_mmc_card *)priv->bt_dev.card;
425 int ret = BT_STATUS_SUCCESS;
427 void *tmpfwbuf = NULL;
435 #ifdef FW_DOWNLOAD_SPEED
440 firmware = (u8 *) priv->firmware->data;
441 firmwarelen = priv->firmware->size;
443 PRINTM(INFO, "BT: Downloading FW image (%d bytes)\n", firmwarelen);
445 #ifdef FW_DOWNLOAD_SPEED
446 tv1 = get_utimeofday();
449 tmpfwbufsz = BT_UPLD_SIZE + DMA_ALIGNMENT;
450 tmpfwbuf = kmalloc(tmpfwbufsz, GFP_KERNEL);
453 "BT: Unable to allocate buffer for firmware. Terminating download\n");
454 ret = BT_STATUS_FAILURE;
457 memset(tmpfwbuf, 0, tmpfwbufsz);
458 /* Ensure aligned firmware buffer */
459 fwbuf = (u8 *) ALIGN_ADDR(tmpfwbuf, DMA_ALIGNMENT);
461 /* Perform firmware data transfer */
464 /* The host polls for the DN_LD_CARD_RDY and CARD_IO_READY bits
466 ret = sd_poll_card_status(priv, CARD_IO_READY | DN_LD_CARD_RDY);
469 "BT: FW download with helper poll status timeout @ %d\n",
474 if (offset >= firmwarelen)
477 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
478 base0 = sdio_readb(card->func,
479 SQ_READ_BASE_ADDRESS_A0_REG, &ret);
481 PRINTM(WARN, "Dev BASE0 register read failed:"
482 " base0=0x%04X(%d). Terminating download\n",
484 ret = BT_STATUS_FAILURE;
487 base1 = sdio_readb(card->func,
488 SQ_READ_BASE_ADDRESS_A1_REG, &ret);
490 PRINTM(WARN, "Dev BASE1 register read failed:"
491 " base1=0x%04X(%d). Terminating download\n",
493 ret = BT_STATUS_FAILURE;
496 len = (((u16) base1) << 8) | base0;
505 else if (len > BT_UPLD_SIZE) {
507 "BT: FW download failure @ %d, invalid length %d\n",
509 ret = BT_STATUS_FAILURE;
517 if (i > MAX_WRITE_IOMEM_RETRY) {
519 "BT: FW download failure @ %d, over max retry count\n",
521 ret = BT_STATUS_FAILURE;
525 "BT: FW CRC error indicated by the helper:"
526 " len = 0x%04X, txlen = %d\n", len, txlen);
529 PRINTM(ERROR, "BT: retry: %d, offset %d\n", i, offset);
530 /* Setting this to 0 to resend from same offset */
535 /* Set blocksize to transfer - checking for last block */
536 if (firmwarelen - offset < txlen)
537 txlen = firmwarelen - offset;
542 (txlen + SD_BLOCK_SIZE_FW_DL -
543 1) / SD_BLOCK_SIZE_FW_DL;
545 /* Copy payload to buffer */
546 memcpy(fwbuf, &firmware[offset], txlen);
550 ret = sdio_writesb(card->func, priv->bt_dev.ioport, fwbuf,
551 tx_blocks * SD_BLOCK_SIZE_FW_DL);
555 "BT: FW download, write iomem (%d) failed @ %d\n",
557 sdio_writeb(card->func, 0x04, CONFIGURATION_REG, &ret);
559 PRINTM(ERROR, "write ioreg failed (CFG)\n");
565 PRINTM(INFO, "\nBT: FW download over, size %d bytes\n", offset);
567 ret = BT_STATUS_SUCCESS;
569 #ifdef FW_DOWNLOAD_SPEED
570 tv2 = get_utimeofday();
571 PRINTM(INFO, "FW: %d.%03d.%03d ", tv1 / 1000000,
572 (tv1 % 1000000) / 1000, tv1 % 1000);
573 PRINTM(INFO, " -> %d.%03d.%03d ", tv2 / 1000000,
574 (tv2 % 1000000) / 1000, tv2 % 1000);
576 PRINTM(INFO, " == %d.%03d.%03d\n", tv2 / 1000000,
577 (tv2 % 1000000) / 1000, tv2 % 1000);
586 * @brief request_firmware callback
588 * @param fw_firmware A pointer to firmware structure
589 * @param context A Pointer to bt_private structure
590 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
593 sd_request_fw_dpc(const struct firmware *fw_firmware, void *context)
595 int ret = BT_STATUS_SUCCESS;
596 bt_private *priv = (bt_private *) context;
597 struct sdio_mmc_card *card = NULL;
598 struct m_dev *m_dev_bt = NULL;
599 struct m_dev *m_dev_fm = NULL;
600 struct m_dev *m_dev_nfc = NULL;
601 struct timeval tstamp;
605 m_dev_bt = &priv->bt_dev.m_dev[BT_SEQ];
606 m_dev_fm = &priv->bt_dev.m_dev[FM_SEQ];
607 m_dev_nfc = &priv->bt_dev.m_dev[NFC_SEQ];
609 if ((priv == NULL) || (priv->adapter == NULL) ||
610 (priv->bt_dev.card == NULL) || (m_dev_bt == NULL)) {
612 return BT_STATUS_FAILURE;
615 card = (struct sdio_mmc_card *)priv->bt_dev.card;
618 do_gettimeofday(&tstamp);
620 (priv->req_fw_time.tv_sec + REQUEST_FW_TIMEOUT)) {
622 "BT: No firmware image found. Skipping download\n");
623 ret = BT_STATUS_FAILURE;
627 "BT: No firmware image found! Retrying download\n");
628 /* Wait a second here before calling the callback again */
629 os_sched_timeout(1000);
630 sd_download_firmware_w_helper(priv);
635 priv->firmware = fw_firmware;
636 if (BT_STATUS_FAILURE == sd_init_fw_dpc(priv)) {
638 "BT: sd_init_fw_dpc failed (download fw with nowait: %d). Terminating download\n",
640 sdio_release_host(card->func);
641 ret = BT_STATUS_FAILURE;
645 /* check if the fimware is downloaded successfully or not */
646 if (sd_verify_fw_download(priv, MAX_FIRMWARE_POLL_TRIES)) {
647 PRINTM(ERROR, "BT: FW failed to be active in time!\n");
648 ret = BT_STATUS_FAILURE;
649 sdio_release_host(card->func);
652 sdio_release_host(card->func);
653 sd_enable_host_int(priv);
654 if (BT_STATUS_FAILURE == sbi_register_conf_dpc(priv)) {
656 "BT: sbi_register_conf_dpc failed. Terminating download\n");
657 ret = BT_STATUS_FAILURE;
661 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
664 release_firmware(fw_firmware);
671 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
674 release_firmware(fw_firmware);
676 /* For synchronous download cleanup will be done in add_card */
679 PRINTM(INFO, "unregister device\n");
680 sbi_unregister_dev(priv);
681 ((struct sdio_mmc_card *)card)->priv = NULL;
682 /* Stop the thread servicing the interrupts */
683 priv->adapter->SurpriseRemoved = TRUE;
684 wake_up_interruptible(&priv->MainThread.waitQ);
685 while (priv->MainThread.pid) {
688 if (m_dev_bt->dev_pointer) {
689 if (m_dev_bt->spec_type == IANYWHERE_SPEC)
690 free_m_dev(m_dev_bt);
692 if (m_dev_fm->dev_pointer)
693 free_m_dev(m_dev_fm);
694 if (m_dev_nfc->dev_pointer)
695 free_m_dev(m_dev_nfc);
697 bt_free_adapter(priv);
704 * @brief request_firmware callback
705 * This function is invoked by request_firmware_nowait system call
707 * @param firmware A pointer to firmware structure
708 * @param context A Pointer to bt_private structure
712 sd_request_fw_callback(const struct firmware *firmware, void *context)
715 sd_request_fw_dpc(firmware, context);
721 * @brief This function downloads firmware image to the card.
723 * @param priv A pointer to bt_private structure
724 * @return BT_STATUS_SUCCESS/BT_STATUS_FAILURE or other error no.
727 sd_download_firmware_w_helper(bt_private * priv)
729 int ret = BT_STATUS_SUCCESS;
731 char *cur_fw_name = NULL;
735 cur_fw_name = fw_name;
738 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 32)
739 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
740 cur_fw_name, priv->hotplug_device,
742 sd_request_fw_callback);
744 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
745 cur_fw_name, priv->hotplug_device,
746 priv, sd_request_fw_callback);
750 "BT: request_firmware_nowait() failed, error code = %#x\n",
753 err = request_firmware(&priv->firmware, cur_fw_name,
754 priv->hotplug_device);
757 "BT: request_firmware() failed, error code = %#x\n",
759 ret = BT_STATUS_FAILURE;
761 ret = sd_request_fw_dpc(priv->firmware, priv);
769 * @brief This function reads data from the card.
771 * @param priv A pointer to bt_private structure
772 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
775 sd_card_to_host(bt_private * priv)
777 int ret = BT_STATUS_SUCCESS;
781 struct sk_buff *skb = NULL;
784 struct mbt_dev *mbt_dev = NULL;
785 struct m_dev *mdev_bt = &(priv->bt_dev.m_dev[BT_SEQ]);
786 struct m_dev *mdev_fm = &(priv->bt_dev.m_dev[FM_SEQ]);
787 struct m_dev *mdev_nfc = &(priv->bt_dev.m_dev[NFC_SEQ]);
788 struct nfc_dev *nfc_dev =
789 (struct nfc_dev *)priv->bt_dev.m_dev[NFC_SEQ].dev_pointer;
790 struct fm_dev *fm_dev =
791 (struct fm_dev *)priv->bt_dev.m_dev[FM_SEQ].dev_pointer;
792 struct m_dev *mdev_debug = &(priv->bt_dev.m_dev[DEBUG_SEQ]);
793 struct debug_dev *debug_dev =
794 (struct debug_dev *)priv->bt_dev.m_dev[DEBUG_SEQ].dev_pointer;
795 struct sdio_mmc_card *card = priv->bt_dev.card;
798 mbt_dev = (struct mbt_dev *)priv->bt_dev.m_dev[BT_SEQ].dev_pointer;
799 if (!card || !card->func) {
800 PRINTM(ERROR, "BT: card or function is NULL!\n");
801 ret = BT_STATUS_FAILURE;
805 /* Read the length of data to be transferred */
806 ret = sd_read_rx_len(priv, &buf_len);
808 PRINTM(ERROR, "BT: card_to_host, read scratch reg failed\n");
809 ret = BT_STATUS_FAILURE;
813 /* Allocate buffer */
814 blksz = SD_BLOCK_SIZE;
815 buf_block_len = (buf_len + blksz - 1) / blksz;
816 if (buf_len <= BT_HEADER_LEN ||
817 (buf_block_len * blksz) > ALLOC_BUF_SIZE) {
818 PRINTM(ERROR, "BT: card_to_host, invalid packet length: %d\n",
820 ret = BT_STATUS_FAILURE;
823 skb = bt_skb_alloc(buf_block_len * blksz + DMA_ALIGNMENT, GFP_ATOMIC);
825 PRINTM(WARN, "BT: No free skb\n");
828 if ((t_ptr) skb->data & (DMA_ALIGNMENT - 1)) {
831 ((t_ptr) skb->data & (DMA_ALIGNMENT - 1)));
834 ((t_ptr) skb->data & (DMA_ALIGNMENT - 1)));
838 ret = sdio_readsb(card->func, payload, priv->bt_dev.ioport,
839 buf_block_len * blksz);
841 PRINTM(ERROR, "BT: card_to_host, read iomem failed: %d\n", ret);
844 ret = BT_STATUS_FAILURE;
847 /* This is SDIO specific header length: byte[2][1][0], * type: byte[3]
848 (HCI_COMMAND = 1, ACL_DATA = 2, SCO_DATA = 3, 0xFE = Vendor) */
849 buf_len = payload[0];
850 buf_len |= (u16) payload[1] << 8;
852 PRINTM(DATA, "BT: SDIO Blk Rd %s: len=%d type=%d\n", mbt_dev->name,
854 if (buf_len > buf_block_len * blksz) {
856 "BT: Drop invalid rx pkt, len in hdr=%d, cmd53 length=%d\n",
857 buf_len, buf_block_len * blksz);
858 ret = BT_STATUS_FAILURE;
863 DBG_HEXDUMP(DAT_D, "BT: SDIO Blk Rd", payload, buf_len);
865 case HCI_ACLDATA_PKT:
866 bt_cb(skb)->pkt_type = type;
867 skb_put(skb, buf_len);
868 skb_pull(skb, BT_HEADER_LEN);
870 skb->dev = (void *)mdev_bt;
871 mdev_recv_frame(skb);
872 mdev_bt->stat.byte_rx += buf_len;
875 case HCI_SCODATA_PKT:
876 bt_cb(skb)->pkt_type = type;
877 skb_put(skb, buf_len);
878 skb_pull(skb, BT_HEADER_LEN);
880 skb->dev = (void *)mdev_bt;
881 mdev_recv_frame(skb);
882 mdev_bt->stat.byte_rx += buf_len;
887 bt_cb(skb)->pkt_type = type;
888 skb_put(skb, buf_len);
889 skb_pull(skb, BT_HEADER_LEN);
890 if (BT_STATUS_SUCCESS == check_evtpkt(priv, skb))
892 switch (skb->data[0]) {
895 if (priv->debug_device_pending) {
896 if (priv->debug_ocf_ogf[0] == skb->data[3] &&
897 priv->debug_ocf_ogf[1] == skb->data[4]) {
898 priv->debug_device_pending = 0;
899 priv->debug_ocf_ogf[0] = 0;
900 priv->debug_ocf_ogf[1] = 0;
901 /** debug cmd complete */
903 skb->dev = (void *)mdev_debug;
904 mdev_recv_frame(skb);
905 mdev_debug->stat.byte_rx +=
911 if (skb->data[3] == 0x80 && skb->data[4] == 0xFE) {
912 /** FM cmd complete */
914 skb->dev = (void *)mdev_fm;
915 mdev_recv_frame(skb);
916 mdev_fm->stat.byte_rx += buf_len;
918 } else if (skb->data[3] == 0x81 && skb->data[4] == 0xFE) {
919 /** NFC cmd complete */
921 skb->dev = (void *)mdev_nfc;
922 mdev_recv_frame(skb);
923 mdev_nfc->stat.byte_rx += buf_len;
927 skb->dev = (void *)mdev_bt;
928 mdev_recv_frame(skb);
929 mdev_bt->stat.byte_rx += buf_len;
935 if (skb->data[4] == 0x80 && skb->data[5] == 0xFE) {
938 skb->dev = (void *)mdev_fm;
939 mdev_recv_frame(skb);
940 mdev_fm->stat.byte_rx += buf_len;
942 } else if (skb->data[4] == 0x81 && skb->data[5] == 0xFE) {
943 /** NFC cmd ststus */
945 skb->dev = (void *)mdev_nfc;
946 mdev_recv_frame(skb);
947 mdev_nfc->stat.byte_rx += buf_len;
952 skb->dev = (void *)mdev_bt;
953 mdev_recv_frame(skb);
954 mdev_bt->stat.byte_rx += buf_len;
959 /** Vendor specific pkt */
960 if (skb->data[2] == 0xC0) {
963 skb->dev = (void *)mdev_nfc;
964 mdev_recv_frame(skb);
965 mdev_nfc->stat.byte_rx += buf_len;
967 } else if (skb->data[2] >= 0x80 && skb->data[2] <= 0xAF) {
970 skb->dev = (void *)mdev_fm;
971 mdev_recv_frame(skb);
972 mdev_fm->stat.byte_rx += buf_len;
977 skb->dev = (void *)mdev_bt;
978 mdev_recv_frame(skb);
979 mdev_bt->stat.byte_rx += buf_len;
986 skb->dev = (void *)mdev_bt;
987 mdev_recv_frame(skb);
988 mdev_bt->stat.byte_rx += buf_len;
993 case MRVL_VENDOR_PKT:
994 /* Just think here need to back compatible FM */
995 bt_cb(skb)->pkt_type = HCI_VENDOR_PKT;
996 skb_put(skb, buf_len);
997 skb_pull(skb, BT_HEADER_LEN);
999 if (BT_STATUS_SUCCESS != bt_process_event(priv, skb)) {
1000 skb->dev = (void *)mdev_bt;
1001 mdev_recv_frame(skb);
1002 mdev_bt->stat.byte_rx += buf_len;
1008 /* Driver specified event and command resp should be handle
1010 PRINTM(INFO, "BT: Unknown PKT type:%d\n", type);
1018 mdev_bt->stat.err_rx++;
1019 PRINTM(ERROR, "error when recv pkt!\n");
1027 * @brief This function removes the card
1029 * @param func A pointer to sdio_func structure
1033 sd_remove_card(struct sdio_func *func)
1035 struct sdio_mmc_card *card;
1040 card = sdio_get_drvdata(func);
1042 if (!unregister && card->priv) {
1043 PRINTM(INFO, "BT: card removed from sd slot\n");
1044 ((bt_private *) (card->priv))->adapter->
1045 SurpriseRemoved = TRUE;
1047 bt_remove_card(card->priv);
1056 * @brief This function handles the interrupt.
1058 * @param func A pointer to sdio_func structure
1062 sd_interrupt(struct sdio_func *func)
1065 struct m_dev *m_dev = NULL;
1066 struct sdio_mmc_card *card;
1067 int ret = BT_STATUS_SUCCESS;
1072 card = sdio_get_drvdata(func);
1073 if (!card || !card->priv) {
1075 "BT: %s: sbi_interrupt(%p) card or priv is NULL, card=%p\n",
1076 __FUNCTION__, func, card);
1081 m_dev = &(priv->bt_dev.m_dev[BT_SEQ]);
1082 ireg = sdio_readb(card->func, HOST_INTSTATUS_REG, &ret);
1085 "BT: sdio_read_ioreg: read int status register failed\n");
1090 * DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS
1091 * Clear the interrupt status register and re-enable the interrupt
1093 PRINTM(INTR, "BT: INT %s: sdio_ireg = 0x%x\n", m_dev->name,
1095 priv->adapter->irq_recv = ireg;
1097 PRINTM(ERROR, "BT: ERR: ireg=0\n");
1100 priv->adapter->sd_ireg |= ireg;
1102 bt_interrupt(m_dev);
1108 * @brief This function checks if the interface is ready to download
1109 * or not while other download interfaces are present
1111 * @param priv A pointer to bt_private structure
1112 * @param val Winner status (0: winner)
1113 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
1116 sd_check_winner_status(bt_private * priv, u8 * val)
1119 int ret = BT_STATUS_SUCCESS;
1121 struct sdio_mmc_card *cardp = (struct sdio_mmc_card *)priv->bt_dev.card;
1124 winner = sdio_readb(cardp->func, CARD_FW_STATUS0_REG, &ret);
1125 if (ret != BT_STATUS_SUCCESS) {
1127 return BT_STATUS_FAILURE;
1135 #ifdef SDIO_SUSPEND_RESUME
1136 #ifdef MMC_PM_KEEP_POWER
1137 #ifdef MMC_PM_FUNC_SUSPENDED
1138 /** @brief This function tells lower driver that BT is suspended
1140 * @param priv A pointer to bt_private structure
1144 bt_is_suspended(bt_private * priv)
1146 struct sdio_mmc_card *card = priv->bt_dev.card;
1147 priv->adapter->is_suspended = TRUE;
1148 sdio_func_suspended(card->func);
1152 /** @brief This function handles client driver suspend
1154 * @param dev A pointer to device structure
1155 * @return BT_STATUS_SUCCESS or other error no.
1158 bt_sdio_suspend(struct device *dev)
1160 struct sdio_func *func = dev_to_sdio_func(dev);
1161 mmc_pm_flag_t pm_flags = 0;
1162 bt_private *priv = NULL;
1163 struct sdio_mmc_card *cardp;
1164 struct m_dev *m_dev = NULL;
1169 pm_flags = sdio_get_host_pm_caps(func);
1170 PRINTM(CMD, "BT: %s: suspend: PM flags = 0x%x\n",
1171 sdio_func_id(func), pm_flags);
1172 if (!(pm_flags & MMC_PM_KEEP_POWER)) {
1174 "BT: %s: cannot remain alive while host is suspended\n",
1175 sdio_func_id(func));
1178 cardp = sdio_get_drvdata(func);
1179 if (!cardp || !cardp->priv) {
1181 "BT: Card or priv structure is not valid\n");
1183 return BT_STATUS_SUCCESS;
1186 PRINTM(ERROR, "BT: sdio_func is not specified\n");
1188 return BT_STATUS_SUCCESS;
1192 if ((mbt_pm_keep_power) && (priv->adapter->hs_state != HS_ACTIVATED)) {
1193 /* disable FM event mask */
1194 if ((priv->bt_dev.m_dev[FM_SEQ].dev_type == FM_TYPE) &&
1195 test_bit(HCI_RUNNING, &(priv->bt_dev.m_dev[FM_SEQ].flags)))
1196 fm_set_intr_mask(priv, FM_DISABLE_INTR_MASK);
1197 if (BT_STATUS_SUCCESS != bt_enable_hs(priv)) {
1198 PRINTM(CMD, "BT: HS not actived, suspend fail!\n");
1203 m_dev = &(priv->bt_dev.m_dev[BT_SEQ]);
1204 PRINTM(CMD, "BT %s: SDIO suspend\n", m_dev->name);
1205 mbt_hci_suspend_dev(m_dev);
1206 skb_queue_purge(&priv->adapter->tx_queue);
1208 priv->adapter->is_suspended = TRUE;
1210 /* We will keep the power when hs enabled successfully */
1211 if ((mbt_pm_keep_power) && (priv->adapter->hs_state == HS_ACTIVATED)) {
1212 #ifdef MMC_PM_SKIP_RESUME_PROBE
1213 PRINTM(CMD, "BT: suspend with MMC_PM_KEEP_POWER and "
1214 "MMC_PM_SKIP_RESUME_PROBE\n");
1215 return sdio_set_host_pm_flags(func,
1217 MMC_PM_SKIP_RESUME_PROBE);
1219 PRINTM(CMD, "BT: suspend with MMC_PM_KEEP_POWER\n");
1220 return sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1223 PRINTM(CMD, "BT: suspend without MMC_PM_KEEP_POWER\n");
1224 return BT_STATUS_SUCCESS;
1228 /** @brief This function handles client driver resume
1230 * @param dev A pointer to device structure
1231 * @return BT_STATUS_SUCCESS
1234 bt_sdio_resume(struct device *dev)
1236 struct sdio_func *func = dev_to_sdio_func(dev);
1237 mmc_pm_flag_t pm_flags = 0;
1238 bt_private *priv = NULL;
1239 struct sdio_mmc_card *cardp;
1240 struct m_dev *m_dev = NULL;
1244 pm_flags = sdio_get_host_pm_caps(func);
1245 PRINTM(CMD, "BT: %s: resume: PM flags = 0x%x\n",
1246 sdio_func_id(func), pm_flags);
1247 cardp = sdio_get_drvdata(func);
1248 if (!cardp || !cardp->priv) {
1250 "BT: Card or priv structure is not valid\n");
1252 return BT_STATUS_SUCCESS;
1255 PRINTM(ERROR, "BT: sdio_func is not specified\n");
1257 return BT_STATUS_SUCCESS;
1260 priv->adapter->is_suspended = FALSE;
1261 m_dev = &(priv->bt_dev.m_dev[BT_SEQ]);
1262 PRINTM(CMD, "BT %s: SDIO resume\n", m_dev->name);
1263 mbt_hci_resume_dev(m_dev);
1264 sbi_wakeup_firmware(priv);
1265 /* enable FM event mask */
1266 if ((priv->bt_dev.m_dev[FM_SEQ].dev_type == FM_TYPE) &&
1267 test_bit(HCI_RUNNING, &(priv->bt_dev.m_dev[FM_SEQ].flags)))
1268 fm_set_intr_mask(priv, FM_DEFAULT_INTR_MASK);
1269 priv->adapter->hs_state = HS_DEACTIVATED;
1270 PRINTM(CMD, "BT:%s: HS DEACTIVATED in Resume!\n", m_dev->name);
1272 return BT_STATUS_SUCCESS;
1277 /********************************************************
1279 ********************************************************/
1280 #ifdef SDIO_SUSPEND_RESUME
1281 #ifdef MMC_PM_KEEP_POWER
1282 static struct dev_pm_ops bt_sdio_pm_ops = {
1283 .suspend = bt_sdio_suspend,
1284 .resume = bt_sdio_resume,
1288 static struct sdio_driver sdio_bt = {
1291 .probe = sd_probe_card,
1292 .remove = sd_remove_card,
1293 #ifdef SDIO_SUSPEND_RESUME
1294 #ifdef MMC_PM_KEEP_POWER
1296 .pm = &bt_sdio_pm_ops,
1303 * @brief This function registers the bt module in bus driver.
1305 * @return An int pointer that keeps returned value
1314 if (sdio_register_driver(&sdio_bt) != 0) {
1315 PRINTM(FATAL, "BT: SD Driver Registration Failed \n");
1326 * @brief This function de-registers the bt module in bus driver.
1331 sbi_unregister(void)
1335 sdio_unregister_driver(&sdio_bt);
1340 * @brief This function registers the device.
1342 * @param priv A pointer to bt_private structure
1343 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
1346 sbi_register_dev(bt_private * priv)
1348 int ret = BT_STATUS_SUCCESS;
1351 struct sdio_mmc_card *card = priv->bt_dev.card;
1352 struct sdio_func *func;
1356 if (!card || !card->func) {
1357 PRINTM(ERROR, "BT: Error: card or function is NULL!\n");
1361 priv->hotplug_device = &func->dev;
1362 if (fw_name == NULL)
1363 fw_name = DEFAULT_FW_NAME;
1365 /* Initialize the private structure */
1366 strncpy(priv->bt_dev.name, "bt_sdio0", sizeof(priv->bt_dev.name));
1367 priv->bt_dev.ioport = 0;
1368 priv->bt_dev.fn = func->num;
1370 sdio_claim_host(func);
1371 ret = sdio_claim_irq(func, sd_interrupt);
1373 PRINTM(FATAL, ": sdio_claim_irq failed: ret=%d\n", ret);
1376 ret = sdio_set_block_size(card->func, SD_BLOCK_SIZE);
1378 PRINTM(FATAL, ": %s: cannot set SDIO block size\n",
1383 /* read Revision Register to get the chip revision number */
1384 chiprev = sdio_readb(func, CARD_REVISION_REG, &ret);
1386 PRINTM(FATAL, ": cannot read CARD_REVISION_REG\n");
1389 priv->adapter->chip_rev = chiprev;
1390 PRINTM(INFO, "revision=%#x\n", chiprev);
1393 * Read the HOST_INTSTATUS_REG for ACK the first interrupt got
1394 * from the bootloader. If we don't do this we get a interrupt
1395 * as soon as we register the irq.
1397 reg = sdio_readb(func, HOST_INTSTATUS_REG, &ret);
1401 /* Read the IO port */
1402 reg = sdio_readb(func, IO_PORT_0_REG, &ret);
1406 priv->bt_dev.ioport |= reg;
1408 reg = sdio_readb(func, IO_PORT_1_REG, &ret);
1412 priv->bt_dev.ioport |= (reg << 8);
1414 reg = sdio_readb(func, IO_PORT_2_REG, &ret);
1418 priv->bt_dev.ioport |= (reg << 16);
1420 PRINTM(INFO, ": SDIO FUNC%d IO port: 0x%x\n", priv->bt_dev.fn,
1421 priv->bt_dev.ioport);
1422 #define SDIO_INT_MASK 0x3F
1423 /* Set Host interrupt reset to read to clear */
1424 reg = sdio_readb(func, HOST_INT_RSR_REG, &ret);
1427 sdio_writeb(func, reg | SDIO_INT_MASK, HOST_INT_RSR_REG, &ret);
1430 /* Set auto re-enable */
1431 reg = sdio_readb(func, CARD_MISC_CFG_REG, &ret);
1434 sdio_writeb(func, reg | AUTO_RE_ENABLE_INT, CARD_MISC_CFG_REG, &ret);
1438 sdio_set_drvdata(func, card);
1439 sdio_release_host(func);
1442 return BT_STATUS_SUCCESS;
1444 sdio_release_irq(func);
1446 sdio_release_host(func);
1450 return BT_STATUS_FAILURE;
1454 * @brief This function de-registers the device.
1456 * @param priv A pointer to bt_private structure
1457 * @return BT_STATUS_SUCCESS
1460 sbi_unregister_dev(bt_private * priv)
1462 struct sdio_mmc_card *card = priv->bt_dev.card;
1466 if (card && card->func) {
1467 sdio_claim_host(card->func);
1468 sdio_release_irq(card->func);
1469 sdio_disable_func(card->func);
1470 sdio_release_host(card->func);
1471 sdio_set_drvdata(card->func, NULL);
1475 return BT_STATUS_SUCCESS;
1479 * @brief This function enables the host interrupts.
1481 * @param priv A pointer to bt_private structure
1482 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
1485 sd_enable_host_int(bt_private * priv)
1487 struct sdio_mmc_card *card = priv->bt_dev.card;
1492 if (!card || !card->func) {
1494 return BT_STATUS_FAILURE;
1496 sdio_claim_host(card->func);
1497 ret = sd_enable_host_int_mask(priv, HIM_ENABLE);
1498 sd_get_rx_unit(priv);
1499 sdio_release_host(card->func);
1506 * @brief This function disables the host interrupts.
1508 * @param priv A pointer to bt_private structure
1509 * @return BT_STATUS_SUCCESS/BT_STATUS_FAILURE or other error no.
1512 sd_disable_host_int(bt_private * priv)
1514 struct sdio_mmc_card *card = priv->bt_dev.card;
1519 if (!card || !card->func) {
1521 return BT_STATUS_FAILURE;
1523 sdio_claim_host(card->func);
1524 ret = sd_disable_host_int_mask(priv, HIM_DISABLE);
1525 sdio_release_host(card->func);
1532 * @brief This function sends data to the card.
1534 * @param priv A pointer to bt_private structure
1535 * @param payload A pointer to the data/cmd buffer
1536 * @param nb Length of data/cmd
1537 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
1540 sbi_host_to_card(bt_private * priv, u8 * payload, u16 nb)
1542 struct sdio_mmc_card *card = priv->bt_dev.card;
1543 struct m_dev *m_dev = &(priv->bt_dev.m_dev[BT_SEQ]);
1544 int ret = BT_STATUS_SUCCESS;
1549 void *tmpbuf = NULL;
1554 if (!card || !card->func) {
1555 PRINTM(ERROR, "BT: card or function is NULL!\n");
1557 return BT_STATUS_FAILURE;
1561 blksz = SD_BLOCK_SIZE;
1562 buf_block_len = (nb + blksz - 1) / blksz;
1563 /* Allocate buffer and copy payload */
1564 if ((t_ptr) payload & (DMA_ALIGNMENT - 1)) {
1565 tmpbufsz = buf_block_len * blksz + DMA_ALIGNMENT;
1566 tmpbuf = kmalloc(tmpbufsz, GFP_KERNEL);
1569 return BT_STATUS_FAILURE;
1571 memset(tmpbuf, 0, tmpbufsz);
1572 /* Ensure 8-byte aligned CMD buffer */
1573 buf = (u8 *) ALIGN_ADDR(tmpbuf, DMA_ALIGNMENT);
1574 memcpy(buf, payload, nb);
1576 sdio_claim_host(card->func);
1577 #define MAX_WRITE_IOMEM_RETRY 2
1579 /* Transfer data to card */
1580 ret = sdio_writesb(card->func, priv->bt_dev.ioport, buf,
1581 buf_block_len * blksz);
1585 "BT: host_to_card, write iomem (%d) failed: %d\n",
1587 sdio_writeb(card->func, HOST_WO_CMD53_FINISH_HOST,
1588 CONFIGURATION_REG, &ret);
1590 ret = BT_STATUS_FAILURE;
1591 if (i > MAX_WRITE_IOMEM_RETRY)
1594 PRINTM(DATA, "BT: SDIO Blk Wr %s: len=%d\n",
1596 DBG_HEXDUMP(DAT_D, "BT: SDIO Blk Wr", payload, nb);
1598 } while (ret == BT_STATUS_FAILURE);
1599 priv->bt_dev.tx_dnld_rdy = FALSE;
1601 sdio_release_host(card->func);
1609 * @brief This function downloads firmware
1611 * @param priv A pointer to bt_private structure
1612 * @return BT_STATUS_SUCCESS or BT_STATUS_FAILURE
1615 sbi_download_fw(bt_private * priv)
1617 struct sdio_mmc_card *card = priv->bt_dev.card;
1618 int ret = BT_STATUS_SUCCESS;
1619 struct m_dev *m_dev_bt = &(priv->bt_dev.m_dev[BT_SEQ]);
1620 struct m_dev *m_dev_fm = &(priv->bt_dev.m_dev[FM_SEQ]);
1621 struct m_dev *m_dev_nfc = &(priv->bt_dev.m_dev[NFC_SEQ]);
1622 int poll_num = MAX_FIRMWARE_POLL_TRIES;
1627 if (!card || !card->func) {
1628 PRINTM(ERROR, "BT: card or function is NULL!\n");
1629 ret = BT_STATUS_FAILURE;
1633 sdio_claim_host(card->func);
1634 if (BT_STATUS_SUCCESS == sd_verify_fw_download(priv, 1)) {
1635 PRINTM(MSG, "BT: FW already downloaded!\n");
1636 sdio_release_host(card->func);
1637 sd_enable_host_int(priv);
1638 if (BT_STATUS_FAILURE == sbi_register_conf_dpc(priv)) {
1640 "BT: sbi_register_conf_dpc failed. Terminating download\n");
1641 ret = BT_STATUS_FAILURE;
1646 /* Check if other interface is downloading */
1647 ret = sd_check_winner_status(priv, &winner);
1648 if (ret == BT_STATUS_FAILURE) {
1649 PRINTM(FATAL, "BT read winner status failed!\n");
1653 PRINTM(MSG, "BT is not the winner (0x%x). Skip FW download\n",
1655 poll_num = MAX_MULTI_INTERFACE_POLL_TRIES;
1656 /* check if the fimware is downloaded successfully or not */
1657 if (sd_verify_fw_download(priv, poll_num)) {
1658 PRINTM(FATAL, "BT: FW failed to be active in time!\n");
1659 ret = BT_STATUS_FAILURE;
1662 sdio_release_host(card->func);
1663 sd_enable_host_int(priv);
1664 if (BT_STATUS_FAILURE == sbi_register_conf_dpc(priv)) {
1666 "BT: sbi_register_conf_dpc failed. Terminating download\n");
1667 ret = BT_STATUS_FAILURE;
1673 do_gettimeofday(&priv->req_fw_time);
1674 /* Download the main firmware via the helper firmware */
1675 if (sd_download_firmware_w_helper(priv)) {
1676 PRINTM(INFO, "BT: FW download failed!\n");
1677 ret = BT_STATUS_FAILURE;
1681 sdio_release_host(card->func);
1686 if (m_dev_bt->dev_pointer) {
1687 if (m_dev_bt->spec_type == IANYWHERE_SPEC)
1688 free_m_dev(m_dev_bt);
1690 if (m_dev_fm->dev_pointer)
1691 free_m_dev(m_dev_fm);
1692 if (m_dev_nfc->dev_pointer)
1693 free_m_dev(m_dev_nfc);
1699 * @brief This function checks the interrupt status and handle it accordingly.
1701 * @param priv A pointer to bt_private structure
1702 * @return BT_STATUS_SUCCESS
1705 sbi_get_int_status(bt_private * priv)
1707 int ret = BT_STATUS_SUCCESS;
1709 struct sdio_mmc_card *card = priv->bt_dev.card;
1714 sdio_ireg = priv->adapter->sd_ireg;
1715 priv->adapter->sd_ireg = 0;
1717 sdio_claim_host(card->func);
1718 priv->adapter->irq_done = sdio_ireg;
1719 if (sdio_ireg & DN_LD_HOST_INT_STATUS) { /* tx_done INT */
1720 if (priv->bt_dev.tx_dnld_rdy) { /* tx_done already received */
1722 "BT: warning: tx_done already received: tx_dnld_rdy=0x%x int status=0x%x\n",
1723 priv->bt_dev.tx_dnld_rdy, sdio_ireg);
1725 priv->bt_dev.tx_dnld_rdy = TRUE;
1728 if (sdio_ireg & UP_LD_HOST_INT_STATUS)
1729 sd_card_to_host(priv);
1731 ret = BT_STATUS_SUCCESS;
1732 sdio_release_host(card->func);
1738 * @brief This function wakeup firmware
1740 * @param priv A pointer to bt_private structure
1741 * @return BT_STATUS_SUCCESS/BT_STATUS_FAILURE or other error no.
1744 sbi_wakeup_firmware(bt_private * priv)
1746 struct sdio_mmc_card *card = priv->bt_dev.card;
1747 int ret = BT_STATUS_SUCCESS;
1751 if (!card || !card->func) {
1752 PRINTM(ERROR, "BT: card or function is NULL!\n");
1754 return BT_STATUS_FAILURE;
1756 sdio_claim_host(card->func);
1757 sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret);
1758 sdio_release_host(card->func);
1759 PRINTM(CMD, "BT wake up firmware\n");
1765 module_param(fw_name, charp, 0);
1766 MODULE_PARM_DESC(fw_name, "Firmware name");
1767 module_param(req_fw_nowait, int, 0);
1768 MODULE_PARM_DESC(req_fw_nowait,
1769 "0: Use request_firmware API; 1: Use request_firmware_nowait API");
1770 module_param(multi_fn, int, 4);
1771 MODULE_PARM_DESC(multi_fn, "Bit 2: FN2;");