Commit 201e9109 authored by Bartosz Golaszewski's avatar Bartosz Golaszewski Committed by Greg Kroah-Hartman
Browse files

sh: add the sh_ prefix to early platform symbols 



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: default avatarBartosz 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: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 507fd01d

arch/sh/drivers/platform_early.c

+33 −33
Original line number Diff line number Diff line
@@ -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);

arch/sh/include/asm/platform_early.h

+15 −15
Original line number Diff line number Diff line
@@ -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;					\

}

arch/sh/kernel/cpu/sh2/setup-sh7619.c

+1 −1
Original line number Diff line number Diff line
@@ -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));

}

arch/sh/kernel/cpu/sh2a/setup-mxg.c

+1 −1
Original line number Diff line number Diff line
@@ -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));

}

arch/sh/kernel/cpu/sh2a/setup-sh7201.c

+1 −1
Original line number Diff line number Diff line
@@ -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));

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE