| Message ID | 1560796871-18560-1-git-send-email-info@metux.net |
|---|---|
| State | New |
| Headers | show |
| Series | [01/30] include: linux: platform_device: more helpers for declaring platform drivers | expand |
On Mon, Jun 17, 2019 at 08:40:42PM +0200, Enrico Weigelt, metux IT consult wrote: > From: Enrico Weigelt <info@metux.net> > > Add more helper macros for trivial driver init cases, similar to the > already existing module_platform_driver()+friends - now for those which > are initialized at other stages. Lots of drivers couldn't use the existing > macros, as they need to be called at different init stages, eg. subsys, > postcore, arch. > > This helps to further reduce driver init boilerplate. > +/* postcore_platform_driver() - Helper macro for drivers that don't do > + * anything special in module init/exit. This eliminates a lot of > + * boilerplate. Each module may only use this macro once, and > + * calling it replaces postcore_initcall() and module_exit() > + */ Perhaps you meant kernel-doc format?
On Mon, Jun 17, 2019 at 8:41 PM Enrico Weigelt, metux IT consult <info@metux.net> wrote: > From: Enrico Weigelt <info@metux.net> > > Add more helper macros for trivial driver init cases, similar to the > already existing module_platform_driver()+friends - now for those which > are initialized at other stages. Lots of drivers couldn't use the existing > macros, as they need to be called at different init stages, eg. subsys, > postcore, arch. > > This helps to further reduce driver init boilerplate. > > Signed-off-by: Enrico Weigelt <info@metux.net> You need to send this to Greg as device core maintainer. Possibly to Rafael as well, he did a very intersting rework on device dependencies with device links. While in general I agree that this diets down a lot of duplicate code that we have done the same way over and over, there is the issue that we don't want any drivers to do this mockery and instead use deferred probe and ultimately just probe in the right order. I think device links were supposed to fix this up, but it indeed assumes that you know of these dependencies before you start probing the first driver, and often you do not, unless the hardware description explicitly encodes that. And that is one big problem. If we should do this, device core changes must be merged or explicitly ACKed first. Yours, Linus Walleij
Hello, On Mon, Jun 17, 2019 at 08:40:42PM +0200, Enrico Weigelt, metux IT consult wrote: > From: Enrico Weigelt <info@metux.net> > > Add more helper macros for trivial driver init cases, similar to the > already existing module_platform_driver()+friends - now for those which > are initialized at other stages. Lots of drivers couldn't use the existing > macros, as they need to be called at different init stages, eg. subsys, > postcore, arch. > > This helps to further reduce driver init boilerplate. > > Signed-off-by: Enrico Weigelt <info@metux.net> > --- > include/linux/platform_device.h | 51 +++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 51 insertions(+) > > diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h > index beb25f2..5f3a967 100644 > --- a/include/linux/platform_device.h > +++ b/include/linux/platform_device.h > @@ -259,6 +259,57 @@ static inline void platform_set_drvdata(struct platform_device *pdev, > } \ > module_exit(__platform_driver##_exit); > > +/* postcore_platform_driver() - Helper macro for drivers that don't do > + * anything special in module init/exit. This eliminates a lot of > + * boilerplate. Each module may only use this macro once, and > + * calling it replaces postcore_initcall() and module_exit() > + */ > +#define postcore_platform_driver(__platform_driver) \ > +static int __init __platform_driver##_init(void) \ > +{ \ > + return platform_driver_register(&(__platform_driver)); \ > +} \ > +postcore_initcall(__platform_driver##_init); \ > +static void __exit __platform_driver##_exit(void) \ > +{ \ > + platform_driver_unregister(&(__platform_driver)); \ > +} \ > +module_exit(__platform_driver##_exit); > + > +/* subsys_platform_driver() - Helper macro for drivers that don't do > + * anything special in module init/exit. This eliminates a lot of > + * boilerplate. Each module may only use this macro once, and > + * calling it replaces subsys_initcall() and module_exit() > + */ > +#define subsys_platform_driver(__platform_driver) \ > +static int __init __platform_driver##_init(void) \ > +{ \ > + return platform_driver_register(&(__platform_driver)); \ > +} \ > +subsys_initcall(__platform_driver##_init); \ > +static void __exit __platform_driver##_exit(void) \ > +{ \ > + platform_driver_unregister(&(__platform_driver)); \ > +} \ > +module_exit(__platform_driver##_exit); Would it make sense to do something like: #define __module_platform_driver(__platform_driver, __initlvl) \ static int __init __platform_driver##_init(void) \ { \ return platform_driver_register(&(__platform_driver)); \ } \ __initlvl ## _initcall(__platform_driver##_init); \ static void __exit __platform_driver##_exit(void) \ { \ platform_driver_unregister(&(__platform_driver)); \ } \ module_exit(__platform_driver##_exit); #define postcore_platform_driver(__platform_driver) __module_platform_driver(__platform_driver, postcore) #define subsys_platform_driver(__platform_driver) __module_platform_driver(__platform_driver, subsys) ... Which would be more compact and makes the difference between these macros a bit more obvious. Best regards Uwe
On 26.06.19 08:14, Uwe Kleine-König wrote: Hi, > Would it make sense to do something like: > > #define __module_platform_driver(__platform_driver, __initlvl) \ > static int __init __platform_driver##_init(void) \ > { \ > return platform_driver_register(&(__platform_driver)); \ > } \ > __initlvl ## _initcall(__platform_driver##_init); \ > static void __exit __platform_driver##_exit(void) \ > { \ > platform_driver_unregister(&(__platform_driver)); \ > } \ > module_exit(__platform_driver##_exit); > > #define postcore_platform_driver(__platform_driver) __module_platform_driver(__platform_driver, postcore) > #define subsys_platform_driver(__platform_driver) __module_platform_driver(__platform_driver, subsys) > ... > > Which would be more compact and makes the difference between these > macros a bit more obvious. yeah, could do that, but not sure whether it's really good for readability when we have so many nested macros :p OTOH, I didn't want to touch the existing macros for now, just trim down the actual init boilerplate, postponing further compactions for later. --mtx
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h index beb25f2..5f3a967 100644 --- a/include/linux/platform_device.h +++ b/include/linux/platform_device.h @@ -259,6 +259,57 @@ static inline void platform_set_drvdata(struct platform_device *pdev, } \ module_exit(__platform_driver##_exit); +/* postcore_platform_driver() - Helper macro for drivers that don't do + * anything special in module init/exit. This eliminates a lot of + * boilerplate. Each module may only use this macro once, and + * calling it replaces postcore_initcall() and module_exit() + */ +#define postcore_platform_driver(__platform_driver) \ +static int __init __platform_driver##_init(void) \ +{ \ + return platform_driver_register(&(__platform_driver)); \ +} \ +postcore_initcall(__platform_driver##_init); \ +static void __exit __platform_driver##_exit(void) \ +{ \ + platform_driver_unregister(&(__platform_driver)); \ +} \ +module_exit(__platform_driver##_exit); + +/* subsys_platform_driver() - Helper macro for drivers that don't do + * anything special in module init/exit. This eliminates a lot of + * boilerplate. Each module may only use this macro once, and + * calling it replaces subsys_initcall() and module_exit() + */ +#define subsys_platform_driver(__platform_driver) \ +static int __init __platform_driver##_init(void) \ +{ \ + return platform_driver_register(&(__platform_driver)); \ +} \ +subsys_initcall(__platform_driver##_init); \ +static void __exit __platform_driver##_exit(void) \ +{ \ + platform_driver_unregister(&(__platform_driver)); \ +} \ +module_exit(__platform_driver##_exit); + +/* arch_platform_driver() - Helper macro for drivers that don't do + * anything special in module init/exit. This eliminates a lot of + * boilerplate. Each module may only use this macro once, and + * calling it replaces arch_initcall() and module_exit() + */ +#define arch_platform_driver(__platform_driver) \ +static int __init __platform_driver##_init(void) \ +{ \ + return platform_driver_register(&(__platform_driver)); \ +} \ +arch_initcall(__platform_driver##_init); \ +static void __exit __platform_driver##_exit(void) \ +{ \ + platform_driver_unregister(&(__platform_driver)); \ +} \ +module_exit(__platform_driver##_exit); + /* builtin_platform_driver_probe() - Helper macro for drivers that don't do * anything special in device init. This eliminates some boilerplate. Each * driver may only use this macro once, and using it replaces device_initcall.