linux设备模型之mmc，sd子系统

-----------------------------------------------------------
本文系本站原创,欢迎转载!

转载请注明出处:http://blog.csdn.net/gdt_a20

-----------------------------------------------------------

####看一下重要的卡扫描函数，mmc_rescan,卡就指着他
####活着呢，

/driver/mmc/core/core.c

void mmc_rescan(struct work_struct *work)

{

 static const unsigned freqs[] = { 400000, 300000, 200000, 100000 }; //扫描试验的频率段

 struct mmc_host *host =

  container_of(work, struct mmc_host, detect.work);

 int i;

 if (host->rescan_disable)        //disable 直接返回
  return;

 mmc_bus_get(host);               //增加bus引用计数

 /*
  * if there is a _removable_ card registered, check whether it is
  * still present
  */
 if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
     && !(host->caps & MMC_CAP_NONREMOVABLE))
  host->bus_ops->detect(host);          //存在热插拔卡，不包括emmc，调用探测函数

 /*
  * Let mmc_bus_put() free the bus/bus_ops if we've found that
  * the card is no longer present.
  */
 mmc_bus_put(host);                           //减少引用技术，就释放
 mmc_bus_get(host);                           //重新增加引用计数

 /* if there still is a card present, stop here */
 if (host->bus_ops != NULL) {
  mmc_bus_put(host);                   //如果卡仍然存在，减少引用计数，不必探测了
  goto out;
 }

 /*
  * Only we can add a new handler, so it's safe to
  * release the lock here.
  */
 mmc_bus_put(host);                          //减少引用计数

 if (host->ops->get_cd && host->ops->get_cd(host) == 0)  //有卡，退出
  goto out;

 mmc_claim_host(host);                   //用于检测host是否被占用，占用则退出，否则标记成占用
 for (i = 0; i < ARRAY_SIZE(freqs); i++) {
  if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))   //利用不同的频率探测卡
   break;
  if (freqs[i] <= host->f_min)
   break;
 }
 mmc_release_host(host);

 out:

 if (host->caps & MMC_CAP_NEEDS_POLL)                   //轮询标志，设置了就会轮询

  mmc_schedule_delayed_work(&host->detect, HZ);

}

#####

/**

 * mmc_claim_host - exclusively claim a host

 * @host: mmc host to claim

 *

 * Claim a host for a set of operations.

 */

static inline void mmc_claim_host(struct mmc_host *host)

{

 __mmc_claim_host(host, NULL);

}

#####
/**
 * __mmc_claim_host - exclusively claim a host
 * @host: mmc host to claim
 * @abort: whether or not the operation should be aborted
 *
 * Claim a host for a set of operations.  If @abort is non null and
 * dereference a non-zero value then this will return prematurely with
 * that non-zero value without acquiring the lock.  Returns zero
 * with the lock held otherwise.
 */
int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
{
 DECLARE_WAITQUEUE(wait, current);                        //定义一个等待队列
 unsigned long flags;
 int stop;

 might_sleep();                                                                    //调度点
 
 add_wait_queue(&host->wq, &wait);
 spin_lock_irqsave(&host->lock, flags);
 while (1) {
  set_current_state(TASK_UNINTERRUPTIBLE);
  stop = abort ? atomic_read(abort) : 0;
  if (stop || !host->claimed || host->claimer == current)
   break;
  spin_unlock_irqrestore(&host->lock, flags);
  schedule();
  spin_lock_irqsave(&host->lock, flags);
 }                                                                                        //只有claim为空的时候还会跳出循环，否则就一直等待释放
 set_current_state(TASK_RUNNING);
 if (!stop) {
  host->claimed = 1;
  host->claimer = current;
  host->claim_cnt += 1;
 } else
  wake_up(&host->wq);
 spin_unlock_irqrestore(&host->lock, flags);
 remove_wait_queue(&host->wq, &wait);
 if (!stop)
  mmc_host_enable(host);   //使能该host
 return stop;
}

#####
mmc_host_enable函数可以做一些底电流工作

#####

/**
 * mmc_host_enable - enable a host.
 * @host: mmc host to enable
 *
 * Hosts that support power saving can use the 'enable' and 'disable'
 * methods to exit and enter power saving states. For more information
 * see comments for struct mmc_host_ops.
 */
int mmc_host_enable(struct mmc_host *host)
{
 if (!(host->caps & MMC_CAP_DISABLE))
  return 0;

 if (host->en_dis_recurs)
  return 0;

 if (host->nesting_cnt++)
  return 0;

 cancel_delayed_work_sync(&host->disable);

 if (host->enabled)
  return 0;

 if (host->ops->enable) {
  int err;

  host->en_dis_recurs = 1;
  err = host->ops->enable(host);
  host->en_dis_recurs = 0;

  if (err) {
   pr_debug("%s: enable error %d\n",
     mmc_hostname(host), err);
   return err;
  }
 }
 host->enabled = 1;
 return 0;
}

#####
重点的卡探测函数，

#####

static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
{
 host->f_init = freq;

#ifdef CONFIG_MMC_DEBUG
 pr_info("%s: %s: trying to init card at %u Hz\n",
  mmc_hostname(host), __func__, host->f_init);
#endif
 mmc_power_up(host);                                                  //电源启用

 /*
  * Some eMMCs (with VCCQ always on) may not be reset after power up, so
  * do a hardware reset if possible.
  */
 mmc_hw_reset_for_init(host);                                      //针对emmc的硬件reset

 /*
  * sdio_reset sends CMD52 to reset card.  Since we do not know
  * if the card is being re-initialized, just send it.  CMD52
  * should be ignored by SD/eMMC cards.
  */
 sdio_reset(host);
 mmc_go_idle(host);                                                      //这部分与sd协议相关，可以结合前面内容来看

 mmc_send_if_cond(host, host->ocr_avail);

 /* Order's important: probe SDIO, then SD, then MMC */
 if (!mmc_attach_sdio(host))                                        //各种卡类型探测初始化
  return 0;
 if (!mmc_attach_sd(host))
  return 0;
 if (!mmc_attach_mmc(host))
  return 0;

 mmc_power_off(host);                                                //关电
 return -EIO;
}

####在卡类型探测初始化过程中，重要的一个环节是和块设备的关联，这部分代码大致相同，

####例如mmc_attach_sd中，会有，

/drivers/mmc/core/sd.c

/*
 * Starting point for SD card init.
 */
int mmc_attach_sd(struct mmc_host *host)
{
    int err;
    u32 ocr;

    BUG_ON(!host);
    WARN_ON(!host->claimed);

    /* Make sure we are at 3.3V signalling voltage */
    err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, false);
    if (err)
        return err;

    /* Disable preset value enable if already set since last time */
    if (host->ops->enable_preset_value)
        host->ops->enable_preset_value(host, false);

    err = mmc_send_app_op_cond(host, 0, &ocr);
    if (err)
        return err;

    mmc_sd_attach_bus_ops(host);                                  //重要，bus操作的绑定
    if (host->ocr_avail_sd)
        host->ocr_avail = host->ocr_avail_sd;

    /*
     * We need to get OCR a different way for SPI.
     */
    if (mmc_host_is_spi(host)) {
        mmc_go_idle(host);

        err = mmc_spi_read_ocr(host, 0, &ocr);
        if (err)
            goto err;
    }

    /*
     * Sanity check the voltages that the card claims to
     * support.
     */
    if (ocr & 0x7F) {
        pr_warning("%s: card claims to support voltages "
               "below the defined range. These will be ignored.\n",
               mmc_hostname(host));
        ocr &= ~0x7F;
    }

    if ((ocr & MMC_VDD_165_195) &&
        !(host->ocr_avail_sd & MMC_VDD_165_195)) {
        pr_warning("%s: SD card claims to support the "
               "incompletely defined 'low voltage range'. This "
               "will be ignored.\n", mmc_hostname(host));
        ocr &= ~MMC_VDD_165_195;
    }

    host->ocr = mmc_select_voltage(host, ocr);

    /*
     * Can we support the voltage(s) of the card(s)?
     */
    if (!host->ocr) {
        err = -EINVAL;
        goto err;
    }

    /*
     * Detect and init the card.
     */
    err = mmc_sd_init_card(host, host->ocr, NULL);
    if (err)
        goto err;

    mmc_release_host(host);
    err = mmc_add_card(host->card);                               //将卡加入
    mmc_claim_host(host);
    if (err)
        goto remove_card;

    return 0;

remove_card:
    mmc_release_host(host);
    mmc_remove_card(host->card);
    host->card = NULL;
    mmc_claim_host(host);
err:
    mmc_detach_bus(host);

    pr_err("%s: error %d whilst initialising SD card\n",
        mmc_hostname(host), err);

    return err;
}

#######首先是绑定操作mmc_sd_attach_bus_ops

static void mmc_sd_attach_bus_ops(struct mmc_host *host)
{
    const struct mmc_bus_ops *bus_ops;

    if (!mmc_card_is_removable(host))              //emmc和sd区别对待
        bus_ops = &mmc_sd_ops_unsafe;
    else
        bus_ops = &mmc_sd_ops;
    mmc_attach_bus(host, bus_ops);
}

####mmc_attach_bus函数会将bus的操作绑定到host上.

####core.c中

/*
 * Assign a mmc bus handler to a host. Only one bus handler may control a
 * host at any given time.
 */
void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
{
    unsigned long flags;

    BUG_ON(!host);
    BUG_ON(!ops);

    WARN_ON(!host->claimed);

    spin_lock_irqsave(&host->lock, flags);

    BUG_ON(host->bus_ops);
    BUG_ON(host->bus_refs);

    host->bus_ops = ops;                                              //指向对应的操作结构
    host->bus_refs = 1;
    host->bus_dead = 0;

    spin_unlock_irqrestore(&host->lock, flags);
}

#####再看另外一个函数mmc_add_card,

####这个函数在bus.c 中，

/*
 * Register a new MMC card with the driver model.
 */
int mmc_add_card(struct mmc_card *card)
{
    int ret;
    const char *type;

    dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);

    switch (card->type) {
    case MMC_TYPE_MMC:
        type = "MMC";
        break;
    case MMC_TYPE_SD:
        type = "SD";
        if (mmc_card_blockaddr(card)) {
            if (mmc_card_ext_capacity(card))
                type = "SDXC";
            else
                type = "SDHC";
        }
        break;
    case MMC_TYPE_SDIO:
        type = "SDIO";
        break;
    case MMC_TYPE_SD_COMBO:
        type = "SD-combo";
        if (mmc_card_blockaddr(card))
            type = "SDHC-combo";
        break;
    default:
        type = "?";
        break;
    }

    if (mmc_host_is_spi(card->host)) {
        pr_info("%s: new %s%s%s card on SPI\n",
            mmc_hostname(card->host),
            mmc_card_highspeed(card) ? "high speed " : "",
            mmc_card_ddr_mode(card) ? "DDR " : "",
            type);
    } else {
        printk(KERN_INFO "%s: new %s%s%s card at address %04x\n",
            mmc_hostname(card->host),
            mmc_sd_card_uhs(card) ? "ultra high speed " :
            (mmc_card_highspeed(card) ? "high speed " : ""),
            mmc_card_ddr_mode(card) ? "DDR " : "",
            type, card->rca);
    }

#ifdef CONFIG_DEBUG_FS
    mmc_add_card_debugfs(card);
#endif

    ret = device_add(&card->dev);
    if (ret)
        return ret;

    mmc_card_set_present(card);

    return 0;
}

####关注一下device_add(&card->dev);会把卡作为一个设备注册，

####这个注册会触发到bus里的match操作，这部分不理解的可以回顾前面讲到的设备模型，

####这里的bus对应mmc，调用的match函数对应于bus.c中

static struct bus_type mmc_bus_type = {
    .name        = "mmc",
    .dev_attrs    = mmc_dev_attrs,
    .match        = mmc_bus_match,
    .uevent        = mmc_bus_uevent,
    .probe        = mmc_bus_probe,
    .remove        = mmc_bus_remove,
    .suspend    = mmc_bus_suspend,
    .resume        = mmc_bus_resume,
    .pm        = MMC_PM_OPS_PTR,
};

/*
 * This currently matches any MMC driver to any MMC card - drivers
 * themselves make the decision whether to drive this card in their
 * probe method.
 */
static int mmc_bus_match(struct device *dev, struct device_driver *drv)
{
    return 1;
}

####总为真，那么直接会触发bus的probe操作，

####

static int mmc_bus_probe(struct device *dev)
{
    struct mmc_driver *drv = to_mmc_driver(dev->driver);
    struct mmc_card *card = mmc_dev_to_card(dev);

    return drv->probe(card);
}

####会调用mmc_driver 里的probe，

####这里的mmc_driver就指的是block.c中的mmc_driver,

####还是看一下，这个过程吧，

####drivers/mmc/card/block.c

static int __init mmc_blk_init(void)
{
    int res;

    if (perdev_minors != CONFIG_MMC_BLOCK_MINORS)
        pr_info("mmcblk: using %d minors per device\n", perdev_minors);

    max_devices = 256 / perdev_minors;

    res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");              //注册mmc块设备，这个后面来讲
    if (res)
        goto out;

    res = mmc_register_driver(&mmc_driver);                                      //重点是这个
    if (res)
        goto out2;

    return 0;
 out2:
    unregister_blkdev(MMC_BLOCK_MAJOR, "mmc");
 out:
    return res;
}

#####

static struct mmc_driver mmc_driver = {
    .drv        = {
        .name    = "mmcblk",
    },
    .probe        = mmc_blk_probe,
    .remove        = mmc_blk_remove,
    .suspend    = mmc_blk_suspend,
    .resume        = mmc_blk_resume,
};

####在bus.c中

/**
 *    mmc_register_driver - register a media driver
 *    @drv: MMC media driver
 */
int mmc_register_driver(struct mmc_driver *drv)
{
    drv->drv.bus = &mmc_bus_type;
    return driver_register(&drv->drv);
}

####bus类型被指定成了mmc，也就是挂到了mmc上，这样刚才的卡注册默认全部匹配，

####所以也就会直接触发block里的probe，mmc_blk_probe

####下面的东西块设备关联比较多，放到下一章来讲

总结：描述了卡的识别阶段，并没有深入到卡的具体探测，这部分结合前面的协议转换图就不难理解，这部分主要集中在sd到块设备部分的过度

下一篇主要是针对mmc中的块设备。

Thanks