Lines Matching defs:card
518 * The device node is saved in card->plt_of_node.
536 * the card structure, enables SDIO function number and initiates the
544 struct sdio_mmc_card *card = NULL;
549 card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL);
550 if (!card)
553 init_completion(&card->fw_done);
555 card->func = func;
557 func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
562 card->firmware = data->firmware;
563 card->firmware_sdiouart = data->firmware_sdiouart;
564 card->reg = data->reg;
565 card->max_ports = data->max_ports;
566 card->mp_agg_pkt_limit = data->mp_agg_pkt_limit;
567 card->supports_sdio_new_mode = data->supports_sdio_new_mode;
568 card->has_control_mask = data->has_control_mask;
569 card->tx_buf_size = data->tx_buf_size;
570 card->mp_tx_agg_buf_size = data->mp_tx_agg_buf_size;
571 card->mp_rx_agg_buf_size = data->mp_rx_agg_buf_size;
572 card->can_dump_fw = data->can_dump_fw;
573 card->fw_dump_enh = data->fw_dump_enh;
574 card->can_auto_tdls = data->can_auto_tdls;
575 card->can_ext_scan = data->can_ext_scan;
576 card->fw_ready_extra_delay = data->fw_ready_extra_delay;
577 INIT_WORK(&card->work, mwifiex_sdio_work);
596 ret = mwifiex_add_card(card, &card->fw_done, &sdio_ops,
599 dev_err(&func->dev, "add card failed\n");
618 * methods. Failing that the kernel simply removes the whole card.
626 struct sdio_mmc_card *card;
629 card = sdio_get_drvdata(func);
630 if (!card || !card->adapter) {
631 dev_err(dev, "resume: invalid card or adapter\n");
635 adapter = card->adapter;
654 /* Write data into SDIO card register. Caller claims SDIO device. */
664 /* This function writes data into SDIO card register.
669 struct sdio_mmc_card *card = adapter->card;
672 sdio_claim_host(card->func);
673 ret = mwifiex_write_reg_locked(card->func, reg, data);
674 sdio_release_host(card->func);
679 /* This function reads data from SDIO card register.
684 struct sdio_mmc_card *card = adapter->card;
688 sdio_claim_host(card->func);
689 val = sdio_readb(card->func, reg, &ret);
690 sdio_release_host(card->func);
697 /* This function writes multiple data into SDIO card memory.
705 struct sdio_mmc_card *card = adapter->card;
722 sdio_claim_host(card->func);
724 ret = sdio_writesb(card->func, ioport, buffer, blk_cnt * blk_size);
726 sdio_release_host(card->func);
731 /* This function reads multiple data from SDIO card memory.
736 struct sdio_mmc_card *card = adapter->card;
746 sdio_claim_host(card->func);
748 ret = sdio_readsb(card->func, buffer, ioport, blk_cnt * blk_size);
751 sdio_release_host(card->func);
761 struct sdio_mmc_card *card = adapter->card;
762 const struct mwifiex_sdio_card_reg *reg = card->reg;
775 /* This function checks the firmware status in card.
780 struct sdio_mmc_card *card = adapter->card;
798 if (card->fw_ready_extra_delay &&
814 struct sdio_mmc_card *card = adapter->card;
816 if (mwifiex_read_reg(adapter, card->reg->status_reg_0, &winner))
830 * This function removes the interface and frees up the card structure.
835 struct sdio_mmc_card *card;
841 card = sdio_get_drvdata(func);
842 if (!card)
845 wait_for_completion(&card->fw_done);
847 adapter = card->adapter;
871 * methods. Failing that the kernel simply removes the whole card.
879 struct sdio_mmc_card *card;
893 card = sdio_get_drvdata(func);
894 if (!card) {
895 dev_err(dev, "suspend: invalid card\n");
900 wait_for_completion(&card->fw_done);
902 adapter = card->adapter;
936 struct sdio_mmc_card *card;
938 card = sdio_get_drvdata(func);
940 &card->work_flags))
941 schedule_work(&card->work);
988 * This function wakes up the card.
990 * A host power up command is written to the card configuration
991 * register to wake up the card.
1002 * This function is called after the card has woken up.
1004 * The card configuration register is reset.
1017 struct sdio_mmc_card *card = adapter->card;
1020 sdio_claim_host(card->func);
1022 sdio_release_host(card->func);
1034 struct sdio_mmc_card *card = adapter->card;
1039 if (mwifiex_read_reg(adapter, card->reg->card_cfg_2_1_reg, ®))
1041 if (mwifiex_write_reg(adapter, card->reg->card_cfg_2_1_reg,
1046 if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_0, ®))
1048 if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_0,
1055 if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_1, ®))
1057 if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_1,
1074 struct sdio_mmc_card *card = adapter->card;
1078 if (card->supports_sdio_new_mode) {
1085 if (!mwifiex_read_reg(adapter, card->reg->io_port_0_reg, ®))
1090 if (!mwifiex_read_reg(adapter, card->reg->io_port_1_reg, ®))
1095 if (!mwifiex_read_reg(adapter, card->reg->io_port_2_reg, ®))
1104 if (mwifiex_read_reg(adapter, card->reg->host_int_rsr_reg, ®))
1106 if (mwifiex_write_reg(adapter, card->reg->host_int_rsr_reg,
1107 reg | card->reg->sdio_int_mask))
1111 if (mwifiex_read_reg(adapter, card->reg->card_misc_cfg_reg, ®))
1113 if (mwifiex_write_reg(adapter, card->reg->card_misc_cfg_reg,
1121 * This function sends data to the card.
1159 struct sdio_mmc_card *card = adapter->card;
1160 const struct mwifiex_sdio_card_reg *reg = card->reg;
1161 u32 rd_bitmap = card->mp_rd_bitmap;
1166 if (card->supports_sdio_new_mode) {
1174 if ((card->has_control_mask) &&
1175 (card->mp_rd_bitmap & CTRL_PORT_MASK)) {
1176 card->mp_rd_bitmap &= (u32) (~CTRL_PORT_MASK);
1180 *port, card->mp_rd_bitmap);
1184 if (!(card->mp_rd_bitmap & (1 << card->curr_rd_port)))
1188 card->mp_rd_bitmap &= (u32)(~(1 << card->curr_rd_port));
1189 *port = card->curr_rd_port;
1191 if (++card->curr_rd_port == card->max_ports)
1192 card->curr_rd_port = reg->start_rd_port;
1196 *port, rd_bitmap, card->mp_rd_bitmap);
1210 struct sdio_mmc_card *card = adapter->card;
1211 const struct mwifiex_sdio_card_reg *reg = card->reg;
1212 u32 wr_bitmap = card->mp_wr_bitmap;
1217 if (!(wr_bitmap & card->mp_data_port_mask)) {
1222 if (card->mp_wr_bitmap & (1 << card->curr_wr_port)) {
1223 card->mp_wr_bitmap &= (u32) (~(1 << card->curr_wr_port));
1224 *port = card->curr_wr_port;
1225 if (++card->curr_wr_port == card->mp_end_port)
1226 card->curr_wr_port = reg->start_wr_port;
1232 if ((card->has_control_mask) && (*port == CTRL_PORT)) {
1235 *port, card->curr_wr_port, wr_bitmap,
1236 card->mp_wr_bitmap);
1242 *port, wr_bitmap, card->mp_wr_bitmap);
1248 * This function polls the card status.
1253 struct sdio_mmc_card *card = adapter->card;
1258 if (mwifiex_read_reg(adapter, card->reg->poll_reg, &cs))
1267 "poll card status failed, tries = %d\n", tries);
1276 * written back to the card host interrupt mask register.
1280 struct sdio_mmc_card *card = adapter->card;
1281 struct sdio_func *func = card->func;
1284 mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg, 0);
1290 * This function reads the interrupt status from card.
1294 struct sdio_mmc_card *card = adapter->card;
1298 if (mwifiex_read_data_sync(adapter, card->mp_regs,
1299 card->reg->max_mp_regs,
1305 sdio_ireg = card->mp_regs[card->reg->host_int_status_reg];
1332 struct sdio_mmc_card *card;
1334 card = sdio_get_drvdata(func);
1335 if (!card || !card->adapter) {
1336 pr_err("int: func=%p card=%p adapter=%p\n",
1337 func, card, card ? card->adapter : NULL);
1340 adapter = card->adapter;
1352 * The host interrupt enable mask is written to the card
1357 struct sdio_mmc_card *card = adapter->card;
1358 struct sdio_func *func = card->func;
1372 ret = mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg,
1373 card->reg->host_int_enable);
1386 * This function sends a data buffer to the card.
1424 * This function downloads the firmware to the card.
1426 * Firmware is downloaded to the card in blocks. Every block download
1433 struct sdio_mmc_card *card = adapter->card;
1434 const struct mwifiex_sdio_card_reg *reg = card->reg;
1460 sdio_claim_host(card->func);
1571 sdio_release_host(card->func);
1728 * This function transfers received packets from card to driver, performing
1739 struct sdio_mmc_card *card = adapter->card;
1749 if ((card->has_control_mask) && (port == CTRL_PORT)) {
1759 if (!card->mpa_rx.enabled) {
1768 if ((!card->has_control_mask && (card->mp_rd_bitmap &
1769 card->reg->data_port_mask)) ||
1770 (card->has_control_mask && (card->mp_rd_bitmap &
1776 if (MP_RX_AGGR_IN_PROGRESS(card)) {
1777 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len)) {
1794 if (MP_RX_AGGR_IN_PROGRESS(card)) {
1796 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len))
1810 mp_rx_aggr_setup(card, rx_len, port);
1812 if (MP_RX_AGGR_PKT_LIMIT_REACHED(card) ||
1813 mp_rx_aggr_port_limit_reached(card)) {
1826 card->mpa_rx.pkt_cnt);
1828 if (card->supports_sdio_new_mode) {
1832 for (i = 0, port_count = 0; i < card->max_ports; i++)
1833 if (card->mpa_rx.ports & BIT(i))
1841 (port_count << 8)) + card->mpa_rx.start_port;
1844 (card->mpa_rx.ports << 4)) +
1845 card->mpa_rx.start_port;
1848 if (card->mpa_rx.pkt_cnt == 1)
1849 mport = adapter->ioport + card->mpa_rx.start_port;
1851 if (mwifiex_read_data_sync(adapter, card->mpa_rx.buf,
1852 card->mpa_rx.buf_len, mport, 1))
1855 curr_ptr = card->mpa_rx.buf;
1857 for (pind = 0; pind < card->mpa_rx.pkt_cnt; pind++) {
1858 u32 *len_arr = card->mpa_rx.len_arr;
1900 MP_RX_AGGR_BUF_RESET(card);
1914 card->mpa_rx.buf, rx_len,
1941 mp_rx_aggr_setup(card, rx_len, port);
1946 if (MP_RX_AGGR_IN_PROGRESS(card))
1947 MP_RX_AGGR_BUF_RESET(card);
1968 * In case of Rx packets received, the packets are uploaded from card to
1973 struct sdio_mmc_card *card = adapter->card;
1974 const struct mwifiex_sdio_card_reg *reg = card->reg;
2003 rx_len = card->mp_regs[reg->cmd_rd_len_1] << 8;
2004 rx_len |= (u16)card->mp_regs[reg->cmd_rd_len_0];
2038 bitmap = (u32) card->mp_regs[reg->wr_bitmap_l];
2039 bitmap |= ((u32) card->mp_regs[reg->wr_bitmap_u]) << 8;
2040 if (card->supports_sdio_new_mode) {
2042 ((u32) card->mp_regs[reg->wr_bitmap_1l]) << 16;
2044 ((u32) card->mp_regs[reg->wr_bitmap_1u]) << 24;
2046 card->mp_wr_bitmap = bitmap;
2050 card->mp_wr_bitmap);
2052 (card->mp_wr_bitmap & card->mp_data_port_mask)) {
2062 if (card->has_control_mask && adapter->cmd_sent) {
2065 card->mp_wr_bitmap |=
2066 (u32) card->mp_regs[reg->wr_bitmap_l] & CTRL_PORT_MASK;
2067 if (card->mp_wr_bitmap & CTRL_PORT_MASK)
2074 bitmap = (u32) card->mp_regs[reg->rd_bitmap_l];
2075 bitmap |= ((u32) card->mp_regs[reg->rd_bitmap_u]) << 8;
2076 if (card->supports_sdio_new_mode) {
2078 ((u32) card->mp_regs[reg->rd_bitmap_1l]) << 16;
2080 ((u32) card->mp_regs[reg->rd_bitmap_1u]) << 24;
2082 card->mp_rd_bitmap = bitmap;
2085 card->mp_rd_bitmap);
2096 rx_len = ((u16) card->mp_regs[len_reg_u]) << 8;
2097 rx_len |= (u16) card->mp_regs[len_reg_l];
2105 (card->mpa_rx.enabled &&
2107 card->mpa_rx.buf_size))) {
2156 * the aggregated packet to card.
2159 * buffer and then downloaded to the card. Previous unsent packets in the
2164 * The function will only download the packet to the card when aggregation
2172 struct sdio_mmc_card *card = adapter->card;
2181 if (!card->mpa_tx.enabled ||
2182 (card->has_control_mask && (port == CTRL_PORT)) ||
2183 (card->supports_sdio_new_mode && (port == CMD_PORT_SLCT))) {
2198 if (MP_TX_AGGR_IN_PROGRESS(card)) {
2199 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len)) {
2202 if (!(card->mp_wr_bitmap &
2203 (1 << card->curr_wr_port)) ||
2205 card, pkt_len + next_pkt_len))
2211 if (!(card->mp_wr_bitmap &
2212 (1 << card->curr_wr_port)))
2218 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len) &&
2219 (card->mp_wr_bitmap & (1 << card->curr_wr_port)))
2230 if (MP_TX_AGGR_IN_PROGRESS(card)) {
2234 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len))
2248 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
2250 if (MP_TX_AGGR_PKT_LIMIT_REACHED(card) ||
2251 mp_tx_aggr_port_limit_reached(card))
2259 __func__, card->mpa_tx.start_port,
2260 card->mpa_tx.ports);
2261 if (card->supports_sdio_new_mode) {
2265 for (i = 0, port_count = 0; i < card->max_ports; i++)
2266 if (card->mpa_tx.ports & BIT(i))
2274 (port_count << 8)) + card->mpa_tx.start_port;
2277 (card->mpa_tx.ports << 4)) +
2278 card->mpa_tx.start_port;
2281 if (card->mpa_tx.pkt_cnt == 1)
2282 mport = adapter->ioport + card->mpa_tx.start_port;
2284 ret = mwifiex_write_data_to_card(adapter, card->mpa_tx.buf,
2285 card->mpa_tx.buf_len, mport);
2292 adapter->dbg.last_mp_wr_bitmap[index] = card->mp_wr_bitmap;
2293 adapter->dbg.last_mp_wr_len[index] = card->mpa_tx.buf_len;
2294 adapter->dbg.last_mp_curr_wr_port[index] = card->curr_wr_port;
2296 MP_TX_AGGR_BUF_RESET(card);
2312 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
2319 * This function downloads data from driver to card.
2321 * Both commands and data packets are transferred to the card by this
2332 struct sdio_mmc_card *card = adapter->card;
2371 if (card->supports_sdio_new_mode)
2375 /* Transfer data to card */
2392 card->curr_wr_port = port;
2393 card->mp_wr_bitmap |= (u32)(1 << card->curr_wr_port);
2397 if (!(card->mp_wr_bitmap & (1 << card->curr_wr_port)))
2413 struct sdio_mmc_card *card = adapter->card;
2417 card->mpa_tx.buf = kzalloc(mpa_tx_buf_size, GFP_KERNEL);
2418 if (!card->mpa_tx.buf) {
2423 card->mpa_tx.buf_size = mpa_tx_buf_size;
2427 card->mpa_rx.buf = kzalloc(rx_buf_size, GFP_KERNEL);
2428 if (!card->mpa_rx.buf) {
2433 card->mpa_rx.buf_size = rx_buf_size;
2437 kfree(card->mpa_tx.buf);
2438 kfree(card->mpa_rx.buf);
2439 card->mpa_tx.buf_size = 0;
2440 card->mpa_rx.buf_size = 0;
2441 card->mpa_tx.buf = NULL;
2442 card->mpa_rx.buf = NULL;
2457 struct sdio_mmc_card *card = adapter->card;
2459 if (adapter->card) {
2460 card->adapter = NULL;
2461 sdio_claim_host(card->func);
2462 sdio_disable_func(card->func);
2463 sdio_release_host(card->func);
2475 struct sdio_mmc_card *card = adapter->card;
2476 struct sdio_func *func = card->func;
2477 const char *firmware = card->firmware;
2479 /* save adapter pointer in card */
2480 card->adapter = adapter;
2481 adapter->tx_buf_size = card->tx_buf_size;
2486 ret = sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE);
2497 if (card->firmware_sdiouart) {
2500 mwifiex_read_reg(adapter, card->reg->host_strap_reg, &val);
2501 if ((val & card->reg->host_strap_mask) == card->reg->host_strap_value)
2502 firmware = card->firmware_sdiouart;
2506 if (card->fw_dump_enh) {
2525 * - Initialize SDIO variables in card
2531 struct sdio_mmc_card *card = adapter->card;
2532 const struct mwifiex_sdio_card_reg *reg = card->reg;
2536 sdio_set_drvdata(card->func, card);
2543 mwifiex_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg);
2549 /* Initialize SDIO variables in card */
2550 card->mp_rd_bitmap = 0;
2551 card->mp_wr_bitmap = 0;
2552 card->curr_rd_port = reg->start_rd_port;
2553 card->curr_wr_port = reg->start_wr_port;
2555 card->mp_data_port_mask = reg->data_port_mask;
2557 card->mpa_tx.buf_len = 0;
2558 card->mpa_tx.pkt_cnt = 0;
2559 card->mpa_tx.start_port = 0;
2561 card->mpa_tx.enabled = 1;
2562 card->mpa_tx.pkt_aggr_limit = card->mp_agg_pkt_limit;
2564 card->mpa_rx.buf_len = 0;
2565 card->mpa_rx.pkt_cnt = 0;
2566 card->mpa_rx.start_port = 0;
2568 card->mpa_rx.enabled = 1;
2569 card->mpa_rx.pkt_aggr_limit = card->mp_agg_pkt_limit;
2572 card->mp_regs = kzalloc(reg->max_mp_regs, GFP_KERNEL);
2573 if (!card->mp_regs)
2576 card->mpa_rx.len_arr = kcalloc(card->mp_agg_pkt_limit,
2577 sizeof(*card->mpa_rx.len_arr),
2579 if (!card->mpa_rx.len_arr) {
2580 kfree(card->mp_regs);
2585 card->mp_tx_agg_buf_size,
2586 card->mp_rx_agg_buf_size);
2589 if (ret && (card->mp_tx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX ||
2590 card->mp_rx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX)) {
2599 card->mpa_tx.enabled = 0;
2600 card->mpa_rx.enabled = 0;
2604 adapter->auto_tdls = card->can_auto_tdls;
2605 adapter->ext_scan = card->can_ext_scan;
2614 struct sdio_mmc_card *card = adapter->card;
2616 MP_TX_AGGR_BUF_RESET(card);
2617 MP_RX_AGGR_BUF_RESET(card);
2621 * This function cleans up the allocated card buffers.
2630 struct sdio_mmc_card *card = adapter->card;
2632 cancel_work_sync(&card->work);
2634 kfree(card->mp_regs);
2635 kfree(card->mpa_rx.len_arr);
2636 kfree(card->mpa_tx.buf);
2637 kfree(card->mpa_rx.buf);
2641 * This function updates the MP end port in card.
2646 struct sdio_mmc_card *card = adapter->card;
2647 const struct mwifiex_sdio_card_reg *reg = card->reg;
2650 card->mp_end_port = port;
2652 card->mp_data_port_mask = reg->data_port_mask;
2655 for (i = 1; i <= card->max_ports - card->mp_end_port; i++)
2656 card->mp_data_port_mask &=
2657 ~(1 << (card->max_ports - i));
2660 card->curr_wr_port = reg->start_wr_port;
2664 port, card->mp_data_port_mask);
2669 struct sdio_mmc_card *card = adapter->card;
2670 struct sdio_func *func = card->func;
2675 clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
2676 clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags);
2680 ret = mmc_hw_reset(func->card);
2704 struct sdio_mmc_card *card = adapter->card;
2708 sdio_writeb(card->func, card->reg->fw_dump_host_ready,
2709 card->reg->fw_dump_ctrl, &ret);
2715 ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl,
2725 if (ctrl_data != card->reg->fw_dump_host_ready) {
2728 sdio_writeb(card->func, card->reg->fw_dump_host_ready,
2729 card->reg->fw_dump_ctrl, &ret);
2737 if (ctrl_data == card->reg->fw_dump_host_ready) {
2749 struct sdio_mmc_card *card = adapter->card;
2756 if (!card->can_dump_fw)
2770 sdio_claim_host(card->func);
2778 reg = card->reg->fw_dump_start;
2780 dump_num = sdio_readb(card->func, reg, &ret);
2795 reg = card->reg->fw_dump_start;
2797 read_reg = sdio_readb(card->func, reg, &ret);
2809 card->reg->fw_dump_ctrl,
2840 reg_start = card->reg->fw_dump_start;
2841 reg_end = card->reg->fw_dump_end;
2843 *dbg_ptr = sdio_readb(card->func, reg, &ret);
2867 sdio_release_host(card->func);
2872 struct sdio_mmc_card *card = adapter->card;
2880 if (!card->fw_dump_enh)
2890 sdio_claim_host(card->func);
2898 reg_start = card->reg->fw_dump_start;
2899 reg_end = card->reg->fw_dump_end;
2902 start_flag = sdio_readb(card->func, reg, &ret);
2938 *dbg_ptr = sdio_readb(card->func, reg, &ret);
2981 sdio_release_host(card->func);
2986 struct sdio_mmc_card *card = adapter->card;
2996 if (card->fw_dump_enh)
3006 struct sdio_mmc_card *card =
3010 &card->work_flags))
3011 mwifiex_sdio_device_dump_work(card->adapter);
3013 &card->work_flags))
3014 mwifiex_sdio_card_reset_work(card->adapter);
3017 /* This function resets the card */
3020 struct sdio_mmc_card *card = adapter->card;
3022 if (!test_and_set_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags))
3023 schedule_work(&card->work);
3029 struct sdio_mmc_card *card = adapter->card;
3032 &card->work_flags))
3033 schedule_work(&card->work);
3043 struct sdio_mmc_card *cardp = adapter->card;
3134 struct sdio_mmc_card *card = adapter->card;
3137 sdio_claim_host(card->func);
3138 sdio_enable_func(card->func);
3139 sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE);
3140 sdio_release_host(card->func);
3145 adapter->tx_buf_size = card->tx_buf_size;
3151 mwifiex_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg);
3154 dev_err(&card->func->dev, "error enabling SDIO port\n");