AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity

MMC core:

Browse Source 
- Fix error code propagation in mmc_pwrseq_simple_alloc()
 - Revert "mmc: core: Convert mmc_driver to device_driver"
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJVN1ScAAoJEP4mhCVzWIwpqlMQAJ3ieLwShDPcX7FRBnLwnIEG
 Iw5DnxKAhyVHy9k6nTmMBDdhAUrqxgmU6FN4uUbQtG+diInwhSaXue9oR8wyOs3Q
 kG/i9cKLPDd5TG16abNFVG7pMFqBEeJMMdx8oLSjVbs7jld9txVObHkhlSiaCW1w
 SSE3F6mFkgYHtt+2+KRVBKOqSNpqM1xXa86P3QPo8rA7XAVDWkykgqIV2UIxxTP0
 uE9oHU0G+wAHEQH4muJAtusyanFxCl1pcEyMOb/6R4YpuGzgkT4gwcci4OoEn6b+
 9JW08FcUZ+FPQw28UjrJjfevmCHWjko8mcnWiSI8a5SNm6JaYZcUv10BASb/ojlM
 qbv9bmkHY80p4Va19h8GYOeXlHVPF8bXst3LmPIi3o1N5b+1foFJH5iQuf8tmV/6
 dYKSBLHa6HpdT6lkTPMQ/lUgDnB+uQE4URVebWVyfGiPC3cIWqUSM1HgSS8RhnJi
 PTilVoHCmhM3lh2tLyI9DB9uP9pWLAv5B4pTfIJiAQXjU6aLWAwax2Bw9jsGlmRR
 Wl6Iq1urVxAEMkl6/HruorVB28HBy70eX3z0igZoYyl20zzow9gSineYR0yBbCIl
 EfPcII6ewvPOGP6tMSvUrc1JSH6iE47aB7qQRtt5Vjp2mx6PRWdw1Tl/8/7vEVC2
 AeNtvVfSWk7o4WXcANZd
 =SJUv
 -----END PGP SIGNATURE-----

Merge tag 'mmc-4.1-rc1' of git://git.linaro.org/people/ulf.hansson/mmc

Pull MMC fixes from Ulf Hansson:
 "Here is two mmc core fixes for v.4.1 rc1:

   - fix error code propagation in mmc_pwrseq_simple_alloc()

   - revert 'mmc: core: Convert mmc_driver to device_driver'"

* tag 'mmc-4.1-rc1' of git://git.linaro.org/people/ulf.hansson/mmc:
  Revert "mmc: core: Convert mmc_driver to device_driver"
  mmc: pwrseq: Fix error code propagation in mmc_pwrseq_simple_alloc()
This commit is contained in:
Linus Torvalds 2015-04-22 09:29:08 -07:00
commit 5e6c94a999
5 changed files with 70 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
drivers/mmc/card/block.c
View File

@ -2418,9 +2418,8 @@ static const struct mmc_fixup blk_fixups[] =
END_FIXUP END_FIXUP
}; };
static int mmc_blk_probe(struct device *dev) static int mmc_blk_probe(struct mmc_card *card)
{ {
struct mmc_card *card = mmc_dev_to_card(dev);
struct mmc_blk_data *md, *part_md; struct mmc_blk_data *md, *part_md;
char cap_str[10]; char cap_str[10];
@ -2445,7 +2444,7 @@ static int mmc_blk_probe(struct device *dev)
if (mmc_blk_alloc_parts(card, md)) if (mmc_blk_alloc_parts(card, md))
goto out; goto out;
dev_set_drvdata(dev, md); dev_set_drvdata(&card->dev, md);
if (mmc_add_disk(md)) if (mmc_add_disk(md))
goto out; goto out;
@ -2475,10 +2474,9 @@ static int mmc_blk_probe(struct device *dev)
return 0; return 0;
} }
static int mmc_blk_remove(struct device *dev) static void mmc_blk_remove(struct mmc_card *card)
{ {
struct mmc_card *card = mmc_dev_to_card(dev); struct mmc_blk_data *md = dev_get_drvdata(&card->dev);
struct mmc_blk_data *md = dev_get_drvdata(dev);
mmc_blk_remove_parts(card, md); mmc_blk_remove_parts(card, md);
pm_runtime_get_sync(&card->dev); pm_runtime_get_sync(&card->dev);
@ -2489,15 +2487,13 @@ static int mmc_blk_remove(struct device *dev)
pm_runtime_disable(&card->dev); pm_runtime_disable(&card->dev);
pm_runtime_put_noidle(&card->dev); pm_runtime_put_noidle(&card->dev);
mmc_blk_remove_req(md); mmc_blk_remove_req(md);
dev_set_drvdata(dev, NULL); dev_set_drvdata(&card->dev, NULL);
return 0;
} }
static int _mmc_blk_suspend(struct device *dev) static int _mmc_blk_suspend(struct mmc_card *card)
{ {
struct mmc_blk_data *part_md; struct mmc_blk_data *part_md;
struct mmc_blk_data *md = dev_get_drvdata(dev); struct mmc_blk_data *md = dev_get_drvdata(&card->dev);
if (md) { if (md) {
mmc_queue_suspend(&md->queue); mmc_queue_suspend(&md->queue);
@ -2508,15 +2504,17 @@ static int _mmc_blk_suspend(struct device *dev)
return 0; return 0;
} }
static void mmc_blk_shutdown(struct device *dev) static void mmc_blk_shutdown(struct mmc_card *card)
{ {
_mmc_blk_suspend(dev); _mmc_blk_suspend(card);
} }
#ifdef CONFIG_PM_SLEEP #ifdef CONFIG_PM_SLEEP
static int mmc_blk_suspend(struct device *dev) static int mmc_blk_suspend(struct device *dev)
{ {
return _mmc_blk_suspend(dev); struct mmc_card *card = mmc_dev_to_card(dev);
return _mmc_blk_suspend(card);
} }
static int mmc_blk_resume(struct device *dev) static int mmc_blk_resume(struct device *dev)
@ -2541,9 +2539,11 @@ static int mmc_blk_resume(struct device *dev)
static SIMPLE_DEV_PM_OPS(mmc_blk_pm_ops, mmc_blk_suspend, mmc_blk_resume); static SIMPLE_DEV_PM_OPS(mmc_blk_pm_ops, mmc_blk_suspend, mmc_blk_resume);
static struct device_driver mmc_driver = { static struct mmc_driver mmc_driver = {
.name = "mmcblk", .drv = {
.pm = &mmc_blk_pm_ops, .name = "mmcblk",
.pm = &mmc_blk_pm_ops,
},
.probe = mmc_blk_probe, .probe = mmc_blk_probe,
.remove = mmc_blk_remove, .remove = mmc_blk_remove,
.shutdown = mmc_blk_shutdown, .shutdown = mmc_blk_shutdown,

18
drivers/mmc/card/mmc_test.c
View File

@ -14,7 +14,6 @@
#include <linux/mmc/host.h> #include <linux/mmc/host.h>
#include <linux/mmc/mmc.h> #include <linux/mmc/mmc.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/device.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/swap.h> /* For nr_free_buffer_pages() */ #include <linux/swap.h> /* For nr_free_buffer_pages() */
@ -2996,9 +2995,8 @@ static int mmc_test_register_dbgfs_file(struct mmc_card *card)
return ret; return ret;
} }
static int mmc_test_probe(struct device *dev) static int mmc_test_probe(struct mmc_card *card)
{ {
struct mmc_card *card = mmc_dev_to_card(dev);
int ret; int ret;
if (!mmc_card_mmc(card) && !mmc_card_sd(card)) if (!mmc_card_mmc(card) && !mmc_card_sd(card))
@ -3013,22 +3011,20 @@ static int mmc_test_probe(struct device *dev)
return 0; return 0;
} }
static int mmc_test_remove(struct device *dev) static void mmc_test_remove(struct mmc_card *card)
{ {
struct mmc_card *card = mmc_dev_to_card(dev);
mmc_test_free_result(card); mmc_test_free_result(card);
mmc_test_free_dbgfs_file(card); mmc_test_free_dbgfs_file(card);
return 0;
} }
static void mmc_test_shutdown(struct device *dev) static void mmc_test_shutdown(struct mmc_card *card)
{ {
} }
static struct device_driver mmc_driver = { static struct mmc_driver mmc_driver = {
.name = "mmc_test", .drv = {
.name = "mmc_test",
},
.probe = mmc_test_probe, .probe = mmc_test_probe,
.remove = mmc_test_remove, .remove = mmc_test_remove,
.shutdown = mmc_test_shutdown, .shutdown = mmc_test_shutdown,

41
drivers/mmc/core/bus.c
View File

@ -26,6 +26,8 @@
#include "sdio_cis.h" #include "sdio_cis.h"
#include "bus.h" #include "bus.h"
#define to_mmc_driver(d) container_of(d, struct mmc_driver, drv)
static ssize_t type_show(struct device *dev, static ssize_t type_show(struct device *dev,
struct device_attribute *attr, char *buf) struct device_attribute *attr, char *buf)
{ {
@ -105,14 +107,33 @@ mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
return retval; return retval;
} }
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);
}
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;
}
static void mmc_bus_shutdown(struct device *dev) 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_card *card = mmc_dev_to_card(dev);
struct mmc_host *host = card->host; struct mmc_host *host = card->host;
int ret; int ret;
if (dev->driver && dev->driver->shutdown) if (dev->driver && drv->shutdown)
dev->driver->shutdown(dev); drv->shutdown(card);
if (host->bus_ops->shutdown) { if (host->bus_ops->shutdown) {
ret = host->bus_ops->shutdown(host); ret = host->bus_ops->shutdown(host);
@ -181,6 +202,8 @@ static struct bus_type mmc_bus_type = {
.dev_groups = mmc_dev_groups, .dev_groups = mmc_dev_groups,
.match = mmc_bus_match, .match = mmc_bus_match,
.uevent = mmc_bus_uevent, .uevent = mmc_bus_uevent,
.probe = mmc_bus_probe,
.remove = mmc_bus_remove,
.shutdown = mmc_bus_shutdown, .shutdown = mmc_bus_shutdown,
.pm = &mmc_bus_pm_ops, .pm = &mmc_bus_pm_ops,
}; };
@ -199,22 +222,24 @@ void mmc_unregister_bus(void)
* mmc_register_driver - register a media driver * mmc_register_driver - register a media driver
* @drv: MMC media driver * @drv: MMC media driver
*/ */
int mmc_register_driver(struct device_driver *drv) int mmc_register_driver(struct mmc_driver *drv)
{ {
drv->bus = &mmc_bus_type; drv->drv.bus = &mmc_bus_type;
return driver_register(drv); return driver_register(&drv->drv);
} }
EXPORT_SYMBOL(mmc_register_driver); EXPORT_SYMBOL(mmc_register_driver);
/** /**
* mmc_unregister_driver - unregister a media driver * mmc_unregister_driver - unregister a media driver
* @drv: MMC media driver * @drv: MMC media driver
*/ */
void mmc_unregister_driver(struct device_driver *drv) void mmc_unregister_driver(struct mmc_driver *drv)
{ {
drv->bus = &mmc_bus_type; drv->drv.bus = &mmc_bus_type;
driver_unregister(drv); driver_unregister(&drv->drv);
} }
EXPORT_SYMBOL(mmc_unregister_driver); EXPORT_SYMBOL(mmc_unregister_driver);
static void mmc_release_card(struct device *dev) static void mmc_release_card(struct device *dev)

2
drivers/mmc/core/pwrseq.c
View File

@ -73,7 +73,7 @@ int mmc_pwrseq_alloc(struct mmc_host *host)
pwrseq = match->alloc(host, &pdev->dev); pwrseq = match->alloc(host, &pdev->dev);
if (IS_ERR(pwrseq)) { if (IS_ERR(pwrseq)) {
ret = PTR_ERR(host->pwrseq); ret = PTR_ERR(pwrseq);
goto err; goto err;
} }

14
include/linux/mmc/card.h
View File

@ -512,8 +512,18 @@ static inline int mmc_card_broken_irq_polling(const struct mmc_card *c)
#define mmc_dev_to_card(d) container_of(d, struct mmc_card, dev) #define mmc_dev_to_card(d) container_of(d, struct mmc_card, dev)
extern int mmc_register_driver(struct device_driver *); /*
extern void mmc_unregister_driver(struct device_driver *); * MMC device driver (e.g., Flash card, I/O card...)
*/
struct mmc_driver {
struct device_driver drv;
int (*probe)(struct mmc_card *);
void (*remove)(struct mmc_card *);
void (*shutdown)(struct mmc_card *);
};
extern int mmc_register_driver(struct mmc_driver *);
extern void mmc_unregister_driver(struct mmc_driver *);
extern void mmc_fixup_device(struct mmc_card *card, extern void mmc_fixup_device(struct mmc_card *card,
const struct mmc_fixup *table); const struct mmc_fixup *table);