Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 14:11:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

sh: add the sh_ prefix to early platform symbols

Browse Source 
Old early platform device support is now sh-specific. Before moving on
to implementing new early platform framework based on real platform
devices, prefix all early platform symbols with 'sh_'.

Signed-off-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>
Cc: Rich Felker <dalias@libc.org>
Link: https://lore.kernel.org/r/20191003092913.10731-3-brgl@bgdev.pl
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Bartosz Golaszewski 2019-10-03 11:29:13 +02:00 committed by Greg Kroah-Hartman
parent 507fd01d53
commit 201e91091b
37 changed files with 94 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
arch/sh/drivers/platform_early.c
View File

@ -4,8 +4,8 @@
#include <linux/mod_devicetable.h>
#include <linux/pm.h>
static __initdata LIST_HEAD(early_platform_driver_list);
static __initdata LIST_HEAD(early_platform_device_list);
static __initdata LIST_HEAD(sh_early_platform_driver_list);
static __initdata LIST_HEAD(sh_early_platform_device_list);
static const struct platform_device_id *
platform_match_id(const struct platform_device_id *id,
@ -58,13 +58,13 @@ static void pm_runtime_early_init(struct device *dev) {}
#endif
/**
* early_platform_driver_register - register early platform driver
* @epdrv: early_platform driver structure
* sh_early_platform_driver_register - register early platform driver
* @epdrv: sh_early_platform driver structure
* @buf: string passed from early_param()
*
* Helper function for early_platform_init() / early_platform_init_buffer()
* Helper function for sh_early_platform_init() / sh_early_platform_init_buffer()
*/
int __init early_platform_driver_register(struct early_platform_driver *epdrv,
int __init sh_early_platform_driver_register(struct sh_early_platform_driver *epdrv,
char *buf)
{
char *tmp;
@ -75,7 +75,7 @@ int __init early_platform_driver_register(struct early_platform_driver *epdrv,
*/
if (!epdrv->list.next) {
INIT_LIST_HEAD(&epdrv->list);
list_add_tail(&epdrv->list, &early_platform_driver_list);
list_add_tail(&epdrv->list, &sh_early_platform_driver_list);
}
/* If the user has specified device then make sure the driver
@ -84,7 +84,7 @@ int __init early_platform_driver_register(struct early_platform_driver *epdrv,
*/
n = strlen(epdrv->pdrv->driver.name);
if (buf && !strncmp(buf, epdrv->pdrv->driver.name, n)) {
list_move(&epdrv->list, &early_platform_driver_list);
list_move(&epdrv->list, &sh_early_platform_driver_list);
/* Allow passing parameters after device name */
if (buf[n] == '\0' || buf[n] == ',')
@ -114,14 +114,14 @@ int __init early_platform_driver_register(struct early_platform_driver *epdrv,
}
/**
* early_platform_add_devices - adds a number of early platform devices
* sh_early_platform_add_devices - adds a number of early platform devices
* @devs: array of early platform devices to add
* @num: number of early platform devices in array
*
* Used by early architecture code to register early platform devices and
* their platform data.
*/
void __init early_platform_add_devices(struct platform_device **devs, int num)
void __init sh_early_platform_add_devices(struct platform_device **devs, int num)
{
struct device *dev;
int i;
@ -134,20 +134,20 @@ void __init early_platform_add_devices(struct platform_device **devs, int num)
pm_runtime_early_init(dev);
INIT_LIST_HEAD(&dev->devres_head);
list_add_tail(&dev->devres_head,
&early_platform_device_list);
&sh_early_platform_device_list);
}
}
}
/**
* early_platform_driver_register_all - register early platform drivers
* sh_early_platform_driver_register_all - register early platform drivers
* @class_str: string to identify early platform driver class
*
* Used by architecture code to register all early platform drivers
* for a certain class. If omitted then only early platform drivers
* with matching kernel command line class parameters will be registered.
*/
void __init early_platform_driver_register_all(char *class_str)
void __init sh_early_platform_driver_register_all(char *class_str)
{
/* The "class_str" parameter may or may not be present on the kernel
* command line. If it is present then there may be more than one
@ -160,23 +160,23 @@ void __init early_platform_driver_register_all(char *class_str)
* We use parse_early_options() to make sure the early_param() gets
* called at least once. The early_param() may be called more than
* once since the name of the preferred device may be specified on
* the kernel command line. early_platform_driver_register() handles
* the kernel command line. sh_early_platform_driver_register() handles
* this case for us.
*/
parse_early_options(class_str);
}
/**
* early_platform_match - find early platform device matching driver
* sh_early_platform_match - find early platform device matching driver
* @epdrv: early platform driver structure
* @id: id to match against
*/
static struct platform_device * __init
early_platform_match(struct early_platform_driver *epdrv, int id)
sh_early_platform_match(struct sh_early_platform_driver *epdrv, int id)
{
struct platform_device *pd;
list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
list_for_each_entry(pd, &sh_early_platform_device_list, dev.devres_head)
if (platform_match(&pd->dev, &epdrv->pdrv->driver))
if (pd->id == id)
return pd;
@ -185,16 +185,16 @@ early_platform_match(struct early_platform_driver *epdrv, int id)
}
/**
* early_platform_left - check if early platform driver has matching devices
* sh_early_platform_left - check if early platform driver has matching devices
* @epdrv: early platform driver structure
* @id: return true if id or above exists
*/
static int __init early_platform_left(struct early_platform_driver *epdrv,
static int __init sh_early_platform_left(struct sh_early_platform_driver *epdrv,
int id)
{
struct platform_device *pd;
list_for_each_entry(pd, &early_platform_device_list, dev.devres_head)
list_for_each_entry(pd, &sh_early_platform_device_list, dev.devres_head)
if (platform_match(&pd->dev, &epdrv->pdrv->driver))
if (pd->id >= id)
return 1;
@ -203,22 +203,22 @@ static int __init early_platform_left(struct early_platform_driver *epdrv,
}
/**
* early_platform_driver_probe_id - probe drivers matching class_str and id
* sh_early_platform_driver_probe_id - probe drivers matching class_str and id
* @class_str: string to identify early platform driver class
* @id: id to match against
* @nr_probe: number of platform devices to successfully probe before exiting
*/
static int __init early_platform_driver_probe_id(char *class_str,
static int __init sh_early_platform_driver_probe_id(char *class_str,
int id,
int nr_probe)
{
struct early_platform_driver *epdrv;
struct sh_early_platform_driver *epdrv;
struct platform_device *match;
int match_id;
int n = 0;
int left = 0;
list_for_each_entry(epdrv, &early_platform_driver_list, list) {
list_for_each_entry(epdrv, &sh_early_platform_driver_list, list) {
/* only use drivers matching our class_str */
if (strcmp(class_str, epdrv->class_str))
continue;
@ -229,7 +229,7 @@ static int __init early_platform_driver_probe_id(char *class_str,
} else {
match_id = id;
left += early_platform_left(epdrv, id);
left += sh_early_platform_left(epdrv, id);
/* skip requested id */
switch (epdrv->requested_id) {
@ -251,7 +251,7 @@ static int __init early_platform_driver_probe_id(char *class_str,
match = NULL;
break;
default:
match = early_platform_match(epdrv, match_id);
match = sh_early_platform_match(epdrv, match_id);
}
if (match) {
@ -293,7 +293,7 @@ static int __init early_platform_driver_probe_id(char *class_str,
}
/**
* early_platform_driver_probe - probe a class of registered drivers
* sh_early_platform_driver_probe - probe a class of registered drivers
* @class_str: string to identify early platform driver class
* @nr_probe: number of platform devices to successfully probe before exiting
* @user_only: only probe user specified early platform devices
@ -302,7 +302,7 @@ static int __init early_platform_driver_probe_id(char *class_str,
* within a certain class. For probe to happen a registered early platform
* device matching a registered early platform driver is needed.
*/
int __init early_platform_driver_probe(char *class_str,
int __init sh_early_platform_driver_probe(char *class_str,
int nr_probe,
int user_only)
{
@ -310,7 +310,7 @@ int __init early_platform_driver_probe(char *class_str,
n = 0;
for (i = -2; n < nr_probe; i++) {
k = early_platform_driver_probe_id(class_str, i, nr_probe - n);
k = sh_early_platform_driver_probe_id(class_str, i, nr_probe - n);
if (k < 0)
break;
@ -325,14 +325,14 @@ int __init early_platform_driver_probe(char *class_str,
}
/**
* early_platform_cleanup - clean up early platform code
* sh_early_platform_cleanup - clean up early platform code
*/
static int __init early_platform_cleanup(void)
static int __init sh_early_platform_cleanup(void)
{
struct platform_device *pd, *pd2;
/* clean up the devres list used to chain devices */
list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
list_for_each_entry_safe(pd, pd2, &sh_early_platform_device_list,
dev.devres_head) {
list_del(&pd->dev.devres_head);
memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
@ -344,4 +344,4 @@ static int __init early_platform_cleanup(void)
* This must happen once after all early devices are probed but before probing
* real platform devices.
*/
subsys_initcall(early_platform_cleanup);
subsys_initcall(sh_early_platform_cleanup);

30
arch/sh/include/asm/platform_early.h
View File

@ -8,7 +8,7 @@
#include <linux/pm_runtime.h>
#include <linux/slab.h>
struct early_platform_driver {
struct sh_early_platform_driver {
const char *class_str;
struct platform_driver *pdrv;
struct list_head list;
@ -20,39 +20,39 @@ struct early_platform_driver {
#define EARLY_PLATFORM_ID_UNSET -2
#define EARLY_PLATFORM_ID_ERROR -3
extern int early_platform_driver_register(struct early_platform_driver *epdrv,
extern int sh_early_platform_driver_register(struct sh_early_platform_driver *epdrv,
char *buf);
extern void early_platform_add_devices(struct platform_device **devs, int num);
extern void sh_early_platform_add_devices(struct platform_device **devs, int num);
static inline int is_early_platform_device(struct platform_device *pdev)
static inline int is_sh_early_platform_device(struct platform_device *pdev)
{
return !pdev->dev.driver;
}
extern void early_platform_driver_register_all(char *class_str);
extern int early_platform_driver_probe(char *class_str,
extern void sh_early_platform_driver_register_all(char *class_str);
extern int sh_early_platform_driver_probe(char *class_str,
int nr_probe, int user_only);
#define early_platform_init(class_string, platdrv) \
early_platform_init_buffer(class_string, platdrv, NULL, 0)
#define sh_early_platform_init(class_string, platdrv) \
sh_early_platform_init_buffer(class_string, platdrv, NULL, 0)
#ifndef MODULE
#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
static __initdata struct early_platform_driver early_driver = { \
#define sh_early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
static __initdata struct sh_early_platform_driver early_driver = { \
.class_str = class_string, \
.buffer = buf, \
.bufsize = bufsiz, \
.pdrv = platdrv, \
.requested_id = EARLY_PLATFORM_ID_UNSET, \
}; \
static int __init early_platform_driver_setup_func(char *buffer) \
static int __init sh_early_platform_driver_setup_func(char *buffer) \
{ \
return early_platform_driver_register(&early_driver, buffer); \
return sh_early_platform_driver_register(&early_driver, buffer); \
} \
early_param(class_string, early_platform_driver_setup_func)
early_param(class_string, sh_early_platform_driver_setup_func)
#else /* MODULE */
#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
static inline char *early_platform_driver_setup_func(void) \
#define sh_early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
static inline char *sh_early_platform_driver_setup_func(void) \
{ \
return bufsiz ? buf : NULL; \
}

2
arch/sh/kernel/cpu/sh2/setup-sh7619.c
View File

@ -200,6 +200,6 @@ void __init plat_early_device_setup(void)
/* enable CMT clock */
__raw_writeb(__raw_readb(STBCR3) & ~0x10, STBCR3);
early_platform_add_devices(sh7619_early_devices,
sh_early_platform_add_devices(sh7619_early_devices,
ARRAY_SIZE(sh7619_early_devices));
}

2
arch/sh/kernel/cpu/sh2a/setup-mxg.c
View File

@ -170,6 +170,6 @@ static struct platform_device *mxg_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(mxg_early_devices,
sh_early_platform_add_devices(mxg_early_devices,
ARRAY_SIZE(mxg_early_devices));
}

2
arch/sh/kernel/cpu/sh2a/setup-sh7201.c
View File

@ -413,6 +413,6 @@ void __init plat_early_device_setup(void)
/* enable MTU2 clock */
__raw_writeb(__raw_readb(STBCR3) & ~0x20, STBCR3);
early_platform_add_devices(sh7201_early_devices,
sh_early_platform_add_devices(sh7201_early_devices,
ARRAY_SIZE(sh7201_early_devices));
}

2
arch/sh/kernel/cpu/sh2a/setup-sh7203.c
View File

@ -350,6 +350,6 @@ void __init plat_early_device_setup(void)
/* enable MTU2 clock */
__raw_writeb(__raw_readb(STBCR3) & ~0x20, STBCR3);
early_platform_add_devices(sh7203_early_devices,
sh_early_platform_add_devices(sh7203_early_devices,
ARRAY_SIZE(sh7203_early_devices));
}

2
arch/sh/kernel/cpu/sh2a/setup-sh7206.c
View File

@ -286,6 +286,6 @@ void __init plat_early_device_setup(void)
/* enable MTU2 clock */
__raw_writeb(__raw_readb(STBCR3) & ~0x20, STBCR3);
early_platform_add_devices(sh7206_early_devices,
sh_early_platform_add_devices(sh7206_early_devices,
ARRAY_SIZE(sh7206_early_devices));
}

2
arch/sh/kernel/cpu/sh2a/setup-sh7264.c
View File

@ -547,6 +547,6 @@ static struct platform_device *sh7264_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7264_early_devices,
sh_early_platform_add_devices(sh7264_early_devices,
ARRAY_SIZE(sh7264_early_devices));
}

2
arch/sh/kernel/cpu/sh2a/setup-sh7269.c
View File

@ -563,6 +563,6 @@ static struct platform_device *sh7269_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7269_early_devices,
sh_early_platform_add_devices(sh7269_early_devices,
ARRAY_SIZE(sh7269_early_devices));
}

2
arch/sh/kernel/cpu/sh3/setup-sh7705.c
View File

@ -179,7 +179,7 @@ static struct platform_device *sh7705_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7705_early_devices,
sh_early_platform_add_devices(sh7705_early_devices,
ARRAY_SIZE(sh7705_early_devices));
}

2
arch/sh/kernel/cpu/sh3/setup-sh770x.c
View File

@ -231,7 +231,7 @@ static struct platform_device *sh770x_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh770x_early_devices,
sh_early_platform_add_devices(sh770x_early_devices,
ARRAY_SIZE(sh770x_early_devices));
}

2
arch/sh/kernel/cpu/sh3/setup-sh7710.c
View File

@ -178,7 +178,7 @@ static struct platform_device *sh7710_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7710_early_devices,
sh_early_platform_add_devices(sh7710_early_devices,
ARRAY_SIZE(sh7710_early_devices));
}

2
arch/sh/kernel/cpu/sh3/setup-sh7720.c
View File

@ -212,7 +212,7 @@ static struct platform_device *sh7720_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7720_early_devices,
sh_early_platform_add_devices(sh7720_early_devices,
ARRAY_SIZE(sh7720_early_devices));
}

2
arch/sh/kernel/cpu/sh4/setup-sh4-202.c
View File

@ -77,7 +77,7 @@ static struct platform_device *sh4202_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh4202_early_devices,
sh_early_platform_add_devices(sh4202_early_devices,
ARRAY_SIZE(sh4202_early_devices));
}

8
arch/sh/kernel/cpu/sh4/setup-sh7750.c
View File

@ -162,15 +162,15 @@ void __init plat_early_device_setup(void)
if (mach_is_rts7751r2d()) {
scif_platform_data.scscr |= SCSCR_CKE1;
dev[0] = &scif_device;
early_platform_add_devices(dev, 1);
sh_early_platform_add_devices(dev, 1);
} else {
dev[0] = &sci_device;
early_platform_add_devices(dev, 1);
sh_early_platform_add_devices(dev, 1);
dev[0] = &scif_device;
early_platform_add_devices(dev, 1);
sh_early_platform_add_devices(dev, 1);
}
early_platform_add_devices(sh7750_early_devices,
sh_early_platform_add_devices(sh7750_early_devices,
ARRAY_SIZE(sh7750_early_devices));
}

2
arch/sh/kernel/cpu/sh4/setup-sh7760.c
View File

@ -272,7 +272,7 @@ static struct platform_device *sh7760_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7760_early_devices,
sh_early_platform_add_devices(sh7760_early_devices,
ARRAY_SIZE(sh7760_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7343.c
View File

@ -297,7 +297,7 @@ static struct platform_device *sh7343_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7343_early_devices,
sh_early_platform_add_devices(sh7343_early_devices,
ARRAY_SIZE(sh7343_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7366.c
View File

@ -241,7 +241,7 @@ static struct platform_device *sh7366_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7366_early_devices,
sh_early_platform_add_devices(sh7366_early_devices,
ARRAY_SIZE(sh7366_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7722.c
View File

@ -513,7 +513,7 @@ static struct platform_device *sh7722_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7722_early_devices,
sh_early_platform_add_devices(sh7722_early_devices,
ARRAY_SIZE(sh7722_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7723.c
View File

@ -411,7 +411,7 @@ static struct platform_device *sh7723_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7723_early_devices,
sh_early_platform_add_devices(sh7723_early_devices,
ARRAY_SIZE(sh7723_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7724.c
View File

@ -831,7 +831,7 @@ static struct platform_device *sh7724_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7724_early_devices,
sh_early_platform_add_devices(sh7724_early_devices,
ARRAY_SIZE(sh7724_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7734.c
View File

@ -281,7 +281,7 @@ static struct platform_device *sh7734_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7734_early_devices,
sh_early_platform_add_devices(sh7734_early_devices,
ARRAY_SIZE(sh7734_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7757.c
View File

@ -768,7 +768,7 @@ static struct platform_device *sh7757_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7757_early_devices,
sh_early_platform_add_devices(sh7757_early_devices,
ARRAY_SIZE(sh7757_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7763.c
View File

@ -222,7 +222,7 @@ static struct platform_device *sh7763_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7763_early_devices,
sh_early_platform_add_devices(sh7763_early_devices,
ARRAY_SIZE(sh7763_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7770.c
View File

@ -317,7 +317,7 @@ static struct platform_device *sh7770_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7770_early_devices,
sh_early_platform_add_devices(sh7770_early_devices,
ARRAY_SIZE(sh7770_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7780.c
View File

@ -286,7 +286,7 @@ void __init plat_early_device_setup(void)
scif1_platform_data.scscr &= ~SCSCR_CKE1;
}
early_platform_add_devices(sh7780_early_devices,
sh_early_platform_add_devices(sh7780_early_devices,
ARRAY_SIZE(sh7780_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7785.c
View File

@ -354,7 +354,7 @@ static struct platform_device *sh7785_early_devices[] __initdata = {
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7785_early_devices,
sh_early_platform_add_devices(sh7785_early_devices,
ARRAY_SIZE(sh7785_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-sh7786.c
View File

@ -835,6 +835,6 @@ arch_initcall(sh7786_devices_setup);
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh7786_early_devices,
sh_early_platform_add_devices(sh7786_early_devices,
ARRAY_SIZE(sh7786_early_devices));
}

2
arch/sh/kernel/cpu/sh4a/setup-shx3.c
View File

@ -153,7 +153,7 @@ arch_initcall(shx3_devices_setup);
void __init plat_early_device_setup(void)
{
early_platform_add_devices(shx3_early_devices,
sh_early_platform_add_devices(shx3_early_devices,
ARRAY_SIZE(shx3_early_devices));
}

2
arch/sh/kernel/cpu/sh5/setup-sh5.c
View File

@ -116,6 +116,6 @@ arch_initcall(sh5_devices_setup);
void __init plat_early_device_setup(void)
{
early_platform_add_devices(sh5_early_devices,
sh_early_platform_add_devices(sh5_early_devices,
ARRAY_SIZE(sh5_early_devices));
}

2
arch/sh/kernel/setup.c
View File

@ -329,7 +329,7 @@ void __init setup_arch(char **cmdline_p)
sh_mv_setup();
/* Let earlyprintk output early console messages */
early_platform_driver_probe("earlyprintk", 1, 1);
sh_early_platform_driver_probe("earlyprintk", 1, 1);
#ifdef CONFIG_OF_FLATTREE
#ifdef CONFIG_USE_BUILTIN_DTB

4
arch/sh/kernel/time.c
View File

@ -31,8 +31,8 @@ static void __init sh_late_time_init(void)
* clocksource and the jiffies clocksource is used transparently
* instead. No error handling is necessary here.
*/
early_platform_driver_register_all("earlytimer");
early_platform_driver_probe("earlytimer", 2, 0);
sh_early_platform_driver_register_all("earlytimer");
sh_early_platform_driver_probe("earlytimer", 2, 0);
}
void __init time_init(void)

6
drivers/clocksource/sh_cmt.c
View File

@ -1056,7 +1056,7 @@ static int sh_cmt_probe(struct platform_device *pdev)
struct sh_cmt_device *cmt = platform_get_drvdata(pdev);
int ret;
if (!is_early_platform_device(pdev)) {
if (!is_sh_early_platform_device(pdev)) {
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
}
@ -1076,7 +1076,7 @@ static int sh_cmt_probe(struct platform_device *pdev)
pm_runtime_idle(&pdev->dev);
return ret;
}
if (is_early_platform_device(pdev))
if (is_sh_early_platform_device(pdev))
return 0;
out:
@ -1114,7 +1114,7 @@ static void __exit sh_cmt_exit(void)
}
#ifdef CONFIG_SUPERH
early_platform_init("earlytimer", &sh_cmt_device_driver);
sh_early_platform_init("earlytimer", &sh_cmt_device_driver);
#endif
subsys_initcall(sh_cmt_init);

6
drivers/clocksource/sh_mtu2.c
View File

@ -446,7 +446,7 @@ static int sh_mtu2_probe(struct platform_device *pdev)
struct sh_mtu2_device *mtu = platform_get_drvdata(pdev);
int ret;
if (!is_early_platform_device(pdev)) {
if (!is_sh_early_platform_device(pdev)) {
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
}
@ -466,7 +466,7 @@ static int sh_mtu2_probe(struct platform_device *pdev)
pm_runtime_idle(&pdev->dev);
return ret;
}
if (is_early_platform_device(pdev))
if (is_sh_early_platform_device(pdev))
return 0;
out:
@ -516,7 +516,7 @@ static void __exit sh_mtu2_exit(void)
}
#ifdef CONFIG_SUPERH
early_platform_init("earlytimer", &sh_mtu2_device_driver);
sh_early_platform_init("earlytimer", &sh_mtu2_device_driver);
#endif
subsys_initcall(sh_mtu2_init);

6
drivers/clocksource/sh_tmu.c
View File

@ -599,7 +599,7 @@ static int sh_tmu_probe(struct platform_device *pdev)
struct sh_tmu_device *tmu = platform_get_drvdata(pdev);
int ret;
if (!is_early_platform_device(pdev)) {
if (!is_sh_early_platform_device(pdev)) {
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
}
@ -620,7 +620,7 @@ static int sh_tmu_probe(struct platform_device *pdev)
return ret;
}
if (is_early_platform_device(pdev))
if (is_sh_early_platform_device(pdev))
return 0;
out:
@ -671,7 +671,7 @@ static void __exit sh_tmu_exit(void)
}
#ifdef CONFIG_SUPERH
early_platform_init("earlytimer", &sh_tmu_device_driver);
sh_early_platform_init("earlytimer", &sh_tmu_device_driver);
#endif
subsys_initcall(sh_tmu_init);

4
drivers/tty/serial/sh-sci.c
View File

@ -3318,7 +3318,7 @@ static int sci_probe(struct platform_device *dev)
* to make it beyond this yet.
*/
#ifdef CONFIG_SUPERH
if (is_early_platform_device(dev))
if (is_sh_early_platform_device(dev))
return sci_probe_earlyprintk(dev);
#endif
@ -3416,7 +3416,7 @@ static void __exit sci_exit(void)
}
#if defined(CONFIG_SUPERH) && defined(CONFIG_SERIAL_SH_SCI_CONSOLE)
early_platform_init_buffer("earlyprintk", &sci_driver,
sh_early_platform_init_buffer("earlyprintk", &sci_driver,
early_serial_buf, ARRAY_SIZE(early_serial_buf));
#endif
#ifdef CONFIG_SERIAL_SH_SCI_EARLYCON

2
include/linux/platform_device.h
View File

@ -332,7 +332,7 @@ extern int platform_dma_configure(struct device *dev);
* drivers. It should go away once we introduce the new platform_device-based
* early driver framework.
*/
static inline int is_early_platform_device(struct platform_device *pdev)
static inline int is_sh_early_platform_device(struct platform_device *pdev)
{
return 0;
}