ramoops: use module parameters instead of platform data if not available

Use generic module parameters instead of platform data, if platform data
are not available.  This limitation has been introduced with commit
c3b92ce9e75 ("ramoops: use the platform data structure instead of module
params").

[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Marco Stornelli <marco.stornelli@gmail.com>
Cc: Kyungmin Park <kyungmin.park@samsung.com>
Cc: Américo Wang <xiyou.wangcong@gmail.com>
Reported-by: Stevie Trujillo <stevie.trujillo@gmail.com>
Cc: Joe Perches <joe@perches.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 35 insertions, 12 deletions

diff --git a/drivers/char/ramoops.c b/drivers/char/ramoops.c
index 1a9f5f6d6ac5..32aa233df300 100644
--- a/drivers/char/ramoops.c
+++ b/drivers/char/ramoops.c
@@ -26,6 +26,7 @@
 #include <linux/io.h>
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <linux/ramoops.h>
 
 #define RAMOOPS_KERNMSG_HDR "===="
@@ -56,6 +57,9 @@ static struct ramoops_context {
         int max_count;
 } oops_cxt;
 
+static struct platform_device *dummy;
+static struct ramoops_platform_data *dummy_data;
+
 static void ramoops_do_dump(struct kmsg_dumper *dumper,
                 enum kmsg_dump_reason reason, const char *s1, unsigned long l1,
                 const char *s2, unsigned long l2)
@@ -106,27 +110,22 @@ static int __init ramoops_probe(struct platform_device *pdev)
         struct ramoops_context *cxt = &oops_cxt;
         int err = -EINVAL;
 
-        if (pdata) {
-                mem_size = pdata->mem_size;
-                mem_address = pdata->mem_address;
-        }
-
-        if (!mem_size) {
+        if (!pdata->mem_size) {
                 printk(KERN_ERR "ramoops: invalid size specification");
                 goto fail3;
         }
 
-        rounddown_pow_of_two(mem_size);
+        rounddown_pow_of_two(pdata->mem_size);
 
-        if (mem_size < RECORD_SIZE) {
+        if (pdata->mem_size < RECORD_SIZE) {
                 printk(KERN_ERR "ramoops: size too small");
                 goto fail3;
         }
 
-        cxt->max_count = mem_size / RECORD_SIZE;
+        cxt->max_count = pdata->mem_size / RECORD_SIZE;
         cxt->count = 0;
-        cxt->size = mem_size;
-        cxt->phys_addr = mem_address;
+        cxt->size = pdata->mem_size;
+        cxt->phys_addr = pdata->mem_address;
 
         if (!request_mem_region(cxt->phys_addr, cxt->size, "ramoops")) {
                 printk(KERN_ERR "ramoops: request mem region failed");
@@ -179,12 +178,36 @@ static struct platform_driver ramoops_driver = {
 
 static int __init ramoops_init(void)
 {
-        return platform_driver_probe(&ramoops_driver, ramoops_probe);
+        int ret;
+        ret = platform_driver_probe(&ramoops_driver, ramoops_probe);
+        if (ret == -ENODEV) {
+                /*
+                 * If we didn't find a platform device, we use module parameters
+                 * building platform data on the fly.
+                 */
+                dummy_data = kzalloc(sizeof(struct ramoops_platform_data),
+                                     GFP_KERNEL);
+                if (!dummy_data)
+                        return -ENOMEM;
+                dummy_data->mem_size = mem_size;
+                dummy_data->mem_address = mem_address;
+                dummy = platform_create_bundle(&ramoops_driver, ramoops_probe,
+                        NULL, 0, dummy_data,
+                        sizeof(struct ramoops_platform_data));
+
+                if (IS_ERR(dummy))
+                        ret = PTR_ERR(dummy);
+                else
+                        ret = 0;
+        }
+
+        return ret;
 }
 
 static void __exit ramoops_exit(void)
 {
         platform_driver_unregister(&ramoops_driver);
+        kfree(dummy_data);
 }
 
 module_init(ramoops_init);