Release 4.7 drivers/mmc/core/bus.c

Directory: drivers/mmc/core
/*
 *  linux/drivers/mmc/core/bus.c
 *
 *  Copyright (C) 2003 Russell King, All Rights Reserved.
 *  Copyright (C) 2007 Pierre Ossman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *  MMC card bus driver model
 */

#include <linux/export.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/of.h>
#include <linux/pm_runtime.h>

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>

#include "core.h"
#include "sdio_cis.h"
#include "bus.h"


#define to_mmc_driver(d)	container_of(d, struct mmc_driver, drv)



static ssize_t type_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct mmc_card *card = mmc_dev_to_card(dev);

	switch (card->type) {
	case MMC_TYPE_MMC:
		return sprintf(buf, "MMC\n");
	case MMC_TYPE_SD:
		return sprintf(buf, "SD\n");
	case MMC_TYPE_SDIO:
		return sprintf(buf, "SDIO\n");
	case MMC_TYPE_SD_COMBO:
		return sprintf(buf, "SDcombo\n");
	default:
		return -EFAULT;
	}
}
Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 74 85.06% 2 40.00%
michal miroslaw michal miroslaw 11 12.64% 1 20.00%
andy shevchenko andy shevchenko 1 1.15% 1 20.00%
greg kroah-hartman greg kroah-hartman 1 1.15% 1 20.00%
Total 87 100.00% 5 100.00%

static DEVICE_ATTR_RO(type);


static struct attribute *mmc_dev_attrs[] = {
	&dev_attr_type.attr,
	NULL,
};

ATTRIBUTE_GROUPS(mmc_dev);

/*
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%


static int

mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	const char *type;
	int retval = 0;

	switch (card->type) {
	case MMC_TYPE_MMC:
		type = "MMC";
		break;
	case MMC_TYPE_SD:
		type = "SD";
		break;
	case MMC_TYPE_SDIO:
		type = "SDIO";
		break;
	case MMC_TYPE_SD_COMBO:
		type = "SDcombo";
		break;
	default:
		type = NULL;
	}

	if (type) {
		retval = add_uevent_var(env, "MMC_TYPE=%s", type);
		if (retval)
			return retval;
	}

	retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
	if (retval)
		return retval;

	/*
         * Request the mmc_block device.  Note: that this is a direct request
         * for the module it carries no information as to what is inserted.
         */
	retval = add_uevent_var(env, "MODALIAS=mmc:block");

	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 97 69.78% 3 42.86%
andy whitcroft andy whitcroft 17 12.23% 1 14.29%
kay sievers kay sievers 16 11.51% 1 14.29%
michal miroslaw michal miroslaw 8 5.76% 1 14.29%
andy shevchenko andy shevchenko 1 0.72% 1 14.29%
Total 139 100.00% 7 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
ulf hansson ulf hansson 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%



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

	drv->remove(card);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
ulf hansson ulf hansson 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



static void mmc_bus_shutdown(struct device *dev)
{
	struct mmc_driver *drv = to_mmc_driver(dev->driver);
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;
	int ret;

	if (dev->driver && drv->shutdown)
		drv->shutdown(card);

	if (host->bus_ops->shutdown) {
		ret = host->bus_ops->shutdown(host);
		if (ret)
			pr_warn("%s: error %d during shutdown\n",
				mmc_hostname(host), ret);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
ulf hansson ulf hansson 99 100.00% 4 100.00%
Total 99 100.00% 4 100.00%

#ifdef CONFIG_PM_SLEEP


static int mmc_bus_suspend(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;
	int ret;

	ret = pm_generic_suspend(dev);
	if (ret)
		return ret;

	ret = host->bus_ops->suspend(host);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 31 50.82% 1 25.00%
ulf hansson ulf hansson 29 47.54% 2 50.00%
andy shevchenko andy shevchenko 1 1.64% 1 25.00%
Total 61 100.00% 4 100.00%



static int mmc_bus_resume(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;
	int ret;

	ret = host->bus_ops->resume(host);
	if (ret)
		pr_warn("%s: error %d during resume (card was removed?)\n",
			mmc_hostname(host), ret);

	ret = pm_generic_resume(dev);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
ulf hansson ulf hansson 38 54.29% 2 50.00%
pierre ossman pierre ossman 31 44.29% 1 25.00%
andy shevchenko andy shevchenko 1 1.43% 1 25.00%
Total 70 100.00% 4 100.00%

#endif

#ifdef CONFIG_PM


static int mmc_runtime_suspend(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;

	return host->bus_ops->runtime_suspend(host);
}

Contributors
Person Tokens Prop Commits CommitProp
ohad ben-cohen ohad ben-cohen 26 65.00% 1 33.33%
ulf hansson ulf hansson 14 35.00% 2 66.67%
Total 40 100.00% 3 100.00%



static int mmc_runtime_resume(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;

	return host->bus_ops->runtime_resume(host);
}
Contributors
Person Tokens Prop Commits CommitProp
ohad ben-cohen ohad ben-cohen 26 65.00% 1 33.33%
ulf hansson ulf hansson 14 35.00% 2 66.67%
Total 40 100.00% 3 100.00%

#endif /* !CONFIG_PM */


static const struct dev_pm_ops mmc_bus_pm_ops = {
	SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, NULL)
	SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
};


static struct bus_type mmc_bus_type = {
	.name		= "mmc",
	.dev_groups	= mmc_dev_groups,
	.match		= mmc_bus_match,
	.uevent		= mmc_bus_uevent,
	.probe		= mmc_bus_probe,
	.remove		= mmc_bus_remove,
	.shutdown	= mmc_bus_shutdown,
	.pm		= &mmc_bus_pm_ops,
};



int mmc_register_bus(void)
{
	return bus_register(&mmc_bus_type);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%



void mmc_unregister_bus(void)
{
	bus_unregister(&mmc_bus_type);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%

/**
 *      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);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 22 78.57% 1 50.00%
ulf hansson ulf hansson 6 21.43% 1 50.00%
Total 28 100.00% 2 100.00%


EXPORT_SYMBOL(mmc_register_driver);

/**
 *      mmc_unregister_driver - unregister a media driver
 *      @drv: MMC media driver
 */


void mmc_unregister_driver(struct mmc_driver *drv)
{
	drv->drv.bus = &mmc_bus_type;
	driver_unregister(&drv->drv);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 21 77.78% 1 50.00%
ulf hansson ulf hansson 6 22.22% 1 50.00%
Total 27 100.00% 2 100.00%


EXPORT_SYMBOL(mmc_unregister_driver);



static void mmc_release_card(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);

	sdio_free_common_cis(card);

	kfree(card->info);

	kfree(card);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 37 97.37% 3 75.00%
andy shevchenko andy shevchenko 1 2.63% 1 25.00%
Total 38 100.00% 4 100.00%

/*
 * Allocate and initialise a new MMC card structure.
 */


struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
{
	struct mmc_card *card;

	card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
	if (!card)
		return ERR_PTR(-ENOMEM);

	card->host = host;

	device_initialize(&card->dev);

	card->dev.parent = mmc_classdev(host);
	card->dev.bus = &mmc_bus_type;
	card->dev.release = mmc_release_card;
	card->dev.type = type;

	return card;
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 99 99.00% 2 66.67%
mariusz kozlowski mariusz kozlowski 1 1.00% 1 33.33%
Total 100 100.00% 3 100.00%

/*
 * Register a new MMC card with the driver model.
 */


int mmc_add_card(struct mmc_card *card)
{
	int ret;
	const char *type;
	const char *uhs_bus_speed_mode = "";
	static const char *const uhs_speeds[] = {
		[UHS_SDR12_BUS_SPEED] = "SDR12 ",
		[UHS_SDR25_BUS_SPEED] = "SDR25 ",
		[UHS_SDR50_BUS_SPEED] = "SDR50 ",
		[UHS_SDR104_BUS_SPEED] = "SDR104 ",
		[UHS_DDR50_BUS_SPEED] = "DDR50 ",
        };


	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_card_uhs(card) &&
		(card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
		uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];

	if (mmc_host_is_spi(card->host)) {
		pr_info("%s: new %s%s%s card on SPI\n",
			mmc_hostname(card->host),
			mmc_card_hs(card) ? "high speed " : "",
			mmc_card_ddr52(card) ? "DDR " : "",
			type);
	} else {
		pr_info("%s: new %s%s%s%s%s card at address %04x\n",
			mmc_hostname(card->host),
			mmc_card_uhs(card) ? "ultra high speed " :
			(mmc_card_hs(card) ? "high speed " : ""),
			mmc_card_hs400(card) ? "HS400 " :
			(mmc_card_hs200(card) ? "HS200 " : ""),
			mmc_card_ddr52(card) ? "DDR " : "",
			uhs_bus_speed_mode, type, card->rca);
	}

#ifdef CONFIG_DEBUG_FS
	mmc_add_card_debugfs(card);
#endif
	mmc_init_context_info(card->host);

	card->dev.of_node = mmc_of_find_child_device(card->host, 0);

	device_enable_async_suspend(&card->dev);

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

	mmc_card_set_present(card);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 135 36.39% 3 15.00%
subhash jadavani subhash jadavani 76 20.49% 1 5.00%
david brownell david brownell 34 9.16% 1 5.00%
arindam nath arindam nath 22 5.93% 1 5.00%
michal miroslaw michal miroslaw 19 5.12% 2 10.00%
adrian hunter adrian hunter 17 4.58% 1 5.00%
sascha hauer sascha hauer 15 4.04% 1 5.00%
girish k s girish k s 13 3.50% 2 10.00%
seungwon jeon seungwon jeon 11 2.96% 2 10.00%
viresh kumar viresh kumar 10 2.70% 1 5.00%
fu zhonghui fu zhonghui 8 2.16% 1 5.00%
konstantin dorfman konstantin dorfman 7 1.89% 1 5.00%
kay sievers kay sievers 2 0.54% 1 5.00%
jackey shen jackey shen 1 0.27% 1 5.00%
philip rakity philip rakity 1 0.27% 1 5.00%
Total 371 100.00% 20 100.00%

/*
 * Unregister a new MMC card with the driver model, and
 * (eventually) free it.
 */


void mmc_remove_card(struct mmc_card *card)
{
#ifdef CONFIG_DEBUG_FS
	mmc_remove_card_debugfs(card);
#endif

	if (mmc_card_present(card)) {
		if (mmc_host_is_spi(card->host)) {
			pr_info("%s: SPI card removed\n",
				mmc_hostname(card->host));
		} else {
			pr_info("%s: card %04x removed\n",
				mmc_hostname(card->host), card->rca);
		}
		device_del(&card->dev);
		of_node_put(card->dev.of_node);
	}

	put_device(&card->dev);
}

Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 50 52.08% 2 33.33%
david brownell david brownell 25 26.04% 1 16.67%
haavard skinnemoen haavard skinnemoen 10 10.42% 1 16.67%
sascha hauer sascha hauer 9 9.38% 1 16.67%
girish k s girish k s 2 2.08% 1 16.67%
Total 96 100.00% 6 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
pierre ossman pierre ossman 717 47.96% 7 15.22%
ulf hansson ulf hansson 313 20.94% 9 19.57%
subhash jadavani subhash jadavani 76 5.08% 1 2.17%
ohad ben-cohen ohad ben-cohen 67 4.48% 1 2.17%
david brownell david brownell 59 3.95% 1 2.17%
michal miroslaw michal miroslaw 38 2.54% 2 4.35%
sascha hauer sascha hauer 27 1.81% 1 2.17%
chuanxiao dong chuanxiao dong 23 1.54% 2 4.35%
arindam nath arindam nath 22 1.47% 1 2.17%
greg kroah-hartman greg kroah-hartman 21 1.40% 1 2.17%
kay sievers kay sievers 18 1.20% 2 4.35%
adrian hunter adrian hunter 17 1.14% 1 2.17%
andy whitcroft andy whitcroft 17 1.14% 1 2.17%
girish k s girish k s 15 1.00% 2 4.35%
seungwon jeon seungwon jeon 11 0.74% 2 4.35%
viresh kumar viresh kumar 10 0.67% 1 2.17%
haavard skinnemoen haavard skinnemoen 10 0.67% 1 2.17%
fu zhonghui fu zhonghui 8 0.54% 1 2.17%
konstantin dorfman konstantin dorfman 7 0.47% 1 2.17%
paul gortmaker paul gortmaker 6 0.40% 2 4.35%
andy shevchenko andy shevchenko 5 0.33% 1 2.17%
tejun heo tejun heo 3 0.20% 1 2.17%
rafael j. wysocki rafael j. wysocki 2 0.13% 1 2.17%
philip rakity philip rakity 1 0.07% 1 2.17%
mariusz kozlowski mariusz kozlowski 1 0.07% 1 2.17%
jackey shen jackey shen 1 0.07% 1 2.17%
Total 1495 100.00% 46 100.00%
  Directory: drivers/mmc/core

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
pierre ossman	pierre ossman	74	85.06%	2	40.00%
michal miroslaw	michal miroslaw	11	12.64%	1	20.00%
andy shevchenko	andy shevchenko	1	1.15%	1	20.00%
greg kroah-hartman	greg kroah-hartman	1	1.15%	1	20.00%
	Total	87	100.00%	5	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/mmc/core/bus.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
