Linux驱动——sdio type card（八）

朴灿烈づ我的快乐病毒、 2022-09-16 15:29 763阅读 0赞

Linux驱动——sdio type card（八）

备注：
  1. Kernel版本：5.4
  2. 使用工具：Source Insight 4.0

文章目录

  • Linux驱动——sdio type card（八）
    • 概述
    • 数据结构
      • mmc_sdio_ops
    • 核心接口说明
      • sdio type card匹配相关
        • mmc_attach_sdio
        • mmc_sdio_init_card
      • sdio ops相关函数
        • mmc_send_io_op_cond
        • mmc_io_rw_direct
        • mmc_io_rw_extended
        • sdio_reset
      • sdio irq相关函数
        • 注册sdio_irq——sdio_claim_irq
        • 释放sdio_irq——sdio_release_irq
        • 创建sdio_irq_thread——sdio_card_irq_get
        • 实现sdio_irq_thread——sdio_irq_thread
      • sdio io相关函数
        • host相关
        • sdio func相关
        • 块配置相关
        • IO读写相关

概述

  card相关模块为对应card实现相应的操作，包括初始化操作、以及对应的总线操作集合。负责和对应card协议层相关的东西。
sdio type card相关代码：

  1. drivers/mmc/core/sdio.c（提供接口）
  2. drivers/mmc/core/sdio_ops.c（提供和sdio type card协议相关的操作）
  3. drivers/mmc/core/sdio_irq.c（提供sdio irq相关功能的操作）
  4. drivers/mmc/core/sdio_cis.c（提供sdio cis相关功能的操作）
  5. drivers/mmc/core/sdio_ops.h

数据结构

mmc_sdio_ops

  1. static const struct mmc_bus_ops mmc_sdio_ops = {
  2.     .remove = mmc_sdio_remove,
  3.     .detect = mmc_sdio_detect,
  4.     .pre_suspend = mmc_sdio_pre_suspend,
  5.     .suspend = mmc_sdio_suspend,
  6.     .resume = mmc_sdio_resume,
  7.     .runtime_suspend = mmc_sdio_runtime_suspend,
  8.     .runtime_resume = mmc_sdio_runtime_resume,
  9.     .alive = mmc_sdio_alive,
  10.     .hw_reset = mmc_sdio_hw_reset,
  11.     .sw_reset = mmc_sdio_sw_reset,
  12. };

核心接口说明

sdio type card匹配相关

mmc_attach_sdio

  1. /*
  2.  * Starting point for SDIO card init.
  3.  */
  4. int mmc_attach_sdio(struct mmc_host *host)
  5. {
  6.     int err, i, funcs;
  7.     u32 ocr, rocr;
  8.     struct mmc_card *card;
  10.     WARN_ON(!host->claimed);
  12.     /*
  13.      * 
  14.      * 以下部分，连同mmc_rescan_try_freq中的
  15.      * mmc_go_idle和mmc_send_if_cond一起构成了
  16.      * “尝试获取一个合适的工作电压” 的任务 
  17.      */
  19.     // host发送参数为0的ACMD41命令，提取response中的VHS，
  20.     // 得到card支持的工作电压范围
  22.     err = mmc_send_io_op_cond(host, 0, &ocr);
  23.     if (err)
  24.         return err;
  26.     //创建sd_ops，host->bus_ops指向mmc_sdio_ops
  27.     mmc_attach_bus(host, &mmc_sdio_ops);
  28.     if (host->ocr_avail_sdio)
  29.         host->ocr_avail = host->ocr_avail_sdio;
  31.     // host选择一个card和host都支持的最低的工作电压，
  32.     // 并将host提供给card的工作电压设置为这个值。
  33.     // 后续就以host->ocr作为工作电压对sd card进行初始化
  34.     rocr = mmc_select_voltage(host, ocr);
  36.     /*
  37.      * Can we support the voltage(s) of the card(s)?
  38.      */
  39.     if (!rocr) {
  40.         err = -EINVAL;
  41.         goto err;
  42.     }
  44.     /*
  45.      * Detect and init the card.
  46.      */
  47.     /** 上述已经完成了card的识别操作，并且为card选择了一个合适的工作电压 **/
  48.     /** 后续调用mmc_sdio_init_card对sdio card进行初始化，也就是代码核心 **/
  49.     err = mmc_sdio_init_card(host, rocr, NULL);
  50.     if (err)
  51.         goto err;
  53.     card = host->card;
  55.     /*
  56.      * Enable runtime PM only if supported by host+card+board
  57.      */
  58.     if (host->caps & MMC_CAP_POWER_OFF_CARD) {
  59.         /*
  60.          * Do not allow runtime suspend until after SDIO function
  61.          * devices are added.
  62.          */
  63.         pm_runtime_get_noresume(&card->dev);
  65.         /*
  66.          * Let runtime PM core know our card is active
  67.          */
  68.         err = pm_runtime_set_active(&card->dev);
  69.         if (err)
  70.             goto remove;
  72.         /*
  73.          * Enable runtime PM for this card
  74.          */
  75.         pm_runtime_enable(&card->dev);
  76.     }
  78.     /*
  79.      * The number of functions on the card is encoded inside
  80.      * the ocr.
  81.      */
  82.     // 根据ocr寄存器获取func数目
  83.     funcs = (ocr & 0x70000000) >> 28;
  84.     card->sdio_funcs = 0;
  86.     /*
  87.      * Initialize (but don't add) all present functions.
  88.      */
  89.     // 初始化sdio_func
  90.     for (i = 0; i < funcs; i++, card->sdio_funcs++) {
  91.         err = sdio_init_func(host->card, i + 1);
  92.         if (err)
  93.             goto remove;
  95.         /*
  96.          * Enable Runtime PM for this func (if supported)
  97.          */
  98.         if (host->caps & MMC_CAP_POWER_OFF_CARD)
  99.             pm_runtime_enable(&card->sdio_func[i]->dev);
  100.     }
  102.     /*
  103.      * First add the card to the driver model...
  104.      */
  105.     mmc_release_host(host);
  107.     // 将sd card添加到device中
  108.     err = mmc_add_card(host->card);
  109.     if (err)
  110.         goto remove_added;
  112.     /*
  113.      * ...then the SDIO functions.
  114.      */
  115.     //注册 sdio_func 到driver中
  116.     for (i = 0;i < funcs;i++) {
  117.         err = sdio_add_func(host->card->sdio_func[i]);
  118.         if (err)
  119.             goto remove_added;
  120.     }
  122.     if (host->caps & MMC_CAP_POWER_OFF_CARD)
  123.         pm_runtime_put(&card->dev);
  125.     mmc_claim_host(host);
  126.     return 0;
  129. remove:
  130.     mmc_release_host(host);
  131. remove_added:
  132.     /*
  133.      * The devices are being deleted so it is not necessary to disable
  134.      * runtime PM. Similarly we also don't pm_runtime_put() the SDIO card
  135.      * because it needs to be active to remove any function devices that
  136.      * were probed, and after that it gets deleted.
  137.      */
  138.     mmc_sdio_remove(host);
  139.     mmc_claim_host(host);
  140. err:
  141.     mmc_detach_bus(host);
  143.     pr_err("%s: error %d whilst initialising SDIO card\n",
  144.         mmc_hostname(host), err);
  146.     return err;
  147. }

mmc_sdio_init_card

  1. /*
  2.  * Handle the detection and initialisation of a card.
  3.  *
  4.  * In the case of a resume, "oldcard" will contain the card
  5.  * we're trying to reinitialise.
  6.  */
  7. static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
  8.                   struct mmc_card *oldcard)
  9. {
  10.     struct mmc_card *card;
  11.     int err;
  12.     int retries = 10;
  13.     u32 rocr = 0;
  14.     u32 ocr_card = ocr;
  16.     WARN_ON(!host->claimed);
  18.     /* to query card if 1.8V signalling is supported */
  19.     if (mmc_host_uhs(host))
  20.         ocr |= R4_18V_PRESENT;
  22. try_again:
  23.     /** 在mmc_sd_get_cid中完成如下工作：：： **/
  24.     /** 重新复位，完成card的内部初始化 **/
  25.     /** 设置信号电压，包括card和host的设置 **/
  26.     /** 获取card的CID值 **/
  27.     // 调用mmc_sd_get_cid进行复位、内部初始化，
  28.     // 设置信号电压，然后获取CID值，
  29.     // 最终card进入了identification state。
  31.     if (!retries) {
  32.         pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
  33.         ocr &= ~R4_18V_PRESENT;
  34.     }
  36.     /*
  37.      * Inform the card of the voltage
  38.      */
  39.     err = mmc_send_io_op_cond(host, ocr, &rocr);
  40.     if (err)
  41.         return err;
  43.     /*
  44.      * For SPI, enable CRC as appropriate.
  45.      */
  46.     if (mmc_host_is_spi(host)) {
  47.         err = mmc_spi_set_crc(host, use_spi_crc);
  48.         if (err)
  49.             return err;
  50.     }
  52.     /*
  53.      * Allocate card structure.
  54.      */
  55.     card = mmc_alloc_card(host, NULL);
  56.     if (IS_ERR(card))
  57.         return PTR_ERR(card);
  59.     if ((rocr & R4_MEMORY_PRESENT) &&
  60.         mmc_sd_get_cid(host, ocr & rocr, card->raw_cid, NULL) == 0) {
  61.         card->type = MMC_TYPE_SD_COMBO;
  63.         if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO ||
  64.             memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) {
  65.             err = -ENOENT;
  66.             goto mismatch;
  67.         }
  68.     } else {
  69.         card->type = MMC_TYPE_SDIO;
  71.         if (oldcard && oldcard->type != MMC_TYPE_SDIO) {
  72.             err = -ENOENT;
  73.             goto mismatch;
  74.         }
  75.     }
  77.     /*
  78.      * Call the optional HC's init_card function to handle quirks.
  79.      */
  80.     if (host->ops->init_card)
  81.         host->ops->init_card(host, card);
  83.     /*
  84.      * If the host and card support UHS-I mode request the card
  85.      * to switch to 1.8V signaling level.  No 1.8v signalling if
  86.      * UHS mode is not enabled to maintain compatibility and some
  87.      * systems that claim 1.8v signalling in fact do not support
  88.      * it. Per SDIO spec v3, section 3.1.2, if the voltage is already
  89.      * 1.8v, the card sets S18A to 0 in the R4 response. So it will
  90.      * fails to check rocr & R4_18V_PRESENT,  but we still need to
  91.      * try to init uhs card. sdio_read_cccr will take over this task
  92.      * to make sure which speed mode should work.
  93.      */
  94.     if (rocr & ocr & R4_18V_PRESENT) {
  95.         err = mmc_set_uhs_voltage(host, ocr_card);
  96.         if (err == -EAGAIN) {
  97.             mmc_sdio_resend_if_cond(host, card);
  98.             retries--;
  99.             goto try_again;
  100.         } else if (err) {
  101.             ocr &= ~R4_18V_PRESENT;
  102.         }
  103.     }
  105.     /*
  106.      * For native busses:  set card RCA and quit open drain mode.
  107.      */
  108.     if (!mmc_host_is_spi(host)) {
  109.         err = mmc_send_relative_addr(host, &card->rca);
  110.         if (err)
  111.             goto remove;
  113.         /*
  114.          * Update oldcard with the new RCA received from the SDIO
  115.          * device -- we're doing this so that it's updated in the
  116.          * "card" struct when oldcard overwrites that later.
  117.          */
  118.         if (oldcard)
  119.             oldcard->rca = card->rca;
  120.     }
  122.     /*
  123.      * Read CSD, before selecting the card
  124.      */
  125.     if (!oldcard && card->type == MMC_TYPE_SD_COMBO) {
  126.         err = mmc_sd_get_csd(host, card);
  127.         if (err)
  128.             goto remove;
  130.         mmc_decode_cid(card);
  131.     }
  133.     /*
  134.      * Select card, as all following commands rely on that.
  135.      */
  136.     if (!mmc_host_is_spi(host)) {
  137.         err = mmc_select_card(card);
  138.         if (err)
  139.             goto remove;
  140.     }
  142.     if (card->quirks & MMC_QUIRK_NONSTD_SDIO) {
  143.         /*
  144.          * This is non-standard SDIO device, meaning it doesn't
  145.          * have any CIA (Common I/O area) registers present.
  146.          * It's host's responsibility to fill cccr and cis
  147.          * structures in init_card().
  148.          */
  149.         mmc_set_clock(host, card->cis.max_dtr);
  151.         if (card->cccr.high_speed) {
  152.             mmc_set_timing(card->host, MMC_TIMING_SD_HS);
  153.         }
  155.         if (oldcard)
  156.             mmc_remove_card(card);
  157.         else
  158.             host->card = card;
  160.         return 0;
  161.     }
  163.     /*
  164.      * Read the common registers. Note that we should try to
  165.      * validate whether UHS would work or not.
  166.      */
  167.     err = sdio_read_cccr(card, ocr);
  168.     if (err) {
  169.         mmc_sdio_resend_if_cond(host, card);
  170.         if (ocr & R4_18V_PRESENT) {
  171.             /* Retry init sequence, but without R4_18V_PRESENT. */
  172.             retries = 0;
  173.             goto try_again;
  174.         }
  175.         return err;
  176.     }
  178.     /*
  179.      * Read the common CIS tuples.
  180.      */
  181.     // 获取card CIS 值
  182.     err = sdio_read_common_cis(card);
  183.     if (err)
  184.         goto remove;
  186.     if (oldcard) {
  187.         if (card->cis.vendor == oldcard->cis.vendor &&
  188.             card->cis.device == oldcard->cis.device) {
  189.             mmc_remove_card(card);
  190.             card = oldcard;
  191.         } else {
  192.             err = -ENOENT;
  193.             goto mismatch;
  194.         }
  195.     }
  196.     card->ocr = ocr_card;
  197.     mmc_fixup_device(card, sdio_fixup_methods);
  200.     /** 获取sd card的配置寄存器和状态寄存器 **/
  201.     /** 读取card 的switch状态，也就是其支持的function **/
  202.     // host发送ACMD51命令，要求card回复其SCR寄存器（SD configuration register）的值
  203.     // host发送ACMD13命令，要求card回复其SSR寄存器（SD status regiter）的值
  204.     // host发送CMD6命令来读取card switch status。
  205.     // 通过card switch status可以得到card支持的总线速度模式以及驱动强度类型。
  206.     if (card->type == MMC_TYPE_SD_COMBO) {
  207.         err = mmc_sd_setup_card(host, card, oldcard != NULL);
  208.         /* handle as SDIO-only card if memory init failed */
  209.         if (err) {
  210.             mmc_go_idle(host);
  211.             if (mmc_host_is_spi(host))
  212.                 /* should not fail, as it worked previously */
  213.                 mmc_spi_set_crc(host, use_spi_crc);
  214.             card->type = MMC_TYPE_SDIO;
  215.         } else
  216.             card->dev.type = &sd_type;
  217.     }
  219.     /*
  220.      * If needed, disconnect card detection pull-up resistor.
  221.      */
  222.     // 关闭 card detection 功能
  223.     err = sdio_disable_cd(card);
  224.     if (err)
  225.         goto remove;
  227.     /* Initialization sequence for UHS-I cards */
  228.     /* Only if card supports 1.8v and UHS signaling */
  229.     // 切换到sdio highspeed 模式、配置时钟速率、配置数据总线宽度
  230.     if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
  231.         err = mmc_sdio_init_uhs_card(card);
  232.         if (err)
  233.             goto remove;
  234.     } else {
  235.         /*
  236.          * Switch to high-speed (if supported).
  237.          */
  238.         err = sdio_enable_hs(card);
  239.         if (err > 0)
  240.             mmc_set_timing(card->host, MMC_TIMING_SD_HS);
  241.         else if (err)
  242.             goto remove;
  244.         /*
  245.          * Change to the card's maximum speed.
  246.          */
  247.         mmc_set_clock(host, mmc_sdio_get_max_clock(card));
  249.         /*
  250.          * Switch to wider bus (if supported).
  251.          */
  252.         err = sdio_enable_4bit_bus(card);
  253.         if (err)
  254.             goto remove;
  255.     }
  257.     if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
  258.         host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
  259.         pr_err("%s: Host failed to negotiate down from 3.3V\n",
  260.             mmc_hostname(host));
  261.         err = -EINVAL;
  262.         goto remove;
  263.     }
  265.     host->card = card;
  266.     return 0;
  268. mismatch:
  269.     pr_debug("%s: Perhaps the card was replaced\n", mmc_hostname(host));
  270. remove:
  271.     if (oldcard != card)
  272.         mmc_remove_card(card);
  273.     return err;
  274. }

sdio ops相关函数

mmc_send_io_op_cond

  1. int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
  2. {
  3.     struct mmc_command cmd = {};
  4.     int i, err = 0;
  6.     cmd.opcode = SD_IO_SEND_OP_COND;
  7.     cmd.arg = ocr;
  8.     cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
  10.     for (i = 100; i; i--) {
  11.         err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
  12.         if (err)
  13.             break;
  15.         /* if we're just probing, do a single pass */
  16.         if (ocr == 0)
  17.             break;
  19.         /* otherwise wait until reset completes */
  20.         if (mmc_host_is_spi(host)) {
  21.             /*
  22.              * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate
  23.              * an initialized card under SPI, but some cards
  24.              * (Marvell's) only behave when looking at this
  25.              * one.
  26.              */
  27.             if (cmd.resp[1] & MMC_CARD_BUSY)
  28.                 break;
  29.         } else {
  30.             if (cmd.resp[0] & MMC_CARD_BUSY)
  31.                 break;
  32.         }
  34.         err = -ETIMEDOUT;
  36.         mmc_delay(10);
  37.     }
  39.     if (rocr)
  40.         *rocr = cmd.resp[mmc_host_is_spi(host) ? 1 : 0];
  42.     return err;
  43. }

mmc_io_rw_direct

  1. int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
  2.     unsigned addr, u8 in, u8 *out)
  3. {
  4.     return mmc_io_rw_direct_host(card->host, write, fn, addr, in, out);
  5. }
  7. static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
  8.     unsigned addr, u8 in, u8 *out)
  9. {
  10.     struct mmc_command cmd = {};
  11.     int err;
  13.     if (fn > 7)
  14.         return -EINVAL;
  16.     /* sanity check */
  17.     if (addr & ~0x1FFFF)
  18.         return -EINVAL;
  20.     cmd.opcode = SD_IO_RW_DIRECT;
  21.     cmd.arg = write ? 0x80000000 : 0x00000000;
  22.     cmd.arg |= fn << 28;
  23.     cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
  24.     cmd.arg |= addr << 9;
  25.     cmd.arg |= in;
  26.     cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
  28.     err = mmc_wait_for_cmd(host, &cmd, 0);
  29.     if (err)
  30.         return err;
  32.     if (mmc_host_is_spi(host)) {
  33.         /* host driver already reported errors */
  34.     } else {
  35.         if (cmd.resp[0] & R5_ERROR)
  36.             return -EIO;
  37.         if (cmd.resp[0] & R5_FUNCTION_NUMBER)
  38.             return -EINVAL;
  39.         if (cmd.resp[0] & R5_OUT_OF_RANGE)
  40.             return -ERANGE;
  41.     }
  43.     if (out) {
  44.         if (mmc_host_is_spi(host))
  45.             *out = (cmd.resp[0] >> 8) & 0xFF;
  46.         else
  47.             *out = cmd.resp[0] & 0xFF;
  48.     }
  50.     return 0;
  51. }

mmc_io_rw_extended

  1. int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
  2.     unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
  3. {
  4.     struct mmc_request mrq = {};
  5.     struct mmc_command cmd = {};
  6.     struct mmc_data data = {};
  7.     struct scatterlist sg, *sg_ptr;
  8.     struct sg_table sgtable;
  9.     unsigned int nents, left_size, i;
  10.     unsigned int seg_size = card->host->max_seg_size;
  11.     int err;
  13.     WARN_ON(blksz == 0);
  15.     /* sanity check */
  16.     if (addr & ~0x1FFFF)
  17.         return -EINVAL;
  19.     mrq.cmd = &cmd;
  20.     mrq.data = &data;
  22.     cmd.opcode = SD_IO_RW_EXTENDED;                    // cmd53
  23.     cmd.arg = write ? 0x80000000 : 0x00000000;        // 读写方向
  24.     cmd.arg |= fn << 28;                            // func->num
  25.     cmd.arg |= incr_addr ? 0x04000000 : 0x00000000;
  26.     cmd.arg |= addr << 9;                            // 块地址
  27.     if (blocks == 0)
  28.         cmd.arg |= (blksz == 512) ? 0 : blksz;    /* byte mode */
  29.     else
  30.         cmd.arg |= 0x08000000 | blocks;        /* block mode */
  31.     cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
  33.     data.blksz = blksz; // 配置块大小
  34.     /* Code in host drivers/fwk assumes that "blocks" always is >=1 */
  35.     data.blocks = blocks ? blocks : 1; // 配置块数量
  36.     data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
  38.     left_size = data.blksz * data.blocks;
  39.     nents = DIV_ROUND_UP(left_size, seg_size);
  40.     if (nents > 1) {
  41.         if (sg_alloc_table(&sgtable, nents, GFP_KERNEL))
  42.             return -ENOMEM;
  44.         data.sg = sgtable.sgl;
  45.         data.sg_len = nents;
  47.         for_each_sg(data.sg, sg_ptr, data.sg_len, i) {
  48.             sg_set_buf(sg_ptr, buf + i * seg_size,
  49.                    min(seg_size, left_size));
  50.             left_size -= seg_size;
  51.         }
  52.     } else {
  53.         data.sg = &sg;
  54.         data.sg_len = 1;
  56.         //初始化sg，找到buf对应的物理页地址，为DMA传输做准备
  57.         sg_init_one(&sg, buf, left_size);
  58.     }
  60.     mmc_set_data_timeout(&data, card);
  62.     mmc_pre_req(card->host, &mrq);
  64.     //发送数据，并且等待返回
  65.     mmc_wait_for_req(card->host, &mrq);
  67.     if (cmd.error)
  68.         err = cmd.error;
  69.     else if (data.error)
  70.         err = data.error;
  71.     else if (mmc_host_is_spi(card->host))
  72.         /* host driver already reported errors */
  73.         err = 0;
  74.     else if (cmd.resp[0] & R5_ERROR)//返回数据处理R5
  75.         err = -EIO;
  76.     else if (cmd.resp[0] & R5_FUNCTION_NUMBER)
  77.         err = -EINVAL;
  78.     else if (cmd.resp[0] & R5_OUT_OF_RANGE)
  79.         err = -ERANGE;
  80.     else
  81.         err = 0;
  83.     mmc_post_req(card->host, &mrq, err);
  85.     if (nents > 1)
  86.         sg_free_table(&sgtable);
  88.     return err;
  89. }

sdio_reset

  1. int sdio_reset(struct mmc_host *host)
  2. {
  3.     int ret;
  4.     u8 abort;
  6.     /* SDIO Simplified Specification V2.0, 4.4 Reset for SDIO */
  8.     ret = mmc_io_rw_direct_host(host, 0, 0, SDIO_CCCR_ABORT, 0, &abort);
  9.     if (ret)
  10.         abort = 0x08;
  11.     else
  12.         abort |= 0x08;
  14.     return mmc_io_rw_direct_host(host, 1, 0, SDIO_CCCR_ABORT, abort, NULL);
  15. }

sdio irq相关函数

注册sdio_irq——sdio_claim_irq

  1. /**
  2.  *    sdio_claim_irq - claim the IRQ for a SDIO function
  3.  *    @func: SDIO function
  4.  *    @handler: IRQ handler callback
  5.  *
  6.  *    Claim and activate the IRQ for the given SDIO function. The provided
  7.  *    handler will be called when that IRQ is asserted.  The host is always
  8.  *    claimed already when the handler is called so the handler should not
  9.  *    call sdio_claim_host() or sdio_release_host().
  10.  */
  11. int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler)
  12. {
  13.     int ret;
  14.     unsigned char reg;
  16.     if (!func)
  17.         return -EINVAL;
  19.     pr_debug("SDIO: Enabling IRQ for %s...\n", sdio_func_id(func));
  21.     // sdio_func已注册中断，则为异常
  22.     if (func->irq_handler) { 
  23.         pr_debug("SDIO: IRQ for %s already in use.\n", sdio_func_id(func));
  24.         return -EBUSY;
  25.     }
  27.     // 获取中断使能寄存器值
  28.     ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
  29.     if (ret)
  30.         return ret;
  32.     reg |= 1 << func->num;
  34.     reg |= 1; /* Master interrupt enable */
  35.     // 使能中断
  36.     ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
  37.     if (ret)
  38.         return ret;
  40.     func->irq_handler = handler;
  41.     // 创建sdio_irq_thread内核线程
  42.     ret = sdio_card_irq_get(func->card);
  43.     if (ret)
  44.         func->irq_handler = NULL;
  46.     // 配置sdio_single_irq
  47.     sdio_single_irq_set(func->card);
  49.     return ret;
  50. }
  51. EXPORT_SYMBOL_GPL(sdio_claim_irq);

释放sdio_irq——sdio_release_irq

  1. /**
  2.  *    sdio_release_irq - release the IRQ for a SDIO function
  3.  *    @func: SDIO function
  4.  *
  5.  *    Disable and release the IRQ for the given SDIO function.
  6.  */
  7. int sdio_release_irq(struct sdio_func *func)
  8. {
  9.     int ret;
  10.     unsigned char reg;
  12.     if (!func)
  13.         return -EINVAL;
  15.     pr_debug("SDIO: Disabling IRQ for %s...\n", sdio_func_id(func));
  17.     if (func->irq_handler) {
  18.         func->irq_handler = NULL;
  19.         sdio_card_irq_put(func->card);
  20.         sdio_single_irq_set(func->card);
  21.     }
  23.     ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
  24.     if (ret)
  25.         return ret;
  27.     reg &= ~(1 << func->num);
  29.     /* Disable master interrupt with the last function interrupt */
  30.     if (!(reg & 0xFE))
  31.         reg = 0;
  33.     ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
  34.     if (ret)
  35.         return ret;
  37.     return 0;
  38. }
  39. EXPORT_SYMBOL_GPL(sdio_release_irq);

创建sdio_irq_thread——sdio_card_irq_get

  1. static int sdio_card_irq_get(struct mmc_card *card)
  2. {
  3.     struct mmc_host *host = card->host;
  5.     WARN_ON(!host->claimed);
  7.     if (!host->sdio_irqs++) {
  8.         if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD)) {
  9.             atomic_set(&host->sdio_irq_thread_abort, 0);
  10.             //创建sdio irq thread 内核线程
  11.             host->sdio_irq_thread =
  12.                 kthread_run(sdio_irq_thread, host,
  13.                         "ksdioirqd/%s", mmc_hostname(host));
  14.             if (IS_ERR(host->sdio_irq_thread)) {
  15.                 int err = PTR_ERR(host->sdio_irq_thread);
  16.                 host->sdio_irqs--;
  17.                 return err;
  18.             }
  19.         } else if (host->caps & MMC_CAP_SDIO_IRQ) {
  20.             host->ops->enable_sdio_irq(host, 1);
  21.         }
  22.     }
  24.     return 0;
  25. }

实现sdio_irq_thread——sdio_irq_thread

  1. static int sdio_irq_thread(void *_host)
  2. {
  3.     struct mmc_host *host = _host;
  4.     struct sched_param param = { .sched_priority = 1 };
  5.     unsigned long period, idle_period;
  6.     int ret;
  8.     // 将sdio irq thread线程为实时线程FIFO，优先级为1
  9.     sched_setscheduler(current, SCHED_FIFO, &param);
  11.     /*
  12.      * We want to allow for SDIO cards to work even on non SDIO
  13.      * aware hosts.  One thing that non SDIO host cannot do is
  14.      * asynchronous notification of pending SDIO card interrupts
  15.      * hence we poll for them in that case.
  16.      */
  17.     // 轮询运行时间为10ms
  18.     idle_period = msecs_to_jiffies(10);
  19.     // 若host支持硬件sdio_irq，则为中断模式，否则为轮询模式，10ms调度一次
  20.     period = (host->caps & MMC_CAP_SDIO_IRQ) ?
  21.         MAX_SCHEDULE_TIMEOUT : idle_period;
  23.     pr_debug("%s: IRQ thread started (poll period = %lu jiffies)\n",
  24.          mmc_hostname(host), period);
  26.     do {
  27.         /*
  28.          * We claim the host here on drivers behalf for a couple
  29.          * reasons:
  30.          *
  31.          * 1) it is already needed to retrieve the CCCR_INTx;
  32.          * 2) we want the driver(s) to clear the IRQ condition ASAP;
  33.          * 3) we need to control the abort condition locally.
  34.          *
  35.          * Just like traditional hard IRQ handlers, we expect SDIO
  36.          * IRQ handlers to be quick and to the point, so that the
  37.          * holding of the host lock does not cover too much work
  38.          * that doesn't require that lock to be held.
  39.          */
  40.         // 获取host的使用权
  41.         ret = __mmc_claim_host(host, NULL,
  42.                        &host->sdio_irq_thread_abort);
  43.         if (ret)
  44.             break;
  45.         // 调用sdio_fun irq_handler函数或获取sdio card status再调用sdio_func
  46.         ret = process_sdio_pending_irqs(host);
  48.         // 释放host的使用权
  49.         mmc_release_host(host);
  51.         /*
  52.          * Give other threads a chance to run in the presence of
  53.          * errors.
  54.          */
  55.         if (ret < 0) {
  56.             set_current_state(TASK_INTERRUPTIBLE);
  57.             if (!kthread_should_stop())
  58.                 schedule_timeout(HZ);
  59.             set_current_state(TASK_RUNNING);
  60.         }
  62.         /*
  63.          * Adaptive polling frequency based on the assumption
  64.          * that an interrupt will be closely followed by more.
  65.          * This has a substantial benefit for network devices.
  66.          */
  67.         if (!(host->caps & MMC_CAP_SDIO_IRQ)) {
  68.             if (ret > 0)
  69.                 period /= 2;
  70.             else {
  71.                 period++;
  72.                 if (period > idle_period)
  73.                     period = idle_period;
  74.             }
  75.         }
  77.         set_current_state(TASK_INTERRUPTIBLE);
  79.         // 处理完sdio card中的数据，若支持sdio_irq，则使能sdio_irq
  80.         if (host->caps & MMC_CAP_SDIO_IRQ)
  81.             host->ops->enable_sdio_irq(host, 1);
  82.         if (!kthread_should_stop())
  83.             schedule_timeout(period);
  84.         set_current_state(TASK_RUNNING);
  85.     } while (!kthread_should_stop());
  87.     // 支持sdio_irq，则关闭sdio_irq
  88.     if (host->caps & MMC_CAP_SDIO_IRQ)
  89.         host->ops->enable_sdio_irq(host, 0);
  91.     pr_debug("%s: IRQ thread exiting with code %d\n",
  92.          mmc_hostname(host), ret);
  94.     return ret;
  95. }

process_sdio_pending_irqs：

  1. static int process_sdio_pending_irqs(struct mmc_host *host)
  2. {
  3.     struct mmc_card *card = host->card;
  4.     int i, ret, count;
  5.     bool sdio_irq_pending = host->sdio_irq_pending;
  6.     unsigned char pending;
  7.     struct sdio_func *func;
  9.     /* Don't process SDIO IRQs if the card is suspended. */
  10.     if (mmc_card_suspended(card))
  11.         return 0;
  13.     /* Clear the flag to indicate that we have processed the IRQ. */
  14.     host->sdio_irq_pending = false;
  16.     /*
  17.      * Optimization, if there is only 1 function interrupt registered
  18.      * and we know an IRQ was signaled then call irq handler directly.
  19.      * Otherwise do the full probe.
  20.      */
  21.     // sdio_single_irq已注册，则直接调用func->irq_handler处理本次中断
  22.     func = card->sdio_single_irq;
  23.     if (func && sdio_irq_pending) {
  24.         func->irq_handler(func);
  25.         return 1;
  26.     }
  28.     // 发送cmd5 查询irq_pending???
  29.     ret = sdio_get_pending_irqs(host, &pending);
  30.     if (ret)
  31.         return ret;
  33.     // 根据pending，调用所对应的func
  34.     count = 0;
  35.     for (i = 1; i <= 7; i++) {
  36.         if (pending & (1 << i)) {
  37.             func = card->sdio_func[i - 1];
  38.             if (!func) {
  39.                 pr_warn("%s: pending IRQ for non-existent function\n",
  40.                     mmc_card_id(card));
  41.                 ret = -EINVAL;
  42.             } else if (func->irq_handler) {
  43.                 func->irq_handler(func);
  44.                 count++;
  45.             } else {
  46.                 pr_warn("%s: pending IRQ with no handler\n",
  47.                     sdio_func_id(func));
  48.                 ret = -EINVAL;
  49.             }
  50.         }
  51.     }
  53.     if (count)
  54.         return count;
  56.     return ret;
  57. }

sdio_get_pending_irqs：

  1. static int sdio_get_pending_irqs(struct mmc_host *host, u8 *pending)
  2. {
  3.     struct mmc_card *card = host->card;
  4.     int ret;
  6.     WARN_ON(!host->claimed);
  8.     ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, pending);
  9.     if (ret) {
  10.         pr_debug("%s: error %d reading SDIO_CCCR_INTx\n",
  11.                mmc_card_id(card), ret);
  12.         return ret;
  13.     }
  15.     if (*pending && mmc_card_broken_irq_polling(card) &&
  16.         !(host->caps & MMC_CAP_SDIO_IRQ)) {
  17.         unsigned char dummy;
  19.         /* A fake interrupt could be created when we poll SDIO_CCCR_INTx
  20.          * register with a Marvell SD8797 card. A dummy CMD52 read to
  21.          * function 0 register 0xff can avoid this.
  22.          */
  23.         mmc_io_rw_direct(card, 0, 0, 0xff, 0, &dummy);
  24.     }
  26.     return 0;
  27. }

sdio io相关函数

host相关

sdio_claim_host：

  1. void sdio_claim_host(struct sdio_func *func)
  2. {
  3.     if (WARN_ON(!func))
  4.         return;
  6.     mmc_claim_host(func->card->host);
  7. }
  8. EXPORT_SYMBOL_GPL(sdio_claim_host);

sdio_release_host：

  1. void sdio_release_host(struct sdio_func *func)
  2. {
  3.     if (WARN_ON(!func))
  4.         return;
  6.     mmc_release_host(func->card->host);
  7. }
  8. EXPORT_SYMBOL_GPL(sdio_release_host);

sdio func相关

  1. int sdio_enable_func(struct sdio_func *func);
  2. int sdio_disable_func(struct sdio_func *func);

块配置相关

  1. int sdio_set_block_size(struct sdio_func *func, unsigned blksz);
  2. unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz);

IO读写相关

  1. // 读写1byte
  2. u8 sdio_readb(struct sdio_func *func, unsigned int addr, int *err_ret);
  3. void sdio_writeb(struct sdio_func *func, u8 b, unsigned int addr, int *err_ret);
  4. u8 sdio_writeb_readb(struct sdio_func *func, u8 write_byte, unsigned int addr, int *err_ret);
  7. // 读写块数据
  8. int sdio_memcpy_fromio(struct sdio_func *func, void *dst, unsigned int addr, int count);
  9. int sdio_memcpy_toio(struct sdio_func *func, unsigned int addr, void *src, int count);
  12. // 读写FIFO 1byte
  13. int sdio_readsb(struct sdio_func *func, void *dst, unsigned int addr, int count);
  14. int sdio_writesb(struct sdio_func *func, unsigned int addr, void *src, int count);
  16. // 读写16bit(2byte)
  17. u16 sdio_readw(struct sdio_func *func, unsigned int addr, int *err_ret);
  18. void sdio_writew(struct sdio_func *func, u16 b, unsigned int addr, int *err_ret);
  20. // 读写32bit(4byte)
  21. u32 sdio_readl(struct sdio_func *func, unsigned int addr, int *err_ret);
  22. void sdio_writel(struct sdio_func *func, u32 b, unsigned int addr, int *err_ret);
  24. // sdio func0 读取1byte
  25. unsigned char sdio_f0_readb(struct sdio_func *func, unsigned int addr, int *err_ret);
  26. void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr, int *err_ret);

  
sdio_io_rw_ext_helper：
  以上IO相关的函数，最终都是调用本函数来实现相关的功能，具体实现方式如下：

  1. /* Split an arbitrarily sized data transfer into several
  2.  * IO_RW_EXTENDED commands. */
  3. static int sdio_io_rw_ext_helper(struct sdio_func *func, int write,
  4.     unsigned addr, int incr_addr, u8 *buf, unsigned size)
  5. {
  6.     unsigned remainder = size;
  7.     unsigned max_blocks;
  8.     int ret;
  10.     if (!func || (func->num > 7))
  11.         return -EINVAL;
  13.     /* Do the bulk of the transfer using block mode (if supported). */
  14.     // 支持多块传输，且当前传输数据大于一块大小
  15.     if (func->card->cccr.multi_block && (size > sdio_max_byte_size(func))) {
  16.         /* Blocks per command is limited by host count, host transfer
  17.          * size and the maximum for IO_RW_EXTENDED of 511 blocks. */
  18.         max_blocks = min(func->card->host->max_blk_count, 511u);
  20.         // 快对齐收发数据
  21.         while (remainder >= func->cur_blksize) {
  22.             unsigned blocks;
  24.             blocks = remainder / func->cur_blksize;
  25.             if (blocks > max_blocks)
  26.                 blocks = max_blocks;
  27.             size = blocks * func->cur_blksize;
  29.             ret = mmc_io_rw_extended(func->card, write,
  30.                 func->num, addr, incr_addr, buf,
  31.                 blocks, func->cur_blksize);
  32.             if (ret)
  33.                 return ret;
  35.             remainder -= size;
  36.             buf += size;
  37.             if (incr_addr)
  38.                 addr += size;
  39.         }
  40.     }
  42.     /* Write the remainder using byte mode. */
  43.     // 收发剩余数据
  44.     while (remainder > 0) {
  45.         size = min(remainder, sdio_max_byte_size(func));
  47.         /* Indicate byte mode by setting "blocks" = 0 */
  48.         ret = mmc_io_rw_extended(func->card, write, func->num, addr,
  49.              incr_addr, buf, 0, size);
  50.         if (ret)
  51.             return ret;
  53.         remainder -= size;
  54.         buf += size;
  55.         if (incr_addr)
  56.             addr += size;
  57.     }
  58.     return 0;
  59. }

发表评论

表情：
评论列表 （有 0 条评论，763人围观）

还没有评论，来说两句吧...

相关阅读

    相关 SDIO定义（七）

    SDIO定义 SDIO，全称： Secure Digital Input and Output ，即安全数字输入输出接口。它是在SD卡接口的基础上发展而来，它可以兼容之前的S

    怼烎@怼烎@/ 0 赞/ 92 阅读