Merge master.kernel.org:/pub/scm/linux/kernel/git/tglx/mtd-2.6

5 files changed, 151 insertions, 199 deletions

diff --git a/drivers/mtd/devices/block2mtd.c b/drivers/mtd/devices/block2mtd.c
index cfe6ccf07972..4a7a805e7564 100644
--- a/drivers/mtd/devices/block2mtd.c
+++ b/drivers/mtd/devices/block2mtd.c
@@ -1,10 +1,9 @@
 /*
- * $Id: block2mtd.c,v 1.23 2005/01/05 17:05:46 dwmw2 Exp $
+ * $Id: block2mtd.c,v 1.28 2005/03/19 22:40:44 gleixner Exp $
  *
  * block2mtd.c - create an mtd from a block device
  *
  * Copyright (C) 2001,2002      Simon Evans <spse@secret.org.uk>
- * Copyright (C) 2004           Gareth Bult <Gareth@Encryptec.net>
  * Copyright (C) 2004,2005      Jörn Engel <joern@wh.fh-wedel.de>
  *
  * Licence: GPL
@@ -20,7 +19,7 @@
 #include <linux/mtd/mtd.h>
 #include <linux/buffer_head.h>
 
-#define VERSION "$Revision: 1.23 $"
+#define VERSION "$Revision: 1.28 $"
 
 
 #define ERROR(fmt, args...) printk(KERN_ERR "block2mtd: " fmt "\n" , ## args)
@@ -89,7 +88,6 @@ void cache_readahead(struct address_space *mapping, int index)
 static struct page* page_readahead(struct address_space *mapping, int index)
 {
         filler_t *filler = (filler_t*)mapping->a_ops->readpage;
-        //do_page_cache_readahead(mapping, index, XXX, 64);
         cache_readahead(mapping, index);
         return read_cache_page(mapping, index, filler, NULL);
 }
@@ -157,7 +155,7 @@ static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
         struct block2mtd_dev *dev = mtd->priv;
         struct page *page;
         int index = from >> PAGE_SHIFT;
-        int offset = from & (PAGE_SHIFT-1);
+        int offset = from & (PAGE_SIZE-1);
         int cpylen;
 
         if (from > mtd->size)
@@ -370,16 +368,16 @@ static int ustrtoul(const char *cp, char **endp, unsigned int base)
 }
 
 
-static int parse_num32(u32 *num32, const char *token)
+static int parse_num(size_t *num, const char *token)
 {
         char *endp;
-        unsigned long n;
+        size_t n;
 
-        n = ustrtoul(token, &endp, 0);
+        n = (size_t) ustrtoul(token, &endp, 0);
         if (*endp)
                 return -EINVAL;
 
-        *num32 = n;
+        *num = n;
         return 0;
 }
 
@@ -422,7 +420,7 @@ static int block2mtd_setup(const char *val, struct kernel_param *kp)
         char buf[80+12], *str=buf; /* 80 for device, 12 for erase size */
         char *token[2];
         char *name;
-        u32 erase_size = PAGE_SIZE;
+        size_t erase_size = PAGE_SIZE;
         int i, ret;
 
         if (strnlen(val, sizeof(buf)) >= sizeof(buf))
@@ -449,7 +447,7 @@ static int block2mtd_setup(const char *val, struct kernel_param *kp)
                 return 0;
 
         if (token[1]) {
-                ret = parse_num32(&erase_size, token[1]);
+                ret = parse_num(&erase_size, token[1]);
                 if (ret)
                         parse_err("illegal erase size");
         }
diff --git a/drivers/mtd/devices/ms02-nv.c b/drivers/mtd/devices/ms02-nv.c
index 380ff08d29e4..f5026cee087f 100644
--- a/drivers/mtd/devices/ms02-nv.c
+++ b/drivers/mtd/devices/ms02-nv.c
@@ -6,7 +6,7 @@
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  *
- *      $Id: ms02-nv.c,v 1.8 2005/01/05 18:05:12 dwmw2 Exp $
+ *      $Id: ms02-nv.c,v 1.10 2005/06/20 12:24:41 macro Exp $
  */
 
 #include <linux/init.h>
@@ -99,8 +99,8 @@ static inline uint ms02nv_probe_one(ulong addr)
          * The firmware writes MS02NV_ID at MS02NV_MAGIC and also
          * a diagnostic status at MS02NV_DIAG.
          */
-        ms02nv_diagp = (ms02nv_uint *)(KSEG1ADDR(addr + MS02NV_DIAG));
-        ms02nv_magicp = (ms02nv_uint *)(KSEG1ADDR(addr + MS02NV_MAGIC));
+        ms02nv_diagp = (ms02nv_uint *)(CKSEG1ADDR(addr + MS02NV_DIAG));
+        ms02nv_magicp = (ms02nv_uint *)(CKSEG1ADDR(addr + MS02NV_MAGIC));
         err = get_dbe(ms02nv_magic, ms02nv_magicp);
         if (err)
                 return 0;
@@ -233,7 +233,7 @@ static int __init ms02nv_init_one(ulong addr)
                 goto err_out_csr_res;
         }
 
-        printk(KERN_INFO "mtd%d: %s at 0x%08lx, size %uMiB.\n",
+        printk(KERN_INFO "mtd%d: %s at 0x%08lx, size %zuMiB.\n",
                 mtd->index, ms02nv_name, addr, size >> 20);
 
         mp->next = root_ms02nv_mtd;
diff --git a/drivers/mtd/devices/mtdram.c b/drivers/mtd/devices/mtdram.c
index edac4156d69c..bb713fed2f37 100644
--- a/drivers/mtd/devices/mtdram.c
+++ b/drivers/mtd/devices/mtdram.c
@@ -1,9 +1,10 @@
 /*
  * mtdram - a test mtd device
- * $Id: mtdram.c,v 1.35 2005/01/05 18:05:12 dwmw2 Exp $
+ * $Id: mtdram.c,v 1.37 2005/04/21 03:42:11 joern Exp $
  * Author: Alexander Larsson <alex@cendio.se>
  *
  * Copyright (c) 1999 Alexander Larsson <alex@cendio.se>
+ * Copyright (c) 2005 Joern Engel <joern@wh.fh-wedel.de>
  *
  * This code is GPL
  *
@@ -18,213 +19,140 @@
 #include <linux/mtd/compatmac.h>
 #include <linux/mtd/mtd.h>
 
-#ifndef CONFIG_MTDRAM_ABS_POS
-  #define CONFIG_MTDRAM_ABS_POS 0
-#endif
-
-#if CONFIG_MTDRAM_ABS_POS > 0
-  #include <asm/io.h>
-#endif
-
-#ifdef MODULE
 static unsigned long total_size = CONFIG_MTDRAM_TOTAL_SIZE;
 static unsigned long erase_size = CONFIG_MTDRAM_ERASE_SIZE;
-module_param(total_size,ulong,0);
-MODULE_PARM_DESC(total_size, "Total device size in KiB");
-module_param(erase_size,ulong,0);
-MODULE_PARM_DESC(erase_size, "Device erase block size in KiB");
 #define MTDRAM_TOTAL_SIZE (total_size * 1024)
 #define MTDRAM_ERASE_SIZE (erase_size * 1024)
-#else
-#define MTDRAM_TOTAL_SIZE (CONFIG_MTDRAM_TOTAL_SIZE * 1024)
-#define MTDRAM_ERASE_SIZE (CONFIG_MTDRAM_ERASE_SIZE * 1024)
-#endif
 
+#ifdef MODULE
+module_param(total_size, ulong, 0);
+MODULE_PARM_DESC(total_size, "Total device size in KiB");
+module_param(erase_size, ulong, 0);
+MODULE_PARM_DESC(erase_size, "Device erase block size in KiB");
+#endif
 
 // We could store these in the mtd structure, but we only support 1 device..
 static struct mtd_info *mtd_info;
 
-
-static int
-ram_erase(struct mtd_info *mtd, struct erase_info *instr)
+static int ram_erase(struct mtd_info *mtd, struct erase_info *instr)
 {
-  DEBUG(MTD_DEBUG_LEVEL2, "ram_erase(pos:%ld, len:%ld)\n", (long)instr->addr, (long)instr->len);
-  if (instr->addr + instr->len > mtd->size) {
-    DEBUG(MTD_DEBUG_LEVEL1, "ram_erase() out of bounds (%ld > %ld)\n", (long)(instr->addr + instr->len), (long)mtd->size);
-    return -EINVAL;
-  }
-        
-  memset((char *)mtd->priv + instr->addr, 0xff, instr->len);
-        
-  instr->state = MTD_ERASE_DONE;
-  mtd_erase_callback(instr);
-
-  return 0;
+        if (instr->addr + instr->len > mtd->size)
+                return -EINVAL;
+
+        memset((char *)mtd->priv + instr->addr, 0xff, instr->len);
+
+        instr->state = MTD_ERASE_DONE;
+        mtd_erase_callback(instr);
+
+        return 0;
 }
 
-static int ram_point (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf)
+static int ram_point(struct mtd_info *mtd, loff_t from, size_t len,
+                size_t *retlen, u_char **mtdbuf)
 {
-  if (from + len > mtd->size)
-    return -EINVAL;
-        
-  *mtdbuf = mtd->priv + from;
-  *retlen = len;
-  return 0;
+        if (from + len > mtd->size)
+                return -EINVAL;
+
+        *mtdbuf = mtd->priv + from;
+        *retlen = len;
+        return 0;
 }
 
-static void ram_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from,
-                         size_t len)
+static void ram_unpoint(struct mtd_info *mtd, u_char * addr, loff_t from,
+                size_t len)
 {
-  DEBUG(MTD_DEBUG_LEVEL2, "ram_unpoint\n");
 }
 
 static int ram_read(struct mtd_info *mtd, loff_t from, size_t len,
-             size_t *retlen, u_char *buf)
+                size_t *retlen, u_char *buf)
 {
-  DEBUG(MTD_DEBUG_LEVEL2, "ram_read(pos:%ld, len:%ld)\n", (long)from, (long)len);
-  if (from + len > mtd->size) {
-    DEBUG(MTD_DEBUG_LEVEL1, "ram_read() out of bounds (%ld > %ld)\n", (long)(from + len), (long)mtd->size);
-    return -EINVAL;
-  }
+        if (from + len > mtd->size)
+                return -EINVAL;
 
-  memcpy(buf, mtd->priv + from, len);
+        memcpy(buf, mtd->priv + from, len);
 
-  *retlen=len;
-  return 0;
+        *retlen = len;
+        return 0;
 }
 
 static int ram_write(struct mtd_info *mtd, loff_t to, size_t len,
-              size_t *retlen, const u_char *buf)
+                size_t *retlen, const u_char *buf)
 {
-  DEBUG(MTD_DEBUG_LEVEL2, "ram_write(pos:%ld, len:%ld)\n", (long)to, (long)len);
-  if (to + len > mtd->size) {
-    DEBUG(MTD_DEBUG_LEVEL1, "ram_write() out of bounds (%ld > %ld)\n", (long)(to + len), (long)mtd->size);
-    return -EINVAL;
-  }
+        if (to + len > mtd->size)
+                return -EINVAL;
 
-  memcpy ((char *)mtd->priv + to, buf, len);
+        memcpy((char *)mtd->priv + to, buf, len);
 
-  *retlen=len;
-  return 0;
+        *retlen = len;
+        return 0;
 }
 
 static void __exit cleanup_mtdram(void)
 {
-  if (mtd_info) {
-    del_mtd_device(mtd_info);
-#if CONFIG_MTDRAM_TOTAL_SIZE > 0
-    if (mtd_info->priv)
-#if CONFIG_MTDRAM_ABS_POS > 0
-      iounmap(mtd_info->priv);
-#else
-      vfree(mtd_info->priv);
-#endif  
-#endif
-    kfree(mtd_info);
-  }
-}
-
-int mtdram_init_device(struct mtd_info *mtd, void *mapped_address, 
-                       unsigned long size, char *name)
-{
-   memset(mtd, 0, sizeof(*mtd));
-
-   /* Setup the MTD structure */
-   mtd->name = name;
-   mtd->type = MTD_RAM;
-   mtd->flags = MTD_CAP_RAM;
-   mtd->size = size;
-   mtd->erasesize = MTDRAM_ERASE_SIZE;
-   mtd->priv = mapped_address;
-
-   mtd->owner = THIS_MODULE;
-   mtd->erase = ram_erase;
-   mtd->point = ram_point;
-   mtd->unpoint = ram_unpoint;
-   mtd->read = ram_read;
-   mtd->write = ram_write;
-
-   if (add_mtd_device(mtd)) {
-     return -EIO;
-   }
-   
-   return 0;
-}
-
-#if CONFIG_MTDRAM_TOTAL_SIZE > 0
-#if CONFIG_MTDRAM_ABS_POS > 0
-static int __init init_mtdram(void)
-{
-  void *addr;
-  int err;
-  /* Allocate some memory */
-   mtd_info = kmalloc(sizeof(struct mtd_info), GFP_KERNEL);
-   if (!mtd_info)
-     return -ENOMEM;
-   
-  addr = ioremap(CONFIG_MTDRAM_ABS_POS, MTDRAM_TOTAL_SIZE);
-  if (!addr) {
-    DEBUG(MTD_DEBUG_LEVEL1, 
-          "Failed to ioremap) memory region of size %ld at ABS_POS:%ld\n", 
-          (long)MTDRAM_TOTAL_SIZE, (long)CONFIG_MTDRAM_ABS_POS);
-    kfree(mtd_info);
-    mtd_info = NULL;
-    return -ENOMEM;
-  }
-  err = mtdram_init_device(mtd_info, addr, 
-                           MTDRAM_TOTAL_SIZE, "mtdram test device");
-  if (err) 
-  {
-    iounmap(addr);
-    kfree(mtd_info);
-    mtd_info = NULL;
-    return err;
-  }
-  memset(mtd_info->priv, 0xff, MTDRAM_TOTAL_SIZE);
-  return err;
+        if (mtd_info) {
+                del_mtd_device(mtd_info);
+                if (mtd_info->priv)
+                        vfree(mtd_info->priv);
+                kfree(mtd_info);
+        }
 }
 
-#else /* CONFIG_MTDRAM_ABS_POS > 0 */
-
-static int __init init_mtdram(void)
+int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
+                unsigned long size, char *name)
 {
-  void *addr;
-  int err;
-  /* Allocate some memory */
-   mtd_info = kmalloc(sizeof(struct mtd_info), GFP_KERNEL);
-   if (!mtd_info)
-     return -ENOMEM;
-
-  addr = vmalloc(MTDRAM_TOTAL_SIZE);
-  if (!addr) {
-    DEBUG(MTD_DEBUG_LEVEL1, 
-          "Failed to vmalloc memory region of size %ld\n", 
-          (long)MTDRAM_TOTAL_SIZE);
-    kfree(mtd_info);
-    mtd_info = NULL;
-    return -ENOMEM;
-  }
-  err = mtdram_init_device(mtd_info, addr, 
-                           MTDRAM_TOTAL_SIZE, "mtdram test device");
-  if (err) 
-  {
-    vfree(addr);
-    kfree(mtd_info);
-    mtd_info = NULL;
-    return err;
-  }
-  memset(mtd_info->priv, 0xff, MTDRAM_TOTAL_SIZE);
-  return err;
+        memset(mtd, 0, sizeof(*mtd));
+
+        /* Setup the MTD structure */
+        mtd->name = name;
+        mtd->type = MTD_RAM;
+        mtd->flags = MTD_CAP_RAM;
+        mtd->size = size;
+        mtd->erasesize = MTDRAM_ERASE_SIZE;
+        mtd->priv = mapped_address;
+
+        mtd->owner = THIS_MODULE;
+        mtd->erase = ram_erase;
+        mtd->point = ram_point;
+        mtd->unpoint = ram_unpoint;
+        mtd->read = ram_read;
+        mtd->write = ram_write;
+
+        if (add_mtd_device(mtd)) {
+                return -EIO;
+        }
+
+        return 0;
 }
-#endif /* !(CONFIG_MTDRAM_ABS_POS > 0) */
-
-#else /* CONFIG_MTDRAM_TOTAL_SIZE > 0 */
 
 static int __init init_mtdram(void)
 {
-  return 0;
+        void *addr;
+        int err;
+
+        if (!total_size)
+                return -EINVAL;
+
+        /* Allocate some memory */
+        mtd_info = kmalloc(sizeof(struct mtd_info), GFP_KERNEL);
+        if (!mtd_info)
+                return -ENOMEM;
+
+        addr = vmalloc(MTDRAM_TOTAL_SIZE);
+        if (!addr) {
+                kfree(mtd_info);
+                mtd_info = NULL;
+                return -ENOMEM;
+        }
+        err = mtdram_init_device(mtd_info, addr, MTDRAM_TOTAL_SIZE, "mtdram test device");
+        if (err) {
+                vfree(addr);
+                kfree(mtd_info);
+                mtd_info = NULL;
+                return err;
+        }
+        memset(mtd_info->priv, 0xff, MTDRAM_TOTAL_SIZE);
+        return err;
 }
-#endif /* !(CONFIG_MTDRAM_TOTAL_SIZE > 0) */
 
 module_init(init_mtdram);
 module_exit(cleanup_mtdram);
@@ -232,4 +160,3 @@ module_exit(cleanup_mtdram);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Alexander Larsson <alexl@redhat.com>");
 MODULE_DESCRIPTION("Simulated MTD driver for testing");
-
diff --git a/drivers/mtd/devices/phram.c b/drivers/mtd/devices/phram.c
index 5f8e164ddb71..a423a382095a 100644
--- a/drivers/mtd/devices/phram.c
+++ b/drivers/mtd/devices/phram.c
@@ -1,5 +1,5 @@
 /**
- * $Id: phram.c,v 1.11 2005/01/05 18:05:13 dwmw2 Exp $
+ * $Id: phram.c,v 1.14 2005/03/07 21:43:38 joern Exp $
  *
  * Copyright (c) ????           Jochen Schäuble <psionic@psionic.de>
  * Copyright (c) 2003-2004      Jörn Engel <joern@wh.fh-wedel.de>
@@ -15,9 +15,7 @@
  *
  * Example:
  *      phram=swap,64Mi,128Mi phram=test,900Mi,1Mi
- *
  */
-
 #include <asm/io.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
@@ -36,7 +34,6 @@ struct phram_mtd_list {
 static LIST_HEAD(phram_list);
 
 
-
 static int phram_erase(struct mtd_info *mtd, struct erase_info *instr)
 {
         u_char *start = mtd->priv;
@@ -71,7 +68,8 @@ static int phram_point(struct mtd_info *mtd, loff_t from, size_t len,
         return 0;
 }
 
-static void phram_unpoint(struct mtd_info *mtd, u_char *addr, loff_t from, size_t len)
+static void phram_unpoint(struct mtd_info *mtd, u_char *addr, loff_t from,
+                size_t len)
 {
 }
 
@@ -80,8 +78,11 @@ static int phram_read(struct mtd_info *mtd, loff_t from, size_t len,
 {
         u_char *start = mtd->priv;
 
-        if (from + len > mtd->size)
+        if (from >= mtd->size)
                 return -EINVAL;
+
+        if (len > mtd->size - from)
+                len = mtd->size - from;
         
         memcpy(buf, start + from, len);
 
@@ -94,8 +95,11 @@ static int phram_write(struct mtd_info *mtd, loff_t to, size_t len,
 {
         u_char *start = mtd->priv;
 
-        if (to + len > mtd->size)
+        if (to >= mtd->size)
                 return -EINVAL;
+
+        if (len > mtd->size - to)
+                len = mtd->size - to;
         
         memcpy(start + to, buf, len);
 
@@ -107,9 +111,9 @@ static int phram_write(struct mtd_info *mtd, loff_t to, size_t len,
 
 static void unregister_devices(void)
 {
-        struct phram_mtd_list *this;
+        struct phram_mtd_list *this, *safe;
 
-        list_for_each_entry(this, &phram_list, list) {
+        list_for_each_entry_safe(this, safe, &phram_list, list) {
                 del_mtd_device(&this->mtd);
                 iounmap(this->mtd.priv);
                 kfree(this);
@@ -145,7 +149,7 @@ static int register_device(char *name, unsigned long start, unsigned long len)
         new->mtd.write = phram_write;
         new->mtd.owner = THIS_MODULE;
         new->mtd.type = MTD_RAM;
-        new->mtd.erasesize = 0;
+        new->mtd.erasesize = PAGE_SIZE;
 
         ret = -EAGAIN;
         if (add_mtd_device(&new->mtd)) {
@@ -214,6 +218,15 @@ static int parse_name(char **pname, const char *token)
         return 0;
 }
 
+
+static inline void kill_final_newline(char *str)
+{
+        char *newline = strrchr(str, '\n');
+        if (newline && !newline[1])
+                *newline = 0;
+}
+
+
 #define parse_err(fmt, args...) do {    \
         ERROR(fmt , ## args);   \
         return 0;               \
@@ -232,6 +245,7 @@ static int phram_setup(const char *val, struct kernel_param *kp)
                 parse_err("parameter too long\n");
 
         strcpy(str, val);
+        kill_final_newline(str);
 
         for (i=0; i<3; i++)
                 token[i] = strsep(&str, ",");
diff --git a/drivers/mtd/devices/slram.c b/drivers/mtd/devices/slram.c
index 5ab15e643be7..84fa91392a8c 100644
--- a/drivers/mtd/devices/slram.c
+++ b/drivers/mtd/devices/slram.c
@@ -1,6 +1,6 @@
 /*======================================================================
 
-  $Id: slram.c,v 1.33 2005/01/05 18:05:13 dwmw2 Exp $
+  $Id: slram.c,v 1.34 2005/01/06 21:16:42 jwboyer Exp $
 
   This driver provides a method to access memory not used by the kernel
   itself (i.e. if the kernel commandline mem=xxx is used). To actually
@@ -50,6 +50,7 @@
 #include <linux/mtd/mtd.h>
 
 #define SLRAM_MAX_DEVICES_PARAMS 6              /* 3 parameters / device */
+#define SLRAM_BLK_SZ 0x4000
 
 #define T(fmt, args...) printk(KERN_DEBUG fmt, ## args)
 #define E(fmt, args...) printk(KERN_NOTICE fmt, ## args)
@@ -108,6 +109,9 @@ static int slram_point(struct mtd_info *mtd, loff_t from, size_t len,
 {
         slram_priv_t *priv = mtd->priv;
 
+        if (from + len > mtd->size)
+                return -EINVAL;
+
         *mtdbuf = priv->start + from;
         *retlen = len;
         return(0);
@@ -121,7 +125,13 @@ static int slram_read(struct mtd_info *mtd, loff_t from, size_t len,
                 size_t *retlen, u_char *buf)
 {
         slram_priv_t *priv = mtd->priv;
-        
+
+        if (from > mtd->size)
+                return -EINVAL;
+
+        if (from + len > mtd->size)
+                len = mtd->size - from;
+
         memcpy(buf, priv->start + from, len);
 
         *retlen = len;
@@ -133,6 +143,9 @@ static int slram_write(struct mtd_info *mtd, loff_t to, size_t len,
 {
         slram_priv_t *priv = mtd->priv;
 
+        if (to + len > mtd->size)
+                return -EINVAL;
+
         memcpy(priv->start + to, buf, len);
 
         *retlen = len;
@@ -188,7 +201,7 @@ static int register_device(char *name, unsigned long start, unsigned long length
         (*curmtd)->mtdinfo->name = name;
         (*curmtd)->mtdinfo->size = length;
         (*curmtd)->mtdinfo->flags = MTD_CLEAR_BITS | MTD_SET_BITS |
-                                        MTD_WRITEB_WRITEABLE | MTD_VOLATILE;
+                                        MTD_WRITEB_WRITEABLE | MTD_VOLATILE | MTD_CAP_RAM;
         (*curmtd)->mtdinfo->erase = slram_erase;
         (*curmtd)->mtdinfo->point = slram_point;
         (*curmtd)->mtdinfo->unpoint = slram_unpoint;
@@ -196,7 +209,7 @@ static int register_device(char *name, unsigned long start, unsigned long length
         (*curmtd)->mtdinfo->write = slram_write;
         (*curmtd)->mtdinfo->owner = THIS_MODULE;
         (*curmtd)->mtdinfo->type = MTD_RAM;
-        (*curmtd)->mtdinfo->erasesize = 0x0;
+        (*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ;
 
         if (add_mtd_device((*curmtd)->mtdinfo)) {
                 E("slram: Failed to register new device\n");
@@ -261,7 +274,7 @@ static int parse_cmdline(char *devname, char *szstart, char *szlength)
         }
         T("slram: devname=%s, devstart=0x%lx, devlength=0x%lx\n",
                         devname, devstart, devlength);
-        if ((devstart < 0) || (devlength < 0)) {
+        if ((devstart < 0) || (devlength < 0) || (devlength % SLRAM_BLK_SZ != 0)) {
                 E("slram: Illegal start / length parameter.\n");
                 return(-EINVAL);
         }