Linuxカーネルのファイルアクセスの処理を追いかける (24) MMC: mmc_blk_probe

// 2885:
static int mmc_blk_probe(struct mmc_card *card)
{
    struct mmc_blk_data *md;
    int ret = 0;

    /*
    * Check that the card supports the command class(es) we need.
    */
    if (!(card->csd.cmdclass & CCC_BLOCK_READ))
        return -ENODEV;

    mmc_fixup_device(card, mmc_blk_fixups);

    card->complete_wq = alloc_workqueue("mmc_complete",
                    WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
    if (!card->complete_wq) {
        pr_err("Failed to create mmc completion workqueue");
        return -ENOMEM;
    }

    md = mmc_blk_alloc(card);
    if (IS_ERR(md)) {
        ret = PTR_ERR(md);
        goto out_free;
    }

    ret = mmc_blk_alloc_parts(card, md);
    if (ret)
        goto out;

    /* Add two debugfs entries */
    mmc_blk_add_debugfs(card, md);

    pm_runtime_set_autosuspend_delay(&card->dev, 3000);
    pm_runtime_use_autosuspend(&card->dev);

    /*
    * Don't enable runtime PM for SD-combo cards here. Leave that
    * decision to be taken during the SDIO init sequence instead.
    */
    if (card->type != MMC_TYPE_SD_COMBO) {
        pm_runtime_set_active(&card->dev);
        pm_runtime_enable(&card->dev);
    }

    return 0;

out:
    mmc_blk_remove_parts(card, md);
    mmc_blk_remove_req(md);
out_free:
    destroy_workqueue(card->complete_wq);
    return ret;
}

// 148:
static inline void mmc_fixup_device(struct mmc_card *card,
                    const struct mmc_fixup *table)
{
    const struct mmc_fixup *f;
    u64 rev = cid_rev_card(card);

    for (f = table; f->vendor_fixup; f++) {
        if ((f->manfid == CID_MANFID_ANY ||
             f->manfid == card->cid.manfid) &&
            (f->oemid == CID_OEMID_ANY ||
             f->oemid == card->cid.oemid) &&
            (f->name == CID_NAME_ANY ||
             !strncmp(f->name, card->cid.prod_name,
                  sizeof(card->cid.prod_name))) &&
            (f->cis_vendor == card->cis.vendor ||
             f->cis_vendor == (u16) SDIO_ANY_ID) &&
            (f->cis_device == card->cis.device ||
             f->cis_device == (u16) SDIO_ANY_ID) &&
            (f->ext_csd_rev == EXT_CSD_REV_ANY ||
             f->ext_csd_rev == card->ext_csd.rev) &&
            rev >= f->rev_start && rev <= f->rev_end) {
            dev_dbg(&card->dev, "calling %ps\n", f->vendor_fixup);
            f->vendor_fixup(card, f->data);
        }
    }
}

// 2455:
static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
{
    sector_t size;

    if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
        /*
        * The EXT_CSD sector count is in number or 512 byte
        * sectors.
        */
        size = card->ext_csd.sectors;
    } else {
        /*
        * The CSD capacity field is in units of read_blkbits.
        * set_capacity takes units of 512 bytes.
        */
        size = (typeof(sector_t))card->csd.capacity
            << (card->csd.read_blkbits - 9);
    }

    return mmc_blk_alloc_req(card, &card->dev, size, false, NULL,
                    MMC_BLK_DATA_AREA_MAIN, 0);
}

// 2336:
static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
                          struct device *parent,
                          sector_t size,
                          bool default_ro,
                          const char *subname,
                          int area_type,
                          unsigned int part_type)
{
    struct mmc_blk_data *md;
    int devidx, ret;
    char cap_str[10];

    devidx = ida_simple_get(&mmc_blk_ida, 0, max_devices, GFP_KERNEL);
    if (devidx < 0) {
        /*
        * We get -ENOSPC because there are no more any available
        * devidx. The reason may be that, either userspace haven't yet
        * unmounted the partitions, which postpones mmc_blk_release()
        * from being called, or the device has more partitions than
        * what we support.
        */
        if (devidx == -ENOSPC)
            dev_err(mmc_dev(card->host),
                "no more device IDs available\n");

        return ERR_PTR(devidx);
    }

    md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);
    if (!md) {
        ret = -ENOMEM;
        goto out;
    }

    md->area_type = area_type;

    /*
    * Set the read-only status based on the supported commands
    * and the write protect switch.
    */
    md->read_only = mmc_blk_readonly(card);

    md->disk = mmc_init_queue(&md->queue, card);
    if (IS_ERR(md->disk)) {
        ret = PTR_ERR(md->disk);
        goto err_kfree;
    }

    INIT_LIST_HEAD(&md->part);
    INIT_LIST_HEAD(&md->rpmbs);
    kref_init(&md->kref);

    md->queue.blkdata = md;
    md->part_type = part_type;

    md->disk->major   = MMC_BLOCK_MAJOR;
    md->disk->minors = perdev_minors;
    md->disk->first_minor = devidx * perdev_minors;
    md->disk->fops = &mmc_bdops;
    md->disk->private_data = md;
    md->parent = parent;
    set_disk_ro(md->disk, md->read_only || default_ro);
    md->disk->flags = GENHD_FL_EXT_DEVT;
    if (area_type & (MMC_BLK_DATA_AREA_RPMB | MMC_BLK_DATA_AREA_BOOT))
        md->disk->flags |= GENHD_FL_NO_PART_SCAN
                   | GENHD_FL_SUPPRESS_PARTITION_INFO;

    /*
    * As discussed on lkml, GENHD_FL_REMOVABLE should:
    *
    * - be set for removable media with permanent block devices
    * - be unset for removable block devices with permanent media
    *
    * Since MMC block devices clearly fall under the second
    * case, we do not set GENHD_FL_REMOVABLE.  Userspace
    * should use the block device creation/destruction hotplug
    * messages to tell when the card is present.
    */

    snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
         "mmcblk%u%s", card->host->index, subname ? subname : "");

    set_capacity(md->disk, size);

    if (mmc_host_cmd23(card->host)) {
        if ((mmc_card_mmc(card) &&
             card->csd.mmca_vsn >= CSD_SPEC_VER_3) ||
            (mmc_card_sd(card) &&
             card->scr.cmds & SD_SCR_CMD23_SUPPORT))
            md->flags |= MMC_BLK_CMD23;
    }

    if (mmc_card_mmc(card) &&
        md->flags & MMC_BLK_CMD23 &&
        ((card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN) ||
         card->ext_csd.rel_sectors)) {
        md->flags |= MMC_BLK_REL_WR;
        blk_queue_write_cache(md->queue.queue, true, true);
    }

    string_get_size((u64)size, 512, STRING_UNITS_2,
            cap_str, sizeof(cap_str));
    pr_info("%s: %s %s %s %s\n",
        md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
        cap_str, md->read_only ? "(ro)" : "");

    /* used in ->open, must be set before add_disk: */
    if (area_type == MMC_BLK_DATA_AREA_MAIN)
        dev_set_drvdata(&card->dev, md);
    device_add_disk(md->parent, md->disk, mmc_disk_attr_groups);
    return md;

 err_kfree:
    kfree(md);
 out:
    ida_simple_remove(&mmc_blk_ida, devidx);
    return ERR_PTR(ret);
}

// 2654:
static int mmc_blk_alloc_parts(struct mmc_card *card, struct mmc_blk_data *md)
{
    int idx, ret;

    if (!mmc_card_mmc(card))
        return 0;

    for (idx = 0; idx < card->nr_parts; idx++) {
        if (card->part[idx].area_type & MMC_BLK_DATA_AREA_RPMB) {
            /*
            * RPMB partitions does not provide block access, they
            * are only accessed using ioctl():s. Thus create
            * special RPMB block devices that do not have a
            * backing block queue for these.
            */
            ret = mmc_blk_alloc_rpmb_part(card, md,
                card->part[idx].part_cfg,
                card->part[idx].size >> 9,
                card->part[idx].name);
            if (ret)
                return ret;
        } else if (card->part[idx].size) {
            ret = mmc_blk_alloc_part(card, md,
                card->part[idx].part_cfg,
                card->part[idx].size >> 9,
                card->part[idx].force_ro,
                card->part[idx].name,
                card->part[idx].area_type);
            if (ret)
                return ret;
        }
    }

    return 0;
}

// 2825:
static int mmc_blk_add_debugfs(struct mmc_card *card, struct mmc_blk_data *md)
{
    struct dentry *root;

    if (!card->debugfs_root)
        return 0;

    root = card->debugfs_root;

    if (mmc_card_mmc(card) || mmc_card_sd(card)) {
        md->status_dentry =
            debugfs_create_file_unsafe("status", 0400, root,
                           card,
                           &mmc_dbg_card_status_fops);
        if (!md->status_dentry)
            return -EIO;
    }

    if (mmc_card_mmc(card)) {
        md->ext_csd_dentry =
            debugfs_create_file("ext_csd", S_IRUSR, root, card,
                        &mmc_dbg_ext_csd_fops);
        if (!md->ext_csd_dentry)
            return -EIO;
    }

    return 0;
}