ops.oobbuf = buf;
        ops.datbuf = NULL;
 
-       res = mtd->read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
+       res = mtd_read_oob(mtd, offs & ~(mtd->writesize - 1), &ops);
        *retlen = ops.oobretlen;
        return res;
 }
 
                        ops.oobbuf = NULL;
                        ops.len = len;
 
-                       ret = mtd->read_oob(mtd, *ppos, &ops);
+                       ret = mtd_read_oob(mtd, *ppos, &ops);
                        retlen = ops.retlen;
                        break;
                }
                return -ENOMEM;
 
        start &= ~((uint64_t)mtd->writesize - 1);
-       ret = mtd->read_oob(mtd, start, &ops);
+       ret = mtd_read_oob(mtd, start, &ops);
 
        if (put_user(ops.oobretlen, retp))
                ret = -EFAULT;
 
                if (from + devops.len > subdev->size)
                        devops.len = subdev->size - from;
 
-               err = subdev->read_oob(subdev, from, &devops);
+               err = mtd_read_oob(subdev, from, &devops);
                ops->retlen += devops.retlen;
                ops->oobretlen += devops.oobretlen;
 
 
                        return -EINVAL;
        }
 
-       res = part->master->read_oob(part->master, from + part->offset, ops);
+       res = mtd_read_oob(part->master, from + part->offset, ops);
        if (unlikely(res)) {
                if (mtd_is_bitflip(res))
                        mtd->ecc_stats.corrected++;
 
 static int mtdswap_read_oob(struct mtdswap_dev *d, loff_t from,
                        struct mtd_oob_ops *ops)
 {
-       int ret = d->mtd->read_oob(d->mtd, from, ops);
+       int ret = mtd_read_oob(d->mtd, from, ops);
 
        if (mtd_is_bitflip(ret))
                return ret;
 
                pos = base;
                for (i = 0; i < mtd_pages; i++) {
-                       ret = mtd->read_oob(mtd, pos, &ops);
+                       ret = mtd_read_oob(mtd, pos, &ops);
                        if (ret)
                                goto error;
 
 
                ops.len = min(len, (size_t)mtd->writesize);
                ops.oobbuf = buf + ops.len;
 
-               res = mtd->read_oob(mtd, offs, &ops);
+               res = mtd_read_oob(mtd, offs, &ops);
 
                if (res)
                        return res;
                 * Read the full oob until read_oob is fixed to handle single
                 * byte reads for 16 bit buswidth.
                 */
-               ret = mtd->read_oob(mtd, offs, &ops);
+               ret = mtd_read_oob(mtd, offs, &ops);
                /* Ignore ECC errors when checking for BBM */
                if (ret && !mtd_is_bitflip_or_eccerr(ret))
                        return ret;
                        /* Read oob data */
                        ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
                        ops.oobbuf = &buf[len];
-                       res = mtd->read_oob(mtd, to + mtd->writesize, &ops);
+                       res = mtd_read_oob(mtd, to + mtd->writesize, &ops);
                        if (res < 0 || ops.oobretlen != ops.ooblen)
                                goto outerr;
 
 
        ops.oobbuf = buf;
        ops.datbuf = NULL;
 
-       res = mtd->read_oob(mtd, offs & ~mask, &ops);
+       res = mtd_read_oob(mtd, offs & ~mask, &ops);
        *retlen = ops.oobretlen;
        return res;
 }
 
 
        /* Unfortunately, oob read will _always_ succeed,
                despite card removal..... */
-       ret = mtd->read_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops);
+       ret = mtd_read_oob(mtd, sm_mkoffset(ftl, zone, block, boffset), &ops);
 
        /* Test for unknown errors */
        if (ret != 0 && !mtd_is_bitflip_or_eccerr(ret)) {
 
        ops.oobbuf = buf;
        ops.datbuf = NULL;
 
-       ret = mtd->read_oob(mtd, offs, &ops);
+       ret = mtd_read_oob(mtd, offs, &ops);
        if (ret < 0 || ops.oobretlen != OOB_SIZE)
                return -1;
 
 
                ops.ooboffs   = use_offset;
                ops.datbuf    = NULL;
                ops.oobbuf    = readbuf;
-               err = mtd->read_oob(mtd, addr, &ops);
+               err = mtd_read_oob(mtd, addr, &ops);
                if (err || ops.oobretlen != use_len) {
                        printk(PRINT_PREF "error: readoob failed at %#llx\n",
                               (long long)addr);
                        ops.ooboffs   = 0;
                        ops.datbuf    = NULL;
                        ops.oobbuf    = readbuf;
-                       err = mtd->read_oob(mtd, addr, &ops);
+                       err = mtd_read_oob(mtd, addr, &ops);
                        if (err || ops.oobretlen != mtd->ecclayout->oobavail) {
                                printk(PRINT_PREF "error: readoob failed at "
                                       "%#llx\n", (long long)addr);
        ops.ooboffs   = 0;
        ops.datbuf    = NULL;
        ops.oobbuf    = readbuf;
-       err = mtd->read_oob(mtd, addr, &ops);
+       err = mtd_read_oob(mtd, addr, &ops);
        if (err || ops.oobretlen != len) {
                printk(PRINT_PREF "error: readoob failed at %#llx\n",
                       (long long)addr);
        ops.oobbuf    = readbuf;
        printk(PRINT_PREF "attempting to start read past end of OOB\n");
        printk(PRINT_PREF "an error is expected...\n");
-       err = mtd->read_oob(mtd, addr0, &ops);
+       err = mtd_read_oob(mtd, addr0, &ops);
        if (err) {
                printk(PRINT_PREF "error occurred as expected\n");
                err = 0;
                ops.oobbuf    = readbuf;
                printk(PRINT_PREF "attempting to read past end of device\n");
                printk(PRINT_PREF "an error is expected...\n");
-               err = mtd->read_oob(mtd, mtd->size - mtd->writesize, &ops);
+               err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops);
                if (err) {
                        printk(PRINT_PREF "error occurred as expected\n");
                        err = 0;
                ops.oobbuf    = readbuf;
                printk(PRINT_PREF "attempting to read past end of device\n");
                printk(PRINT_PREF "an error is expected...\n");
-               err = mtd->read_oob(mtd, mtd->size - mtd->writesize, &ops);
+               err = mtd_read_oob(mtd, mtd->size - mtd->writesize, &ops);
                if (err) {
                        printk(PRINT_PREF "error occurred as expected\n");
                        err = 0;
                ops.ooboffs   = 0;
                ops.datbuf    = NULL;
                ops.oobbuf    = readbuf;
-               err = mtd->read_oob(mtd, addr, &ops);
+               err = mtd_read_oob(mtd, addr, &ops);
                if (err)
                        goto out;
                if (memcmp(readbuf, writebuf, mtd->ecclayout->oobavail * 2)) {
 
                        ops.ooboffs   = 0;
                        ops.datbuf    = NULL;
                        ops.oobbuf    = oobbuf;
-                       ret = mtd->read_oob(mtd, addr, &ops);
+                       ret = mtd_read_oob(mtd, addr, &ops);
                        if ((ret && !mtd_is_bitflip(ret)) ||
                                        ops.oobretlen != mtd->oobsize) {
                                printk(PRINT_PREF "error: read oob failed at "
 
                ops.ooblen = BTSIG_BYTES;
                ops.ooboffs = 0;
 
-               ret = spectra_mtd->read_oob(spectra_mtd,
-                                           (Block * spectra_mtd->erasesize) + (Page * spectra_mtd->writesize),
-                                           &ops);
+               ret = mtd_read_oob(spectra_mtd,
+                                  (Block * spectra_mtd->erasesize) + (Page * spectra_mtd->writesize),
+                                  &ops);
                if (ret) {
                        printk(KERN_ERR "%s failed %d\n", __func__, ret);
                        return FAIL;
                ops.ooblen = BTSIG_BYTES;
                ops.ooboffs = 0;
 
-               ret = spectra_mtd->read_oob(spectra_mtd,
-                                           (Block * spectra_mtd->erasesize) + (Page * spectra_mtd->writesize),
-                                           &ops);
+               ret = mtd_read_oob(spectra_mtd,
+                                  (Block * spectra_mtd->erasesize) + (Page * spectra_mtd->writesize),
+                                  &ops);
                if (ret) {
                        printk(KERN_ERR "%s failed %d\n", __func__, ret);
                        return FAIL;
 
        ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
        ops.datbuf = NULL;
 
-       ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
+       ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
        if (ret || ops.oobretlen != ops.ooblen) {
                printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
                                " bytes, read %zd bytes, error %d\n",
        ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
        ops.datbuf = NULL;
 
-       ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
+       ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
        if (ret || ops.oobretlen != ops.ooblen) {
                printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
                                " bytes, read %zd bytes, error %d\n",
 
                      size_t *retlen, const u_char *buf);
        int (*panic_write) (struct mtd_info *mtd, loff_t to, size_t len,
                            size_t *retlen, const u_char *buf);
+       int (*read_oob) (struct mtd_info *mtd, loff_t from,
+                        struct mtd_oob_ops *ops);
 
        /* Backing device capabilities for this device
         * - provides mmap capabilities
        struct backing_dev_info *backing_dev_info;
 
 
-       int (*read_oob) (struct mtd_info *mtd, loff_t from,
-                        struct mtd_oob_ops *ops);
        int (*write_oob) (struct mtd_info *mtd, loff_t to,
                         struct mtd_oob_ops *ops);
 
        return mtd->panic_write(mtd, to, len, retlen, buf);
 }
 
+static inline int mtd_read_oob(struct mtd_info *mtd, loff_t from,
+                              struct mtd_oob_ops *ops)
+{
+       return mtd->read_oob(mtd, from, ops);
+}
+
 static inline struct mtd_info *dev_to_mtd(struct device *dev)
 {
        return dev ? dev_get_drvdata(dev) : NULL;