mtd: add leading underscore to all mtd functions
authorArtem Bityutskiy <artem.bityutskiy@linux.intel.com>
Mon, 30 Jan 2012 12:58:32 +0000 (14:58 +0200)
committerDavid Woodhouse <David.Woodhouse@intel.com>
Mon, 26 Mar 2012 23:20:01 +0000 (00:20 +0100)
This patch renames all MTD functions by adding a "_" prefix:

mtd->erase -> mtd->_erase
mtd->read_oob -> mtd->_read_oob
...

The reason is that we are re-working the MTD API and from now on it is
an error to use MTD function pointers directly - we have a corresponding
API call for every pointer. By adding a leading "_" we achieve the following:

1. Make sure we convert every direct pointer users
2. A leading "_" suggests that this interface is internal and it becomes
   less likely that people will use them directly
3. Make sure all the out-of-tree modules stop compiling and the owners
   spot the big API change and amend them.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
36 files changed:
drivers/mtd/chips/cfi_cmdset_0001.c
drivers/mtd/chips/cfi_cmdset_0002.c
drivers/mtd/chips/cfi_cmdset_0020.c
drivers/mtd/chips/fwh_lock.h
drivers/mtd/chips/map_absent.c
drivers/mtd/chips/map_ram.c
drivers/mtd/chips/map_rom.c
drivers/mtd/devices/block2mtd.c
drivers/mtd/devices/doc2000.c
drivers/mtd/devices/doc2001.c
drivers/mtd/devices/doc2001plus.c
drivers/mtd/devices/docg3.c
drivers/mtd/devices/lart.c
drivers/mtd/devices/m25p80.c
drivers/mtd/devices/ms02-nv.c
drivers/mtd/devices/mtd_dataflash.c
drivers/mtd/devices/mtdram.c
drivers/mtd/devices/phram.c
drivers/mtd/devices/pmc551.c
drivers/mtd/devices/slram.c
drivers/mtd/devices/spear_smi.c
drivers/mtd/devices/sst25l.c
drivers/mtd/inftlcore.c
drivers/mtd/lpddr/lpddr_cmds.c
drivers/mtd/maps/uclinux.c
drivers/mtd/maps/vmu-flash.c
drivers/mtd/mtdchar.c
drivers/mtd/mtdconcat.c
drivers/mtd/mtdcore.c
drivers/mtd/mtdpart.c
drivers/mtd/nand/alauda.c
drivers/mtd/nand/nand_base.c
drivers/mtd/onenand/onenand_base.c
drivers/mtd/ubi/gluebi.c
drivers/net/ethernet/sfc/mtd.c
include/linux/mtd/mtd.h

index e1e122f2f92912bcc71d2418ffea1f3e77aeb3fa..152accf4bf858aae662c6ed5ba538593ee869b13 100644 (file)
@@ -262,9 +262,9 @@ static void fixup_st_m28w320cb(struct mtd_info *mtd)
 static void fixup_use_point(struct mtd_info *mtd)
 {
        struct map_info *map = mtd->priv;
-       if (!mtd->point && map_is_linear(map)) {
-               mtd->point   = cfi_intelext_point;
-               mtd->unpoint = cfi_intelext_unpoint;
+       if (!mtd->_point && map_is_linear(map)) {
+               mtd->_point   = cfi_intelext_point;
+               mtd->_unpoint = cfi_intelext_unpoint;
        }
 }
 
@@ -274,8 +274,8 @@ static void fixup_use_write_buffers(struct mtd_info *mtd)
        struct cfi_private *cfi = map->fldrv_priv;
        if (cfi->cfiq->BufWriteTimeoutTyp) {
                printk(KERN_INFO "Using buffer write method\n" );
-               mtd->write = cfi_intelext_write_buffers;
-               mtd->writev = cfi_intelext_writev;
+               mtd->_write = cfi_intelext_write_buffers;
+               mtd->_writev = cfi_intelext_writev;
        }
 }
 
@@ -443,15 +443,15 @@ struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
        mtd->type = MTD_NORFLASH;
 
        /* Fill in the default mtd operations */
-       mtd->erase   = cfi_intelext_erase_varsize;
-       mtd->read    = cfi_intelext_read;
-       mtd->write   = cfi_intelext_write_words;
-       mtd->sync    = cfi_intelext_sync;
-       mtd->lock    = cfi_intelext_lock;
-       mtd->unlock  = cfi_intelext_unlock;
-       mtd->is_locked = cfi_intelext_is_locked;
-       mtd->suspend = cfi_intelext_suspend;
-       mtd->resume  = cfi_intelext_resume;
+       mtd->_erase   = cfi_intelext_erase_varsize;
+       mtd->_read    = cfi_intelext_read;
+       mtd->_write   = cfi_intelext_write_words;
+       mtd->_sync    = cfi_intelext_sync;
+       mtd->_lock    = cfi_intelext_lock;
+       mtd->_unlock  = cfi_intelext_unlock;
+       mtd->_is_locked = cfi_intelext_is_locked;
+       mtd->_suspend = cfi_intelext_suspend;
+       mtd->_resume  = cfi_intelext_resume;
        mtd->flags   = MTD_CAP_NORFLASH;
        mtd->name    = map->name;
        mtd->writesize = 1;
@@ -600,12 +600,12 @@ static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
        }
 
 #ifdef CONFIG_MTD_OTP
-       mtd->read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
-       mtd->read_user_prot_reg = cfi_intelext_read_user_prot_reg;
-       mtd->write_user_prot_reg = cfi_intelext_write_user_prot_reg;
-       mtd->lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
-       mtd->get_fact_prot_info = cfi_intelext_get_fact_prot_info;
-       mtd->get_user_prot_info = cfi_intelext_get_user_prot_info;
+       mtd->_read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
+       mtd->_read_user_prot_reg = cfi_intelext_read_user_prot_reg;
+       mtd->_write_user_prot_reg = cfi_intelext_write_user_prot_reg;
+       mtd->_lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
+       mtd->_get_fact_prot_info = cfi_intelext_get_fact_prot_info;
+       mtd->_get_user_prot_info = cfi_intelext_get_user_prot_info;
 #endif
 
        /* This function has the potential to distort the reality
index e2d94bb1d7c81d57d316af768cad242a6cc1b94d..27ac0622abe37e6fe40925f7c7dd2dabe0398587 100644 (file)
@@ -192,7 +192,7 @@ static void fixup_use_write_buffers(struct mtd_info *mtd)
        struct cfi_private *cfi = map->fldrv_priv;
        if (cfi->cfiq->BufWriteTimeoutTyp) {
                pr_debug("Using buffer write method\n" );
-               mtd->write = cfi_amdstd_write_buffers;
+               mtd->_write = cfi_amdstd_write_buffers;
        }
 }
 
@@ -231,8 +231,8 @@ static void fixup_convert_atmel_pri(struct mtd_info *mtd)
 static void fixup_use_secsi(struct mtd_info *mtd)
 {
        /* Setup for chips with a secsi area */
-       mtd->read_user_prot_reg = cfi_amdstd_secsi_read;
-       mtd->read_fact_prot_reg = cfi_amdstd_secsi_read;
+       mtd->_read_user_prot_reg = cfi_amdstd_secsi_read;
+       mtd->_read_fact_prot_reg = cfi_amdstd_secsi_read;
 }
 
 static void fixup_use_erase_chip(struct mtd_info *mtd)
@@ -241,7 +241,7 @@ static void fixup_use_erase_chip(struct mtd_info *mtd)
        struct cfi_private *cfi = map->fldrv_priv;
        if ((cfi->cfiq->NumEraseRegions == 1) &&
                ((cfi->cfiq->EraseRegionInfo[0] & 0xffff) == 0)) {
-               mtd->erase = cfi_amdstd_erase_chip;
+               mtd->_erase = cfi_amdstd_erase_chip;
        }
 
 }
@@ -252,8 +252,8 @@ static void fixup_use_erase_chip(struct mtd_info *mtd)
  */
 static void fixup_use_atmel_lock(struct mtd_info *mtd)
 {
-       mtd->lock = cfi_atmel_lock;
-       mtd->unlock = cfi_atmel_unlock;
+       mtd->_lock = cfi_atmel_lock;
+       mtd->_unlock = cfi_atmel_unlock;
        mtd->flags |= MTD_POWERUP_LOCK;
 }
 
@@ -432,12 +432,12 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
        mtd->type = MTD_NORFLASH;
 
        /* Fill in the default mtd operations */
-       mtd->erase   = cfi_amdstd_erase_varsize;
-       mtd->write   = cfi_amdstd_write_words;
-       mtd->read    = cfi_amdstd_read;
-       mtd->sync    = cfi_amdstd_sync;
-       mtd->suspend = cfi_amdstd_suspend;
-       mtd->resume  = cfi_amdstd_resume;
+       mtd->_erase   = cfi_amdstd_erase_varsize;
+       mtd->_write   = cfi_amdstd_write_words;
+       mtd->_read    = cfi_amdstd_read;
+       mtd->_sync    = cfi_amdstd_sync;
+       mtd->_suspend = cfi_amdstd_suspend;
+       mtd->_resume  = cfi_amdstd_resume;
        mtd->flags   = MTD_CAP_NORFLASH;
        mtd->name    = map->name;
        mtd->writesize = 1;
@@ -446,7 +446,7 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
        pr_debug("MTD %s(): write buffer size %d\n", __func__,
                        mtd->writebufsize);
 
-       mtd->panic_write = cfi_amdstd_panic_write;
+       mtd->_panic_write = cfi_amdstd_panic_write;
        mtd->reboot_notifier.notifier_call = cfi_amdstd_reboot;
 
        if (cfi->cfi_mode==CFI_MODE_CFI){
index 85e80180b65b5131201d974e6946fdc658c2463b..3861cca97bb0dbbb92bfea9b799db9acc9f1eaf7 100644 (file)
@@ -228,15 +228,15 @@ static struct mtd_info *cfi_staa_setup(struct map_info *map)
                }
 
        /* Also select the correct geometry setup too */
-       mtd->erase = cfi_staa_erase_varsize;
-       mtd->read = cfi_staa_read;
-        mtd->write = cfi_staa_write_buffers;
-       mtd->writev = cfi_staa_writev;
-       mtd->sync = cfi_staa_sync;
-       mtd->lock = cfi_staa_lock;
-       mtd->unlock = cfi_staa_unlock;
-       mtd->suspend = cfi_staa_suspend;
-       mtd->resume = cfi_staa_resume;
+       mtd->_erase = cfi_staa_erase_varsize;
+       mtd->_read = cfi_staa_read;
+       mtd->_write = cfi_staa_write_buffers;
+       mtd->_writev = cfi_staa_writev;
+       mtd->_sync = cfi_staa_sync;
+       mtd->_lock = cfi_staa_lock;
+       mtd->_unlock = cfi_staa_unlock;
+       mtd->_suspend = cfi_staa_suspend;
+       mtd->_resume = cfi_staa_resume;
        mtd->flags = MTD_CAP_NORFLASH & ~MTD_BIT_WRITEABLE;
        mtd->writesize = 8; /* FIXME: Should be 0 for STMicro flashes w/out ECC */
        mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
index 89c6595454a508925fe6c5accf0fbd44d1af56f9..800b0e853e868479b66b5dd917c602c428e0b3d7 100644 (file)
@@ -101,7 +101,7 @@ static void fixup_use_fwh_lock(struct mtd_info *mtd)
 {
        printk(KERN_NOTICE "using fwh lock/unlock method\n");
        /* Setup for the chips with the fwh lock method */
-       mtd->lock   = fwh_lock_varsize;
-       mtd->unlock = fwh_unlock_varsize;
+       mtd->_lock   = fwh_lock_varsize;
+       mtd->_unlock = fwh_unlock_varsize;
 }
 #endif /* FWH_LOCK_H */
index f2b87294687182abedba8ef30379fcd089e2827b..6be2eddfea45c4b154a07ee2038c2d00575857e6 100644 (file)
@@ -55,10 +55,10 @@ static struct mtd_info *map_absent_probe(struct map_info *map)
        mtd->name       = map->name;
        mtd->type       = MTD_ABSENT;
        mtd->size       = map->size;
-       mtd->erase      = map_absent_erase;
-       mtd->read       = map_absent_read;
-       mtd->write      = map_absent_write;
-       mtd->sync       = map_absent_sync;
+       mtd->_erase     = map_absent_erase;
+       mtd->_read      = map_absent_read;
+       mtd->_write     = map_absent_write;
+       mtd->_sync      = map_absent_sync;
        mtd->flags      = 0;
        mtd->erasesize  = PAGE_SIZE;
        mtd->writesize  = 1;
index 67640ccb2d4168d959de0f3c3d9c9b573f029923..225307088dc029ae24fd70eb9b7d5f136bdd32c9 100644 (file)
@@ -64,11 +64,11 @@ static struct mtd_info *map_ram_probe(struct map_info *map)
        mtd->name = map->name;
        mtd->type = MTD_RAM;
        mtd->size = map->size;
-       mtd->erase = mapram_erase;
-       mtd->get_unmapped_area = mapram_unmapped_area;
-       mtd->read = mapram_read;
-       mtd->write = mapram_write;
-       mtd->sync = mapram_nop;
+       mtd->_erase = mapram_erase;
+       mtd->_get_unmapped_area = mapram_unmapped_area;
+       mtd->_read = mapram_read;
+       mtd->_write = mapram_write;
+       mtd->_sync = mapram_nop;
        mtd->flags = MTD_CAP_RAM;
        mtd->writesize = 1;
 
index 593f73d480d2cf9e615ced4e2e66d758e3c4f8f3..facb56092d3912203b1f77ac542e727e28e31073 100644 (file)
@@ -41,11 +41,11 @@ static struct mtd_info *map_rom_probe(struct map_info *map)
        mtd->name = map->name;
        mtd->type = MTD_ROM;
        mtd->size = map->size;
-       mtd->get_unmapped_area = maprom_unmapped_area;
-       mtd->read = maprom_read;
-       mtd->write = maprom_write;
-       mtd->sync = maprom_nop;
-       mtd->erase = maprom_erase;
+       mtd->_get_unmapped_area = maprom_unmapped_area;
+       mtd->_read = maprom_read;
+       mtd->_write = maprom_write;
+       mtd->_sync = maprom_nop;
+       mtd->_erase = maprom_erase;
        mtd->flags = MTD_CAP_ROM;
        mtd->erasesize = map->size;
        mtd->writesize = 1;
index e7e46d1e74631b6f31cbde50a0590077d8ee0da6..d9e75dafdd45c4cb223fc50e8852ab7831f850a4 100644 (file)
@@ -285,11 +285,11 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
        dev->mtd.writesize = 1;
        dev->mtd.type = MTD_RAM;
        dev->mtd.flags = MTD_CAP_RAM;
-       dev->mtd.erase = block2mtd_erase;
-       dev->mtd.write = block2mtd_write;
-       dev->mtd.writev = mtd_writev;
-       dev->mtd.sync = block2mtd_sync;
-       dev->mtd.read = block2mtd_read;
+       dev->mtd._erase = block2mtd_erase;
+       dev->mtd._write = block2mtd_write;
+       dev->mtd._writev = mtd_writev;
+       dev->mtd._sync = block2mtd_sync;
+       dev->mtd._read = block2mtd_read;
        dev->mtd.priv = dev;
        dev->mtd.owner = THIS_MODULE;
 
index b1cdf647901960fd88ef2bce4a787c21ace8a03d..ffd01a66a17593da06caa1e3a715fc2f9ddce7ba 100644 (file)
@@ -565,11 +565,11 @@ void DoC2k_init(struct mtd_info *mtd)
        mtd->writesize = 512;
        mtd->oobsize = 16;
        mtd->owner = THIS_MODULE;
-       mtd->erase = doc_erase;
-       mtd->read = doc_read;
-       mtd->write = doc_write;
-       mtd->read_oob = doc_read_oob;
-       mtd->write_oob = doc_write_oob;
+       mtd->_erase = doc_erase;
+       mtd->_read = doc_read;
+       mtd->_write = doc_write;
+       mtd->_read_oob = doc_read_oob;
+       mtd->_write_oob = doc_write_oob;
        this->curfloor = -1;
        this->curchip = -1;
        mutex_init(&this->lock);
index 7543b98f46c46c1524a5f5aeec26b4c567e07d49..3785733650cbf473008c676eef5df74b78031728 100644 (file)
@@ -349,11 +349,11 @@ void DoCMil_init(struct mtd_info *mtd)
        mtd->writesize = 512;
        mtd->oobsize = 16;
        mtd->owner = THIS_MODULE;
-       mtd->erase = doc_erase;
-       mtd->read = doc_read;
-       mtd->write = doc_write;
-       mtd->read_oob = doc_read_oob;
-       mtd->write_oob = doc_write_oob;
+       mtd->_erase = doc_erase;
+       mtd->_read = doc_read;
+       mtd->_write = doc_write;
+       mtd->_read_oob = doc_read_oob;
+       mtd->_write_oob = doc_write_oob;
        this->curfloor = -1;
        this->curchip = -1;
 
index 177510d0e7ee0c35a23450e6f66b7fdc944c5a6c..409fa3174cc475e6cd7edc3e7cab21416e247283 100644 (file)
@@ -470,11 +470,11 @@ void DoCMilPlus_init(struct mtd_info *mtd)
        mtd->writesize = 512;
        mtd->oobsize = 16;
        mtd->owner = THIS_MODULE;
-       mtd->erase = doc_erase;
-       mtd->read = doc_read;
-       mtd->write = doc_write;
-       mtd->read_oob = doc_read_oob;
-       mtd->write_oob = doc_write_oob;
+       mtd->_erase = doc_erase;
+       mtd->_read = doc_read;
+       mtd->_write = doc_write;
+       mtd->_read_oob = doc_read_oob;
+       mtd->_write_oob = doc_write_oob;
        this->curfloor = -1;
        this->curchip = -1;
 
index ad11ef0a81f401dc0f2b4e2440f5d27af10e4708..3746ae8ff0a2b61c8438f81d58353bf50555548f 100644 (file)
@@ -1820,12 +1820,12 @@ static void __init doc_set_driver_info(int chip_id, struct mtd_info *mtd)
        mtd->writesize = DOC_LAYOUT_PAGE_SIZE;
        mtd->oobsize = DOC_LAYOUT_OOB_SIZE;
        mtd->owner = THIS_MODULE;
-       mtd->erase = doc_erase;
-       mtd->read = doc_read;
-       mtd->write = doc_write;
-       mtd->read_oob = doc_read_oob;
-       mtd->write_oob = doc_write_oob;
-       mtd->block_isbad = doc_block_isbad;
+       mtd->_erase = doc_erase;
+       mtd->_read = doc_read;
+       mtd->_write = doc_write;
+       mtd->_read_oob = doc_read_oob;
+       mtd->_write_oob = doc_write_oob;
+       mtd->_block_isbad = doc_block_isbad;
        mtd->ecclayout = &docg3_oobinfo;
 }
 
index 3a11ea628e58a2249bbe1d54939a77d2003690cb..a59584871af595871e79cfcf833973174bd7e4e1 100644 (file)
@@ -635,9 +635,9 @@ static int __init lart_flash_init (void)
    mtd.erasesize = FLASH_BLOCKSIZE_MAIN;
    mtd.numeraseregions = ARRAY_SIZE(erase_regions);
    mtd.eraseregions = erase_regions;
-   mtd.erase = flash_erase;
-   mtd.read = flash_read;
-   mtd.write = flash_write;
+   mtd._erase = flash_erase;
+   mtd._read = flash_read;
+   mtd._write = flash_write;
    mtd.owner = THIS_MODULE;
 
 #ifdef LART_DEBUG
index 230b02e336ab8e1b0c539d721b9be25769129858..f83e4d0366cc37c8d0f8bbbfea71c28fe3388617 100644 (file)
@@ -908,14 +908,14 @@ static int __devinit m25p_probe(struct spi_device *spi)
        flash->mtd.writesize = 1;
        flash->mtd.flags = MTD_CAP_NORFLASH;
        flash->mtd.size = info->sector_size * info->n_sectors;
-       flash->mtd.erase = m25p80_erase;
-       flash->mtd.read = m25p80_read;
+       flash->mtd._erase = m25p80_erase;
+       flash->mtd._read = m25p80_read;
 
        /* sst flash chips use AAI word program */
        if (JEDEC_MFR(info->jedec_id) == CFI_MFR_SST)
-               flash->mtd.write = sst_write;
+               flash->mtd._write = sst_write;
        else
-               flash->mtd.write = m25p80_write;
+               flash->mtd._write = m25p80_write;
 
        /* prefer "small sector" erase if possible */
        if (info->flags & SECT_4K) {
index 8423fb6d4f26b05df635ee14608e654599627fc7..3a05af529e7d777602bd012b6a2b5b25c70f90f5 100644 (file)
@@ -215,8 +215,8 @@ static int __init ms02nv_init_one(ulong addr)
        mtd->size = fixsize;
        mtd->name = (char *)ms02nv_name;
        mtd->owner = THIS_MODULE;
-       mtd->read = ms02nv_read;
-       mtd->write = ms02nv_write;
+       mtd->_read = ms02nv_read;
+       mtd->_write = ms02nv_write;
        mtd->writesize = 1;
 
        ret = -EIO;
index 5ec5fc9fe045efd5d12297eaef5fd4e14317d08c..fd4a9fc0d8b8232c353741f71633ac3cf2f5efaf 100644 (file)
@@ -611,16 +611,16 @@ static int dataflash_write_user_otp(struct mtd_info *mtd,
 
 static char *otp_setup(struct mtd_info *device, char revision)
 {
-       device->get_fact_prot_info = dataflash_get_otp_info;
-       device->read_fact_prot_reg = dataflash_read_fact_otp;
-       device->get_user_prot_info = dataflash_get_otp_info;
-       device->read_user_prot_reg = dataflash_read_user_otp;
+       device->_get_fact_prot_info = dataflash_get_otp_info;
+       device->_read_fact_prot_reg = dataflash_read_fact_otp;
+       device->_get_user_prot_info = dataflash_get_otp_info;
+       device->_read_user_prot_reg = dataflash_read_user_otp;
 
        /* rev c parts (at45db321c and at45db1281 only!) use a
         * different write procedure; not (yet?) implemented.
         */
        if (revision > 'c')
-               device->write_user_prot_reg = dataflash_write_user_otp;
+               device->_write_user_prot_reg = dataflash_write_user_otp;
 
        return ", OTP";
 }
@@ -672,9 +672,9 @@ add_dataflash_otp(struct spi_device *spi, char *name,
        device->owner = THIS_MODULE;
        device->type = MTD_DATAFLASH;
        device->flags = MTD_WRITEABLE;
-       device->erase = dataflash_erase;
-       device->read = dataflash_read;
-       device->write = dataflash_write;
+       device->_erase = dataflash_erase;
+       device->_read = dataflash_read;
+       device->_write = dataflash_write;
        device->priv = priv;
 
        device->dev.parent = &spi->dev;
index 2562689ba6b47d185edd5c3ba862af50a8ae97a8..91030cfb03b3d05d901905d8279b396a7bf3a51b 100644 (file)
@@ -126,12 +126,12 @@ int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
        mtd->priv = mapped_address;
 
        mtd->owner = THIS_MODULE;
-       mtd->erase = ram_erase;
-       mtd->point = ram_point;
-       mtd->unpoint = ram_unpoint;
-       mtd->get_unmapped_area = ram_get_unmapped_area;
-       mtd->read = ram_read;
-       mtd->write = ram_write;
+       mtd->_erase = ram_erase;
+       mtd->_point = ram_point;
+       mtd->_unpoint = ram_unpoint;
+       mtd->_get_unmapped_area = ram_get_unmapped_area;
+       mtd->_read = ram_read;
+       mtd->_write = ram_write;
 
        if (mtd_device_register(mtd, NULL, 0))
                return -EIO;
index 23423bd00b069da5266d72cbfa6353f21ec775dd..eff2b69864f5153484b52729478c44cc7386f7f8 100644 (file)
@@ -142,11 +142,11 @@ static int register_device(char *name, unsigned long start, unsigned long len)
        new->mtd.name = name;
        new->mtd.size = len;
        new->mtd.flags = MTD_CAP_RAM;
-        new->mtd.erase = phram_erase;
-       new->mtd.point = phram_point;
-       new->mtd.unpoint = phram_unpoint;
-       new->mtd.read = phram_read;
-       new->mtd.write = phram_write;
+       new->mtd._erase = phram_erase;
+       new->mtd._point = phram_point;
+       new->mtd._unpoint = phram_unpoint;
+       new->mtd._read = phram_read;
+       new->mtd._write = phram_write;
        new->mtd.owner = THIS_MODULE;
        new->mtd.type = MTD_RAM;
        new->mtd.erasesize = PAGE_SIZE;
index cfccf65104116141a7fa67ae153ddb7e2706ab74..67d22e1cbc0ed8af85ae2793195a384b3bcbf8a7 100644 (file)
@@ -787,11 +787,11 @@ static int __init init_pmc551(void)
 
                mtd->size = msize;
                mtd->flags = MTD_CAP_RAM;
-               mtd->erase = pmc551_erase;
-               mtd->read = pmc551_read;
-               mtd->write = pmc551_write;
-               mtd->point = pmc551_point;
-               mtd->unpoint = pmc551_unpoint;
+               mtd->_erase = pmc551_erase;
+               mtd->_read = pmc551_read;
+               mtd->_write = pmc551_write;
+               mtd->_point = pmc551_point;
+               mtd->_unpoint = pmc551_unpoint;
                mtd->type = MTD_RAM;
                mtd->name = "PMC551 RAM board";
                mtd->erasesize = 0x10000;
index e585263161b949ee1b863725ae627f6a4595fc7f..cbeb19522bbce6e9b524e245c04ec413a8b4e209 100644 (file)
@@ -200,11 +200,11 @@ static int register_device(char *name, unsigned long start, unsigned long length
        (*curmtd)->mtdinfo->name = name;
        (*curmtd)->mtdinfo->size = length;
        (*curmtd)->mtdinfo->flags = MTD_CAP_RAM;
-        (*curmtd)->mtdinfo->erase = slram_erase;
-       (*curmtd)->mtdinfo->point = slram_point;
-       (*curmtd)->mtdinfo->unpoint = slram_unpoint;
-       (*curmtd)->mtdinfo->read = slram_read;
-       (*curmtd)->mtdinfo->write = slram_write;
+       (*curmtd)->mtdinfo->_erase = slram_erase;
+       (*curmtd)->mtdinfo->_point = slram_point;
+       (*curmtd)->mtdinfo->_unpoint = slram_unpoint;
+       (*curmtd)->mtdinfo->_read = slram_read;
+       (*curmtd)->mtdinfo->_write = slram_write;
        (*curmtd)->mtdinfo->owner = THIS_MODULE;
        (*curmtd)->mtdinfo->type = MTD_RAM;
        (*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ;
index 0f0f1ac06493867d58306d0b9a4e20417f7bb258..5f4254254641b7bfee259c14b2f2e9013391619f 100644 (file)
@@ -846,9 +846,9 @@ static int spear_smi_setup_banks(struct platform_device *pdev, u32 bank)
        flash->mtd.erasesize = flash_devices[flash_index].sectorsize;
        flash->page_size = flash_devices[flash_index].pagesize;
        flash->erase_cmd = flash_devices[flash_index].erase_cmd;
-       flash->mtd.erase = spear_mtd_erase;
-       flash->mtd.read = spear_mtd_read;
-       flash->mtd.write = spear_mtd_write;
+       flash->mtd._erase = spear_mtd_erase;
+       flash->mtd._read = spear_mtd_read;
+       flash->mtd._write = spear_mtd_write;
        flash->dev_id = flash_devices[flash_index].device_id;
 
        dev_info(&dev->pdev->dev, "mtd .name=%s .size=%llx(%lluM)\n",
index 196fd95b19d6161cc127c66f3807505fe0515e0a..a665eba96e7fabe1a1da346749713700e245d267 100644 (file)
@@ -403,9 +403,9 @@ static int __devinit sst25l_probe(struct spi_device *spi)
        flash->mtd.erasesize    = flash_info->erase_size;
        flash->mtd.writesize    = flash_info->page_size;
        flash->mtd.size         = flash_info->page_size * flash_info->nr_pages;
-       flash->mtd.erase        = sst25l_erase;
-       flash->mtd.read         = sst25l_read;
-       flash->mtd.write        = sst25l_write;
+       flash->mtd._erase       = sst25l_erase;
+       flash->mtd._read                = sst25l_read;
+       flash->mtd._write       = sst25l_write;
 
        dev_info(&spi->dev, "%s (%lld KiB)\n", flash_info->name,
                 (long long)flash->mtd.size >> 10);
index 28646c95cfb845803fd983c6a83b489bf4130c41..3af351484098b6b47c5b0973dda092abdc1bfe0d 100644 (file)
@@ -56,7 +56,7 @@ static void inftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
        if (memcmp(mtd->name, "DiskOnChip", 10))
                return;
 
-       if (!mtd->block_isbad) {
+       if (!mtd->_block_isbad) {
                printk(KERN_ERR
 "INFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n"
 "Please use the new diskonchip driver under the NAND subsystem.\n");
index 536bbceaeaad559868acf633a6cd994412af3c4a..fd19d3b1ee906b7451fe1627b0fcd589822e69af 100644 (file)
@@ -63,18 +63,18 @@ struct mtd_info *lpddr_cmdset(struct map_info *map)
        mtd->type = MTD_NORFLASH;
 
        /* Fill in the default mtd operations */
-       mtd->read = lpddr_read;
+       mtd->_read = lpddr_read;
        mtd->type = MTD_NORFLASH;
        mtd->flags = MTD_CAP_NORFLASH;
        mtd->flags &= ~MTD_BIT_WRITEABLE;
-       mtd->erase = lpddr_erase;
-       mtd->write = lpddr_write_buffers;
-       mtd->writev = lpddr_writev;
-       mtd->lock = lpddr_lock;
-       mtd->unlock = lpddr_unlock;
+       mtd->_erase = lpddr_erase;
+       mtd->_write = lpddr_write_buffers;
+       mtd->_writev = lpddr_writev;
+       mtd->_lock = lpddr_lock;
+       mtd->_unlock = lpddr_unlock;
        if (map_is_linear(map)) {
-               mtd->point = lpddr_point;
-               mtd->unpoint = lpddr_unpoint;
+               mtd->_point = lpddr_point;
+               mtd->_unpoint = lpddr_unpoint;
        }
        mtd->size = 1 << lpddr->qinfo->DevSizeShift;
        mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift;
index 6793074f3f40aff0eacb4d4e94eb6c8e960e51e7..cfff454f628ba73498f0876355e9c1266d67c7fa 100644 (file)
@@ -85,7 +85,7 @@ static int __init uclinux_mtd_init(void)
        }
 
        mtd->owner = THIS_MODULE;
-       mtd->point = uclinux_point;
+       mtd->_point = uclinux_point;
        mtd->priv = mapp;
 
        uclinux_ram_mtdinfo = mtd;
index 3a04b078576a0aa04ee07afa4fec48c56fe3f43b..48a803e2cd2edbd6cac48790201fd20e3fc3e9d5 100644 (file)
@@ -544,9 +544,9 @@ static void vmu_queryblocks(struct mapleq *mq)
        mtd_cur->flags = MTD_WRITEABLE|MTD_NO_ERASE;
        mtd_cur->size = part_cur->numblocks * card->blocklen;
        mtd_cur->erasesize = card->blocklen;
-       mtd_cur->write = vmu_flash_write;
-       mtd_cur->read = vmu_flash_read;
-       mtd_cur->sync = vmu_flash_sync;
+       mtd_cur->_write = vmu_flash_write;
+       mtd_cur->_read = vmu_flash_read;
+       mtd_cur->_sync = vmu_flash_sync;
        mtd_cur->writesize = card->blocklen;
 
        mpart = kmalloc(sizeof(struct mdev_part), GFP_KERNEL);
index 50c6a1e7f675cea884a5a0bbb71fb061bfdfe932..426640eaf81823ebe06825a98090de76ca340ab6 100644 (file)
@@ -405,7 +405,7 @@ static int mtdchar_writeoob(struct file *file, struct mtd_info *mtd,
        if (length > 4096)
                return -EINVAL;
 
-       if (!mtd->write_oob)
+       if (!mtd->_write_oob)
                ret = -EOPNOTSUPP;
        else
                ret = access_ok(VERIFY_READ, ptr, length) ? 0 : -EFAULT;
@@ -576,7 +576,7 @@ static int mtdchar_write_ioctl(struct mtd_info *mtd,
                        !access_ok(VERIFY_READ, req.usr_data, req.len) ||
                        !access_ok(VERIFY_READ, req.usr_oob, req.ooblen))
                return -EFAULT;
-       if (!mtd->write_oob)
+       if (!mtd->_write_oob)
                return -EOPNOTSUPP;
 
        ops.mode = req.mode;
index 1ed5103b219ba3d51919b3ae285eb64f335e1af9..5c7eb69c4ed987f8e80acca6ef7d2664b6fb300e 100644 (file)
@@ -777,16 +777,16 @@ struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],     /* subdevices to c
        concat->mtd.subpage_sft = subdev[0]->subpage_sft;
        concat->mtd.oobsize = subdev[0]->oobsize;
        concat->mtd.oobavail = subdev[0]->oobavail;
-       if (subdev[0]->writev)
-               concat->mtd.writev = concat_writev;
-       if (subdev[0]->read_oob)
-               concat->mtd.read_oob = concat_read_oob;
-       if (subdev[0]->write_oob)
-               concat->mtd.write_oob = concat_write_oob;
-       if (subdev[0]->block_isbad)
-               concat->mtd.block_isbad = concat_block_isbad;
-       if (subdev[0]->block_markbad)
-               concat->mtd.block_markbad = concat_block_markbad;
+       if (subdev[0]->_writev)
+               concat->mtd._writev = concat_writev;
+       if (subdev[0]->_read_oob)
+               concat->mtd._read_oob = concat_read_oob;
+       if (subdev[0]->_write_oob)
+               concat->mtd._write_oob = concat_write_oob;
+       if (subdev[0]->_block_isbad)
+               concat->mtd._block_isbad = concat_block_isbad;
+       if (subdev[0]->_block_markbad)
+               concat->mtd._block_markbad = concat_block_markbad;
 
        concat->mtd.ecc_stats.badblocks = subdev[0]->ecc_stats.badblocks;
 
@@ -833,8 +833,8 @@ struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],       /* subdevices to c
                if (concat->mtd.writesize   !=  subdev[i]->writesize ||
                    concat->mtd.subpage_sft != subdev[i]->subpage_sft ||
                    concat->mtd.oobsize    !=  subdev[i]->oobsize ||
-                   !concat->mtd.read_oob  != !subdev[i]->read_oob ||
-                   !concat->mtd.write_oob != !subdev[i]->write_oob) {
+                   !concat->mtd._read_oob  != !subdev[i]->_read_oob ||
+                   !concat->mtd._write_oob != !subdev[i]->_write_oob) {
                        kfree(concat);
                        printk("Incompatible OOB or ECC data on \"%s\"\n",
                               subdev[i]->name);
@@ -849,15 +849,15 @@ struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],     /* subdevices to c
        concat->num_subdev = num_devs;
        concat->mtd.name = name;
 
-       concat->mtd.erase = concat_erase;
-       concat->mtd.read = concat_read;
-       concat->mtd.write = concat_write;
-       concat->mtd.sync = concat_sync;
-       concat->mtd.lock = concat_lock;
-       concat->mtd.unlock = concat_unlock;
-       concat->mtd.suspend = concat_suspend;
-       concat->mtd.resume = concat_resume;
-       concat->mtd.get_unmapped_area = concat_get_unmapped_area;
+       concat->mtd._erase = concat_erase;
+       concat->mtd._read = concat_read;
+       concat->mtd._write = concat_write;
+       concat->mtd._sync = concat_sync;
+       concat->mtd._lock = concat_lock;
+       concat->mtd._unlock = concat_unlock;
+       concat->mtd._suspend = concat_suspend;
+       concat->mtd._resume = concat_resume;
+       concat->mtd._get_unmapped_area = concat_get_unmapped_area;
 
        /*
         * Combine the erase block size info of the subdevices:
index de96865b4f9636cdc8e80a9506b9769ea6cbbf19..aafe0ee9c9f34feecf7a4f99dfcdc231a637d209 100644 (file)
@@ -126,7 +126,7 @@ static int mtd_cls_resume(struct device *dev)
 {
        struct mtd_info *mtd = dev_get_drvdata(dev);
 
-       if (mtd && mtd->resume)
+       if (mtd && mtd->_resume)
                mtd_resume(mtd);
        return 0;
 }
@@ -610,8 +610,8 @@ int __get_mtd_device(struct mtd_info *mtd)
        if (!try_module_get(mtd->owner))
                return -ENODEV;
 
-       if (mtd->get_device) {
-               err = mtd->get_device(mtd);
+       if (mtd->_get_device) {
+               err = mtd->_get_device(mtd);
 
                if (err) {
                        module_put(mtd->owner);
@@ -675,8 +675,8 @@ void __put_mtd_device(struct mtd_info *mtd)
        --mtd->usecount;
        BUG_ON(mtd->usecount < 0);
 
-       if (mtd->put_device)
-               mtd->put_device(mtd);
+       if (mtd->_put_device)
+               mtd->_put_device(mtd);
 
        module_put(mtd->owner);
 }
@@ -729,9 +729,9 @@ int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
               unsigned long count, loff_t to, size_t *retlen)
 {
        *retlen = 0;
-       if (!mtd->writev)
+       if (!mtd->_writev)
                return default_mtd_writev(mtd, vecs, count, to, retlen);
-       return mtd->writev(mtd, vecs, count, to, retlen);
+       return mtd->_writev(mtd, vecs, count, to, retlen);
 }
 EXPORT_SYMBOL_GPL(mtd_writev);
 
index 47d00f0bb36d59ae9ae787814f3e5b86eeadcb49..4f01079e357f8a53bdb83dce0de6486df6837ecd 100644 (file)
@@ -262,7 +262,7 @@ static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
 
 void mtd_erase_callback(struct erase_info *instr)
 {
-       if (instr->mtd->erase == part_erase) {
+       if (instr->mtd->_erase == part_erase) {
                struct mtd_part *part = PART(instr->mtd);
 
                if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
@@ -410,54 +410,55 @@ static struct mtd_part *allocate_partition(struct mtd_info *master,
         */
        slave->mtd.dev.parent = master->dev.parent;
 
-       slave->mtd.read = part_read;
-       slave->mtd.write = part_write;
+       slave->mtd._read = part_read;
+       slave->mtd._write = part_write;
 
-       if (master->panic_write)
-               slave->mtd.panic_write = part_panic_write;
+       if (master->_panic_write)
+               slave->mtd._panic_write = part_panic_write;
 
-       if (master->point && master->unpoint) {
-               slave->mtd.point = part_point;
-               slave->mtd.unpoint = part_unpoint;
+       if (master->_point && master->_unpoint) {
+               slave->mtd._point = part_point;
+               slave->mtd._unpoint = part_unpoint;
        }
 
-       if (master->get_unmapped_area)
-               slave->mtd.get_unmapped_area = part_get_unmapped_area;
-       if (master->read_oob)
-               slave->mtd.read_oob = part_read_oob;
-       if (master->write_oob)
-               slave->mtd.write_oob = part_write_oob;
-       if (master->read_user_prot_reg)
-               slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
-       if (master->read_fact_prot_reg)
-               slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
-       if (master->write_user_prot_reg)
-               slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
-       if (master->lock_user_prot_reg)
-               slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
-       if (master->get_user_prot_info)
-               slave->mtd.get_user_prot_info = part_get_user_prot_info;
-       if (master->get_fact_prot_info)
-               slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
-       if (master->sync)
-               slave->mtd.sync = part_sync;
-       if (!partno && !master->dev.class && master->suspend && master->resume) {
-                       slave->mtd.suspend = part_suspend;
-                       slave->mtd.resume = part_resume;
+       if (master->_get_unmapped_area)
+               slave->mtd._get_unmapped_area = part_get_unmapped_area;
+       if (master->_read_oob)
+               slave->mtd._read_oob = part_read_oob;
+       if (master->_write_oob)
+               slave->mtd._write_oob = part_write_oob;
+       if (master->_read_user_prot_reg)
+               slave->mtd._read_user_prot_reg = part_read_user_prot_reg;
+       if (master->_read_fact_prot_reg)
+               slave->mtd._read_fact_prot_reg = part_read_fact_prot_reg;
+       if (master->_write_user_prot_reg)
+               slave->mtd._write_user_prot_reg = part_write_user_prot_reg;
+       if (master->_lock_user_prot_reg)
+               slave->mtd._lock_user_prot_reg = part_lock_user_prot_reg;
+       if (master->_get_user_prot_info)
+               slave->mtd._get_user_prot_info = part_get_user_prot_info;
+       if (master->_get_fact_prot_info)
+               slave->mtd._get_fact_prot_info = part_get_fact_prot_info;
+       if (master->_sync)
+               slave->mtd._sync = part_sync;
+       if (!partno && !master->dev.class && master->_suspend &&
+           master->_resume) {
+                       slave->mtd._suspend = part_suspend;
+                       slave->mtd._resume = part_resume;
        }
-       if (master->writev)
-               slave->mtd.writev = part_writev;
-       if (master->lock)
-               slave->mtd.lock = part_lock;
-       if (master->unlock)
-               slave->mtd.unlock = part_unlock;
-       if (master->is_locked)
-               slave->mtd.is_locked = part_is_locked;
-       if (master->block_isbad)
-               slave->mtd.block_isbad = part_block_isbad;
-       if (master->block_markbad)
-               slave->mtd.block_markbad = part_block_markbad;
-       slave->mtd.erase = part_erase;
+       if (master->_writev)
+               slave->mtd._writev = part_writev;
+       if (master->_lock)
+               slave->mtd._lock = part_lock;
+       if (master->_unlock)
+               slave->mtd._unlock = part_unlock;
+       if (master->_is_locked)
+               slave->mtd._is_locked = part_is_locked;
+       if (master->_block_isbad)
+               slave->mtd._block_isbad = part_block_isbad;
+       if (master->_block_markbad)
+               slave->mtd._block_markbad = part_block_markbad;
+       slave->mtd._erase = part_erase;
        slave->master = master;
        slave->offset = part->offset;
 
@@ -549,7 +550,7 @@ static struct mtd_part *allocate_partition(struct mtd_info *master,
        }
 
        slave->mtd.ecclayout = master->ecclayout;
-       if (master->block_isbad) {
+       if (master->_block_isbad) {
                uint64_t offs = 0;
 
                while (offs < slave->mtd.size) {
index 6a5ff64a139e6281e5b92a80f5c39066e81563ac..ac38f73fde3b8d87caeb2fc1519e1febf150d324 100644 (file)
@@ -585,10 +585,10 @@ static int alauda_init_media(struct alauda *al)
        mtd->writesize = 1<<card->pageshift;
        mtd->type = MTD_NANDFLASH;
        mtd->flags = MTD_CAP_NANDFLASH;
-       mtd->read = alauda_read;
-       mtd->write = alauda_write;
-       mtd->erase = alauda_erase;
-       mtd->block_isbad = alauda_isbad;
+       mtd->_read = alauda_read;
+       mtd->_write = alauda_write;
+       mtd->_erase = alauda_erase;
+       mtd->_block_isbad = alauda_isbad;
        mtd->priv = al;
        mtd->owner = THIS_MODULE;
 
index b90206613108844ad5da9252222ad36245f791d7..05f8243ed1d392fc1477cd1d3e0df35dff5fbee0 100644 (file)
@@ -3483,21 +3483,21 @@ int nand_scan_tail(struct mtd_info *mtd)
        mtd->type = MTD_NANDFLASH;
        mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM :
                                                MTD_CAP_NANDFLASH;
-       mtd->erase = nand_erase;
-       mtd->point = NULL;
-       mtd->unpoint = NULL;
-       mtd->read = nand_read;
-       mtd->write = nand_write;
-       mtd->panic_write = panic_nand_write;
-       mtd->read_oob = nand_read_oob;
-       mtd->write_oob = nand_write_oob;
-       mtd->sync = nand_sync;
-       mtd->lock = NULL;
-       mtd->unlock = NULL;
-       mtd->suspend = nand_suspend;
-       mtd->resume = nand_resume;
-       mtd->block_isbad = nand_block_isbad;
-       mtd->block_markbad = nand_block_markbad;
+       mtd->_erase = nand_erase;
+       mtd->_point = NULL;
+       mtd->_unpoint = NULL;
+       mtd->_read = nand_read;
+       mtd->_write = nand_write;
+       mtd->_panic_write = panic_nand_write;
+       mtd->_read_oob = nand_read_oob;
+       mtd->_write_oob = nand_write_oob;
+       mtd->_sync = nand_sync;
+       mtd->_lock = NULL;
+       mtd->_unlock = NULL;
+       mtd->_suspend = nand_suspend;
+       mtd->_resume = nand_resume;
+       mtd->_block_isbad = nand_block_isbad;
+       mtd->_block_markbad = nand_block_markbad;
        mtd->writebufsize = mtd->writesize;
 
        /* propagate ecc.layout to mtd_info */
index a061bc163da2e128171bdc9fce6d146e6163b411..914c49bdf2b61977f9895daca210f9eee443f2d5 100644 (file)
@@ -4107,29 +4107,29 @@ int onenand_scan(struct mtd_info *mtd, int maxchips)
        /* Fill in remaining MTD driver data */
        mtd->type = ONENAND_IS_MLC(this) ? MTD_MLCNANDFLASH : MTD_NANDFLASH;
        mtd->flags = MTD_CAP_NANDFLASH;
-       mtd->erase = onenand_erase;
-       mtd->point = NULL;
-       mtd->unpoint = NULL;
-       mtd->read = onenand_read;
-       mtd->write = onenand_write;
-       mtd->read_oob = onenand_read_oob;
-       mtd->write_oob = onenand_write_oob;
-       mtd->panic_write = onenand_panic_write;
+       mtd->_erase = onenand_erase;
+       mtd->_point = NULL;
+       mtd->_unpoint = NULL;
+       mtd->_read = onenand_read;
+       mtd->_write = onenand_write;
+       mtd->_read_oob = onenand_read_oob;
+       mtd->_write_oob = onenand_write_oob;
+       mtd->_panic_write = onenand_panic_write;
 #ifdef CONFIG_MTD_ONENAND_OTP
-       mtd->get_fact_prot_info = onenand_get_fact_prot_info;
-       mtd->read_fact_prot_reg = onenand_read_fact_prot_reg;
-       mtd->get_user_prot_info = onenand_get_user_prot_info;
-       mtd->read_user_prot_reg = onenand_read_user_prot_reg;
-       mtd->write_user_prot_reg = onenand_write_user_prot_reg;
-       mtd->lock_user_prot_reg = onenand_lock_user_prot_reg;
+       mtd->_get_fact_prot_info = onenand_get_fact_prot_info;
+       mtd->_read_fact_prot_reg = onenand_read_fact_prot_reg;
+       mtd->_get_user_prot_info = onenand_get_user_prot_info;
+       mtd->_read_user_prot_reg = onenand_read_user_prot_reg;
+       mtd->_write_user_prot_reg = onenand_write_user_prot_reg;
+       mtd->_lock_user_prot_reg = onenand_lock_user_prot_reg;
 #endif
-       mtd->sync = onenand_sync;
-       mtd->lock = onenand_lock;
-       mtd->unlock = onenand_unlock;
-       mtd->suspend = onenand_suspend;
-       mtd->resume = onenand_resume;
-       mtd->block_isbad = onenand_block_isbad;
-       mtd->block_markbad = onenand_block_markbad;
+       mtd->_sync = onenand_sync;
+       mtd->_lock = onenand_lock;
+       mtd->_unlock = onenand_unlock;
+       mtd->_suspend = onenand_suspend;
+       mtd->_resume = onenand_resume;
+       mtd->_block_isbad = onenand_block_isbad;
+       mtd->_block_markbad = onenand_block_markbad;
        mtd->owner = THIS_MODULE;
        mtd->writebufsize = mtd->writesize;
 
index 941bc3c05d6e51232eabfbdd6db08a0248bb4328..0101dce90c451148351206ab0e8be2203be8a7be 100644 (file)
@@ -340,11 +340,11 @@ static int gluebi_create(struct ubi_device_info *di,
        mtd->owner      = THIS_MODULE;
        mtd->writesize  = di->min_io_size;
        mtd->erasesize  = vi->usable_leb_size;
-       mtd->read       = gluebi_read;
-       mtd->write      = gluebi_write;
-       mtd->erase      = gluebi_erase;
-       mtd->get_device = gluebi_get_device;
-       mtd->put_device = gluebi_put_device;
+       mtd->_read       = gluebi_read;
+       mtd->_write      = gluebi_write;
+       mtd->_erase      = gluebi_erase;
+       mtd->_get_device = gluebi_get_device;
+       mtd->_put_device = gluebi_put_device;
 
        /*
         * In case of dynamic a volume, MTD device size is just volume size. In
index bc9dcd6b30d7f6e290ab4236998e00a06af37e41..6622eca09cbef884baeba56f6923dae4c15c6490 100644 (file)
@@ -263,10 +263,10 @@ static int efx_mtd_probe_device(struct efx_nic *efx, struct efx_mtd *efx_mtd)
                part->mtd.owner = THIS_MODULE;
                part->mtd.priv = efx_mtd;
                part->mtd.name = part->name;
-               part->mtd.erase = efx_mtd_erase;
-               part->mtd.read = efx_mtd->ops->read;
-               part->mtd.write = efx_mtd->ops->write;
-               part->mtd.sync = efx_mtd_sync;
+               part->mtd._erase = efx_mtd_erase;
+               part->mtd._read = efx_mtd->ops->read;
+               part->mtd._write = efx_mtd->ops->write;
+               part->mtd._sync = efx_mtd_sync;
 
                if (mtd_device_register(&part->mtd, NULL, 0))
                        goto fail;
index d43dc25af82e23a8c6b18f5f3785b8ad4383c8c7..e2e545616b2a58f505f964ab695880c44242f523 100644 (file)
@@ -174,52 +174,52 @@ struct mtd_info {
         * Do not call via these pointers, use corresponding mtd_*()
         * wrappers instead.
         */
-       int (*erase) (struct mtd_info *mtd, struct erase_info *instr);
-       int (*point) (struct mtd_info *mtd, loff_t from, size_t len,
-                     size_t *retlen, void **virt, resource_size_t *phys);
-       void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len);
-       unsigned long (*get_unmapped_area) (struct mtd_info *mtd,
-                                           unsigned long len,
-                                           unsigned long offset,
-                                           unsigned long flags);
-       int (*read) (struct mtd_info *mtd, loff_t from, size_t len,
-                    size_t *retlen, u_char *buf);
-       int (*write) (struct mtd_info *mtd, loff_t to, size_t len,
-                     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);
-       int (*write_oob) (struct mtd_info *mtd, loff_t to,
+       int (*_erase) (struct mtd_info *mtd, struct erase_info *instr);
+       int (*_point) (struct mtd_info *mtd, loff_t from, size_t len,
+                      size_t *retlen, void **virt, resource_size_t *phys);
+       void (*_unpoint) (struct mtd_info *mtd, loff_t from, size_t len);
+       unsigned long (*_get_unmapped_area) (struct mtd_info *mtd,
+                                            unsigned long len,
+                                            unsigned long offset,
+                                            unsigned long flags);
+       int (*_read) (struct mtd_info *mtd, loff_t from, size_t len,
+                     size_t *retlen, u_char *buf);
+       int (*_write) (struct mtd_info *mtd, loff_t to, size_t len,
+                      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);
-       int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf,
-                                  size_t len);
-       int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from,
-                                  size_t len, size_t *retlen, u_char *buf);
-       int (*get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf,
-                                  size_t len);
-       int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from,
-                                  size_t len, size_t *retlen, u_char *buf);
-       int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t to, size_t len,
-                                   size_t *retlen, u_char *buf);
-       int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from,
-                                  size_t len);
-       int (*writev) (struct mtd_info *mtd, const struct kvec *vecs,
+       int (*_write_oob) (struct mtd_info *mtd, loff_t to,
+                          struct mtd_oob_ops *ops);
+       int (*_get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf,
+                                   size_t len);
+       int (*_read_fact_prot_reg) (struct mtd_info *mtd, loff_t from,
+                                   size_t len, size_t *retlen, u_char *buf);
+       int (*_get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf,
+                                   size_t len);
+       int (*_read_user_prot_reg) (struct mtd_info *mtd, loff_t from,
+                                   size_t len, size_t *retlen, u_char *buf);
+       int (*_write_user_prot_reg) (struct mtd_info *mtd, loff_t to,
+                                    size_t len, size_t *retlen, u_char *buf);
+       int (*_lock_user_prot_reg) (struct mtd_info *mtd, loff_t from,
+                                   size_t len);
+       int (*_writev) (struct mtd_info *mtd, const struct kvec *vecs,
                        unsigned long count, loff_t to, size_t *retlen);
-       void (*sync) (struct mtd_info *mtd);
-       int (*lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
-       int (*unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
-       int (*is_locked) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
-       int (*block_isbad) (struct mtd_info *mtd, loff_t ofs);
-       int (*block_markbad) (struct mtd_info *mtd, loff_t ofs);
-       int (*suspend) (struct mtd_info *mtd);
-       void (*resume) (struct mtd_info *mtd);
+       void (*_sync) (struct mtd_info *mtd);
+       int (*_lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
+       int (*_unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
+       int (*_is_locked) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
+       int (*_block_isbad) (struct mtd_info *mtd, loff_t ofs);
+       int (*_block_markbad) (struct mtd_info *mtd, loff_t ofs);
+       int (*_suspend) (struct mtd_info *mtd);
+       void (*_resume) (struct mtd_info *mtd);
        /*
         * If the driver is something smart, like UBI, it may need to maintain
         * its own reference counting. The below functions are only for driver.
         */
-       int (*get_device) (struct mtd_info *mtd);
-       void (*put_device) (struct mtd_info *mtd);
+       int (*_get_device) (struct mtd_info *mtd);
+       void (*_put_device) (struct mtd_info *mtd);
 
        /* Backing device capabilities for this device
         * - provides mmap capabilities
@@ -249,7 +249,7 @@ struct mtd_info {
  */
 static inline int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
 {
-       return mtd->erase(mtd, instr);
+       return mtd->_erase(mtd, instr);
 }
 
 /*
@@ -259,15 +259,15 @@ static inline int mtd_point(struct mtd_info *mtd, loff_t from, size_t len,
                            size_t *retlen, void **virt, resource_size_t *phys)
 {
        *retlen = 0;
-       if (!mtd->point)
+       if (!mtd->_point)
                return -EOPNOTSUPP;
-       return mtd->point(mtd, from, len, retlen, virt, phys);
+       return mtd->_point(mtd, from, len, retlen, virt, phys);
 }
 
 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
 static inline void mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
 {
-       return mtd->unpoint(mtd, from, len);
+       return mtd->_unpoint(mtd, from, len);
 }
 
 /*
@@ -280,24 +280,24 @@ static inline unsigned long mtd_get_unmapped_area(struct mtd_info *mtd,
                                                  unsigned long offset,
                                                  unsigned long flags)
 {
-       if (!mtd->get_unmapped_area)
+       if (!mtd->_get_unmapped_area)
                return -EOPNOTSUPP;
-       return mtd->get_unmapped_area(mtd, len, offset, flags);
+       return mtd->_get_unmapped_area(mtd, len, offset, flags);
 }
 
 static inline int mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
                           size_t *retlen, u_char *buf)
 {
-       return mtd->read(mtd, from, len, retlen, buf);
+       return mtd->_read(mtd, from, len, retlen, buf);
 }
 
 static inline int mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
                            size_t *retlen, const u_char *buf)
 {
        *retlen = 0;
-       if (!mtd->write)
+       if (!mtd->_write)
                return -EROFS;
-       return mtd->write(mtd, to, len, retlen, buf);
+       return mtd->_write(mtd, to, len, retlen, buf);
 }
 
 /*
@@ -311,27 +311,27 @@ static inline int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
                                  size_t *retlen, const u_char *buf)
 {
        *retlen = 0;
-       if (!mtd->panic_write)
+       if (!mtd->_panic_write)
                return -EOPNOTSUPP;
-       return mtd->panic_write(mtd, to, len, retlen, buf);
+       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)
 {
        ops->retlen = ops->oobretlen = 0;
-       if (!mtd->read_oob)
+       if (!mtd->_read_oob)
                return -EOPNOTSUPP;
-       return mtd->read_oob(mtd, from, ops);
+       return mtd->_read_oob(mtd, from, ops);
 }
 
 static inline int mtd_write_oob(struct mtd_info *mtd, loff_t to,
                                struct mtd_oob_ops *ops)
 {
        ops->retlen = ops->oobretlen = 0;
-       if (!mtd->write_oob)
+       if (!mtd->_write_oob)
                return -EOPNOTSUPP;
-       return mtd->write_oob(mtd, to, ops);
+       return mtd->_write_oob(mtd, to, ops);
 }
 
 /*
@@ -342,9 +342,9 @@ static inline int mtd_write_oob(struct mtd_info *mtd, loff_t to,
 static inline int mtd_get_fact_prot_info(struct mtd_info *mtd,
                                         struct otp_info *buf, size_t len)
 {
-       if (!mtd->get_fact_prot_info)
+       if (!mtd->_get_fact_prot_info)
                return -EOPNOTSUPP;
-       return mtd->get_fact_prot_info(mtd, buf, len);
+       return mtd->_get_fact_prot_info(mtd, buf, len);
 }
 
 static inline int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
@@ -352,18 +352,18 @@ static inline int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
                                         u_char *buf)
 {
        *retlen = 0;
-       if (!mtd->read_fact_prot_reg)
+       if (!mtd->_read_fact_prot_reg)
                return -EOPNOTSUPP;
-       return mtd->read_fact_prot_reg(mtd, from, len, retlen, buf);
+       return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf);
 }
 
 static inline int mtd_get_user_prot_info(struct mtd_info *mtd,
                                         struct otp_info *buf,
                                         size_t len)
 {
-       if (!mtd->get_user_prot_info)
+       if (!mtd->_get_user_prot_info)
                return -EOPNOTSUPP;
-       return mtd->get_user_prot_info(mtd, buf, len);
+       return mtd->_get_user_prot_info(mtd, buf, len);
 }
 
 static inline int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
@@ -371,9 +371,9 @@ static inline int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
                                         u_char *buf)
 {
        *retlen = 0;
-       if (!mtd->read_user_prot_reg)
+       if (!mtd->_read_user_prot_reg)
                return -EOPNOTSUPP;
-       return mtd->read_user_prot_reg(mtd, from, len, retlen, buf);
+       return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf);
 }
 
 static inline int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to,
@@ -381,17 +381,17 @@ static inline int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to,
                                          u_char *buf)
 {
        *retlen = 0;
-       if (!mtd->write_user_prot_reg)
+       if (!mtd->_write_user_prot_reg)
                return -EOPNOTSUPP;
-       return mtd->write_user_prot_reg(mtd, to, len, retlen, buf);
+       return mtd->_write_user_prot_reg(mtd, to, len, retlen, buf);
 }
 
 static inline int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
                                         size_t len)
 {
-       if (!mtd->lock_user_prot_reg)
+       if (!mtd->_lock_user_prot_reg)
                return -EOPNOTSUPP;
-       return mtd->lock_user_prot_reg(mtd, from, len);
+       return mtd->_lock_user_prot_reg(mtd, from, len);
 }
 
 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
@@ -399,55 +399,55 @@ int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
 
 static inline void mtd_sync(struct mtd_info *mtd)
 {
-       if (mtd->sync)
-               mtd->sync(mtd);
+       if (mtd->_sync)
+               mtd->_sync(mtd);
 }
 
 /* Chip-supported device locking */
 static inline int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 {
-       if (!mtd->lock)
+       if (!mtd->_lock)
                return -EOPNOTSUPP;
-       return mtd->lock(mtd, ofs, len);
+       return mtd->_lock(mtd, ofs, len);
 }
 
 static inline int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 {
-       if (!mtd->unlock)
+       if (!mtd->_unlock)
                return -EOPNOTSUPP;
-       return mtd->unlock(mtd, ofs, len);
+       return mtd->_unlock(mtd, ofs, len);
 }
 
 static inline int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 {
-       if (!mtd->is_locked)
+       if (!mtd->_is_locked)
                return -EOPNOTSUPP;
-       return mtd->is_locked(mtd, ofs, len);
+       return mtd->_is_locked(mtd, ofs, len);
 }
 
 static inline int mtd_suspend(struct mtd_info *mtd)
 {
-       return mtd->suspend ? mtd->suspend(mtd) : 0;
+       return mtd->_suspend ? mtd->_suspend(mtd) : 0;
 }
 
 static inline void mtd_resume(struct mtd_info *mtd)
 {
-       if (mtd->resume)
-               mtd->resume(mtd);
+       if (mtd->_resume)
+               mtd->_resume(mtd);
 }
 
 static inline int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
 {
-       if (!mtd->block_isbad)
+       if (!mtd->_block_isbad)
                return 0;
-       return mtd->block_isbad(mtd, ofs);
+       return mtd->_block_isbad(mtd, ofs);
 }
 
 static inline int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)
 {
-       if (!mtd->block_markbad)
+       if (!mtd->_block_markbad)
                return -EOPNOTSUPP;
-       return mtd->block_markbad(mtd, ofs);
+       return mtd->_block_markbad(mtd, ofs);
 }
 
 static inline uint32_t mtd_div_by_eb(uint64_t sz, struct mtd_info *mtd)
@@ -482,12 +482,12 @@ static inline uint32_t mtd_mod_by_ws(uint64_t sz, struct mtd_info *mtd)
 
 static inline int mtd_has_oob(const struct mtd_info *mtd)
 {
-       return mtd->read_oob && mtd->write_oob;
+       return mtd->_read_oob && mtd->_write_oob;
 }
 
 static inline int mtd_can_have_bb(const struct mtd_info *mtd)
 {
-       return !!mtd->block_isbad;
+       return !!mtd->_block_isbad;
 }
 
        /* Kernel-side ioctl definitions */