rmodules: use rmodtool to create rmodules

Start using the rmodtool for generating rmodules.
rmodule_link() has been changed to create 2 rules:
one for the passed in <name>, the other for creating
<name>.rmod which is an ELF file in the format of
an rmodule.

Since the header is not compiled and linked together
with an rmodule there needs to be a way of marking
which symbol is the entry point. __rmodule_entry is
the symbol used for knowing the entry point. There
was a little churn in SMM modules to ensure an
rmodule entry point symbol takes a single argument.

Change-Id: Ie452ed866f6596bf13f137f5b832faa39f48d26e
Signed-off-by: Aaron Durbin <adurbin@chromium.org>
Reviewed-on: http://review.coreboot.org/5379
Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
Tested-by: build bot (Jenkins)

3 files changed, 17 insertions, 44 deletions

diff --git a/src/include/cpu/x86/smm.h b/src/include/cpu/x86/smm.h
index 3ab43ff2ce..f63420fab5 100644
--- a/src/include/cpu/x86/smm.h
+++ b/src/include/cpu/x86/smm.h
@@ -517,14 +517,20 @@ struct smm_runtime {
 	u8 apic_id_to_cpu[CONFIG_MAX_CPUS];
 } __attribute__ ((packed));
 
-typedef void asmlinkage (*smm_handler_t)(void *arg, int cpu,
-                                         const struct smm_runtime *runtime);
+struct smm_module_params {
+	void *arg;
+	int cpu;
+	const struct smm_runtime *runtime;
+};
+
+/* smm_handler_t is called with arg of smm_module_params pointer. */
+typedef void asmlinkage (*smm_handler_t)(void *);
 
 #ifdef __SMM__
 /* SMM Runtime helpers. */
 
 /* Entry point for SMM modules. */
-void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime);
+void asmlinkage smm_handler_start(void *params);
 
 /* Retrieve SMM save state for a given CPU. WARNING: This does not take into
  * account CPUs which are configured to not save their state to RAM. */
diff --git a/src/include/rmodule-defs.h b/src/include/rmodule-defs.h
index ee2d3f7bdd..4139ef3d41 100644
--- a/src/include/rmodule-defs.h
+++ b/src/include/rmodule-defs.h
@@ -25,30 +25,6 @@
 #define RMODULE_MAGIC 0xf8fe
 #define RMODULE_VERSION_1 1
 
-#define FIELD_ENTRY(x_) ((uint32_t)&x_)
-#define RMODULE_HEADER(entry_, type_)					\
-{									\
-	.magic = RMODULE_MAGIC,						\
-	.version = RMODULE_VERSION_1,					\
-	.type = type_,							\
-	.payload_begin_offset = FIELD_ENTRY(_payload_begin_offset),	\
-	.payload_end_offset = FIELD_ENTRY(_payload_end_offset),		\
-	.relocations_begin_offset  =					\
-		FIELD_ENTRY(_relocations_begin_offset),			\
-	.relocations_end_offset =					\
-		FIELD_ENTRY(_relocations_end_offset),			\
-	.module_link_start_address =					\
-		FIELD_ENTRY(_module_link_start_addr),			\
-	.module_program_size = FIELD_ENTRY(_module_program_size),	\
-	.module_entry_point = FIELD_ENTRY(entry_),			\
-	.parameters_begin = FIELD_ENTRY(_module_params_begin),		\
-	.parameters_end = FIELD_ENTRY(_module_params_end),		\
-	.bss_begin = FIELD_ENTRY(_bss),					\
-	.bss_end = FIELD_ENTRY(_ebss),					\
-}
-
-/* Private data structures below should not be used directly. */
-
 /* All fields with '_offset' in the name are byte offsets into the flat blob.
  * The linker and the linker script takes are of assigning the values.  */
 struct rmodule_header {
diff --git a/src/include/rmodule.h b/src/include/rmodule.h
index 2147ab0919..d229cf816a 100644
--- a/src/include/rmodule.h
+++ b/src/include/rmodule.h
@@ -21,6 +21,7 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include <string.h>
 #include <rmodule-defs.h>
 
 enum {
@@ -50,11 +51,6 @@ int rmodule_load_alignment(const struct rmodule *m);
 int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
                         size_t *region_size, int *load_offset);
 
-#define DEFINE_RMODULE_HEADER(name_, entry_, type_) \
-	struct rmodule_header name_ \
-	__attribute__ ((section (".module_header"))) = \
-	RMODULE_HEADER(entry_, type_)
-
 /* Support for loading rmodule stages. This API is only available when
  * using dynamic cbmem because it uses the dynamic cbmem API to obtain
  * the backing store region for the stage. */
@@ -84,17 +80,12 @@ struct rmodule {
 	void *relocations;
 };
 
-/* These are the symbols assumed that every module contains. The linker script
- * provides these symbols. */
-extern char _relocations_begin_offset[];
-extern char _relocations_end_offset[];
-extern char _payload_end_offset[];
-extern char _payload_begin_offset[];
-extern char _bss[];
-extern char _ebss[];
-extern char _module_program_size[];
-extern char _module_link_start_addr[];
-extern char _module_params_begin[];
-extern char _module_params_end[];
+#if IS_ENABLED(CONFIG_RELOCATABLE_MODULES)
+/* Rmodules have an entry point of named __rmodule_entry. */
+#define RMODULE_ENTRY(entry_) \
+	void __rmodule_entry(void *) __attribute__((alias (STRINGIFY(entry_))))
+#else
+#define RMODULE_ENTRY(entry_)
+#endif
 
 #endif /* RMODULE_H */