#include <linux/mtd/partitions.h>
 #include <linux/mtd/cfi.h>
 #include <linux/reboot.h>
+#include <linux/err.h>
 #include <linux/kdev_t.h>
 #include <linux/root_dev.h>
 #include <asm/io.h>
 
        init_waitqueue_head(&wait_q);
        mtd = get_mtd_device(NULL, 2);
-       if (mtd) {
+       if (!IS_ERR(mtd)) {
                nettel_erase.mtd = mtd;
                nettel_erase.callback = nettel_erasecallback;
                nettel_erase.callback = NULL;
 
 
 #include <linux/device.h>
 #include <linux/fs.h>
+#include <linux/err.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 
        mtd = get_mtd_device(NULL, devnum);
 
-       if (!mtd)
-               return -ENODEV;
+       if (IS_ERR(mtd))
+               return PTR_ERR(mtd);
 
        if (MTD_ABSENT == mtd->type) {
                put_mtd_device(mtd);
 
  *     Given a number and NULL address, return the num'th entry in the device
  *     table, if any.  Given an address and num == -1, search the device table
  *     for a device with that address and return if it's still present. Given
- *     both, return the num'th driver only if its address matches. Return NULL
- *     if not.
+ *     both, return the num'th driver only if its address matches. Return
+ *     error code if not.
  */
 
 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
 {
        struct mtd_info *ret = NULL;
-       int i;
+       int i, err = -ENODEV;
 
        mutex_lock(&mtd_table_mutex);
 
        if (!ret)
                goto out_unlock;
 
-       if (!try_module_get(ret->owner)) {
-               ret = NULL;
+       if (!try_module_get(ret->owner))
                goto out_unlock;
-       }
 
-       if (ret->get_device && ret->get_device(ret)) {
-               module_put(ret->owner);
-               ret = NULL;
-               goto out_unlock;
+       if (ret->get_device) {
+               err = ret->get_device(ret);
+               if (err)
+                       goto out_put;
        }
 
        ret->usecount++;
+       mutex_unlock(&mtd_table_mutex);
+       return ret;
 
+out_put:
+       module_put(ret->owner);
 out_unlock:
        mutex_unlock(&mtd_table_mutex);
-       return ret;
+       return ERR_PTR(err);
 }
 
 /**
 
  *
  */
 #include <linux/slab.h>
+#include <linux/err.h>
 #include <linux/blkdev.h>
 #include <linux/jffs.h>
 #include "jffs_fm.h"
 
        mtd = get_mtd_device(NULL, unit);
 
-       if (!mtd) {
+       if (IS_ERR(mtd)) {
                kfree(fmc);
                DJM(no_jffs_fmcontrol--);
                return NULL;
 
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/fs.h>
+#include <linux/err.h>
 #include <linux/mount.h>
 #include <linux/jffs2.h>
 #include <linux/pagemap.h>
        struct mtd_info *mtd;
 
        mtd = get_mtd_device(NULL, mtdnr);
-       if (!mtd) {
+       if (IS_ERR(mtd)) {
                D1(printk(KERN_DEBUG "jffs2: MTD device #%u doesn't appear to exist\n", mtdnr));
-               return -EINVAL;
+               return PTR_ERR(mtd);
        }
 
        return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt);
                        D1(printk(KERN_DEBUG "jffs2_get_sb(): mtd:%%s, name \"%s\"\n", dev_name+4));
                        for (mtdnr = 0; mtdnr < MAX_MTD_DEVICES; mtdnr++) {
                                mtd = get_mtd_device(NULL, mtdnr);
-                               if (mtd) {
+                               if (!IS_ERR(mtd)) {
                                        if (!strcmp(mtd->name, dev_name+4))
                                                return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt);
                                        put_mtd_device(mtd);