mtd: remove use of __devinit · tjh.dev/kernel@06f2551

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

mtd: remove use of __devinit

CONFIG_HOTPLUG is going away as an option so __devinit is no longer
needed.

Signed-off-by: Bill Pemberton <wfp5p@virginia.edu>
Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

authored by

Bill Pemberton and committed by

Artem Bityutskiy 13 years ago 06f25510 5153b88c

+92 -93

50 changed files

expand all collapse all

drivers

mtd

devices

m25p80.c

mtd_dataflash.c

spear_smi.c

sst25l.c

maps

amd76xrom.c

autcpu12-nvram.c

bfin-async-flash.c

ck804xrom.c

esb2rom.c

gpio-addr-flash.c

ichxrom.c

intel_vr_nor.c

lantiq-flash.c

latch-addr-flash.c

pci.c

physmap_of.c

pismo.c

pxa2xx-flash.c

sa1100-flash.c

scb2_flash.c

sun_uflash.c

vmu-flash.c

nand

ams-delta.c

atmel_nand.c

au1550nd.c

bf5xx_nand.c

cafe_nand.c

denali_dt.c

denali_pci.c

fsl_elbc_nand.c

fsl_ifc_nand.c

fsl_upm.c

fsmc_nand.c

gpio.c

gpmi-nand

gpmi-nand.c

jz4740_nand.c

lpc32xx_mlc.c

lpc32xx_slc.c

mpc5121_nfc.c

mxc_nand.c

ndfc.c

nuc900_nand.c

omap2.c

pasemi_nand.c

plat_nand.c

sh_flctl.c

sharpsl.c

socrates_nand.c

onenand

generic.c

omap2.c

+2 -2

drivers/mtd/devices/m25p80.c

reviewed

··· 755 755 }; 756 756 MODULE_DEVICE_TABLE(spi, m25p_ids); 757 757 758 758 - static const struct spi_device_id *__devinit jedec_probe(struct spi_device *spi) 758 758 + static const struct spi_device_id *jedec_probe(struct spi_device *spi) 759 759 { 760 760 int tmp; 761 761 u8 code = OPCODE_RDID; ··· 800 800 * matches what the READ command supports, at least until this driver 801 801 * understands FAST_READ (for clocks over 25 MHz). 802 802 */ 803 803 - static int __devinit m25p_probe(struct spi_device *spi) 803 803 + static int m25p_probe(struct spi_device *spi) 804 804 { 805 805 const struct spi_device_id *id = spi_get_device_id(spi); 806 806 struct flash_platform_data *data;

+4 -4

drivers/mtd/devices/mtd_dataflash.c

reviewed

··· 618 618 /* 619 619 * Register DataFlash device with MTD subsystem. 620 620 */ 621 621 - static int __devinit 621 621 + static int 622 622 add_dataflash_otp(struct spi_device *spi, char *name, 623 623 int nr_pages, int pagesize, int pageoffset, char revision) 624 624 { ··· 679 679 return err; 680 680 } 681 681 682 682 - static inline int __devinit 682 682 + static inline int 683 683 add_dataflash(struct spi_device *spi, char *name, 684 684 int nr_pages, int pagesize, int pageoffset) 685 685 { ··· 740 740 { "at45db642d", 0x1f2800, 8192, 1024, 10, SUP_POW2PS | IS_POW2PS}, 741 741 }; 742 742 743 743 - static struct flash_info *__devinit jedec_probe(struct spi_device *spi) 743 743 + static struct flash_info *jedec_probe(struct spi_device *spi) 744 744 { 745 745 int tmp; 746 746 uint8_t code = OP_READ_ID; ··· 823 823 * AT45DB0642 64Mbit (8M) xx111xxx (0x3c) 8192 1056 11 824 824 * AT45DB1282 128Mbit (16M) xx0100xx (0x10) 16384 1056 11 825 825 */ 826 826 - static int __devinit dataflash_probe(struct spi_device *spi) 826 826 + static int dataflash_probe(struct spi_device *spi) 827 827 { 828 828 int status; 829 829 struct flash_info *info;

+3 -3

drivers/mtd/devices/spear_smi.c

reviewed

··· 756 756 757 757 758 758 #ifdef CONFIG_OF 759 759 - static int __devinit spear_smi_probe_config_dt(struct platform_device *pdev, 759 759 + static int spear_smi_probe_config_dt(struct platform_device *pdev, 760 760 struct device_node *np) 761 761 { 762 762 struct spear_smi_plat_data *pdata = dev_get_platdata(&pdev->dev); ··· 799 799 return 0; 800 800 } 801 801 #else 802 802 - static int __devinit spear_smi_probe_config_dt(struct platform_device *pdev, 802 802 + static int spear_smi_probe_config_dt(struct platform_device *pdev, 803 803 struct device_node *np) 804 804 { 805 805 return -ENOSYS; ··· 901 901 * and do proper init for any found one. 902 902 * Returns 0 on success, non zero otherwise 903 903 */ 904 904 - static int __devinit spear_smi_probe(struct platform_device *pdev) 904 904 + static int spear_smi_probe(struct platform_device *pdev) 905 905 { 906 906 struct device_node *np = pdev->dev.of_node; 907 907 struct spear_smi_plat_data *pdata = NULL;

+2 -2

drivers/mtd/devices/sst25l.c

reviewed

··· 313 313 return ret; 314 314 } 315 315 316 316 - static struct flash_info *__devinit sst25l_match_device(struct spi_device *spi) 316 316 + static struct flash_info *sst25l_match_device(struct spi_device *spi) 317 317 { 318 318 struct flash_info *flash_info = NULL; 319 319 struct spi_message m; ··· 353 353 return flash_info; 354 354 } 355 355 356 356 - static int __devinit sst25l_probe(struct spi_device *spi) 356 356 + static int sst25l_probe(struct spi_device *spi) 357 357 { 358 358 struct flash_info *flash_info; 359 359 struct sst25l_flash *flash;

+1 -1

drivers/mtd/maps/amd76xrom.c

reviewed

··· 100 100 } 101 101 102 102 103 103 - static int __devinit amd76xrom_init_one (struct pci_dev *pdev, 103 103 + static int amd76xrom_init_one (struct pci_dev *pdev, 104 104 const struct pci_device_id *ent) 105 105 { 106 106 static char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };

+1 -1

drivers/mtd/maps/autcpu12-nvram.c

reviewed

··· 33 33 struct map_info map; 34 34 }; 35 35 36 36 - static int __devinit autcpu12_nvram_probe(struct platform_device *pdev) 36 36 + static int autcpu12_nvram_probe(struct platform_device *pdev) 37 37 { 38 38 map_word tmp, save0, save1; 39 39 struct resource *res;

+1 -1

drivers/mtd/maps/bfin-async-flash.c

reviewed

··· 123 123 124 124 static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", NULL }; 125 125 126 126 - static int __devinit bfin_flash_probe(struct platform_device *pdev) 126 126 + static int bfin_flash_probe(struct platform_device *pdev) 127 127 { 128 128 int ret; 129 129 struct physmap_flash_data *pdata = pdev->dev.platform_data;

+1 -1

drivers/mtd/maps/ck804xrom.c

reviewed

··· 112 112 } 113 113 114 114 115 115 - static int __devinit ck804xrom_init_one (struct pci_dev *pdev, 115 115 + static int ck804xrom_init_one (struct pci_dev *pdev, 116 116 const struct pci_device_id *ent) 117 117 { 118 118 static char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };

+1 -1

drivers/mtd/maps/esb2rom.c

reviewed

··· 144 144 pci_dev_put(window->pdev); 145 145 } 146 146 147 147 - static int __devinit esb2rom_init_one(struct pci_dev *pdev, 147 147 + static int esb2rom_init_one(struct pci_dev *pdev, 148 148 const struct pci_device_id *ent) 149 149 { 150 150 static char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };

+1 -1

drivers/mtd/maps/gpio-addr-flash.c

reviewed

··· 185 185 * ... 186 186 * }; 187 187 */ 188 188 - static int __devinit gpio_flash_probe(struct platform_device *pdev) 188 188 + static int gpio_flash_probe(struct platform_device *pdev) 189 189 { 190 190 size_t i, arr_size; 191 191 struct physmap_flash_data *pdata;

+1 -1

drivers/mtd/maps/ichxrom.c

reviewed

··· 84 84 } 85 85 86 86 87 87 - static int __devinit ichxrom_init_one (struct pci_dev *pdev, 87 87 + static int ichxrom_init_one (struct pci_dev *pdev, 88 88 const struct pci_device_id *ent) 89 89 { 90 90 static char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };

+4 -4

drivers/mtd/maps/intel_vr_nor.c

reviewed

··· 68 68 mtd_device_unregister(p->info); 69 69 } 70 70 71 71 - static int __devinit vr_nor_init_partitions(struct vr_nor_mtd *p) 71 71 + static int vr_nor_init_partitions(struct vr_nor_mtd *p) 72 72 { 73 73 /* register the flash bank */ 74 74 /* partition the flash bank */ ··· 80 80 map_destroy(p->info); 81 81 } 82 82 83 83 - static int __devinit vr_nor_mtd_setup(struct vr_nor_mtd *p) 83 83 + static int vr_nor_mtd_setup(struct vr_nor_mtd *p) 84 84 { 85 85 static const char *probe_types[] = 86 86 { "cfi_probe", "jedec_probe", NULL }; ··· 116 116 * Initialize the map_info structure and map the flash. 117 117 * Returns 0 on success, nonzero otherwise. 118 118 */ 119 119 - static int __devinit vr_nor_init_maps(struct vr_nor_mtd *p) 119 119 + static int vr_nor_init_maps(struct vr_nor_mtd *p) 120 120 { 121 121 unsigned long csr_phys, csr_len; 122 122 unsigned long win_phys, win_len; ··· 189 189 pci_disable_device(dev); 190 190 } 191 191 192 192 - static int __devinit 192 192 + static int 193 193 vr_nor_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) 194 194 { 195 195 struct vr_nor_mtd *p = NULL;

+1 -1

drivers/mtd/maps/lantiq-flash.c

reviewed

··· 109 109 spin_unlock_irqrestore(&ebu_lock, flags); 110 110 } 111 111 112 112 - static int __devinit 112 112 + static int 113 113 ltq_mtd_probe(struct platform_device *pdev) 114 114 { 115 115 struct mtd_part_parser_data ppdata;

+1 -1

drivers/mtd/maps/latch-addr-flash.c

reviewed

··· 125 125 return 0; 126 126 } 127 127 128 128 - static int __devinit latch_addr_flash_probe(struct platform_device *dev) 128 128 + static int latch_addr_flash_probe(struct platform_device *dev) 129 129 { 130 130 struct latch_addr_flash_data *latch_addr_data; 131 131 struct latch_addr_flash_info *info;

+1 -1

drivers/mtd/maps/pci.c

reviewed

··· 253 253 * Generic code follows. 254 254 */ 255 255 256 256 - static int __devinit 256 256 + static int 257 257 mtd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) 258 258 { 259 259 struct mtd_pci_info *info = (struct mtd_pci_info *)id->driver_data;

+4 -4

drivers/mtd/maps/physmap_of.c

reviewed

··· 77 77 /* Helper function to handle probing of the obsolete "direct-mapped" 78 78 * compatible binding, which has an extra "probe-type" property 79 79 * describing the type of flash probe necessary. */ 80 80 - static struct mtd_info * __devinit obsolete_probe(struct platform_device *dev, 80 80 + static struct mtd_info *obsolete_probe(struct platform_device *dev, 81 81 struct map_info *map) 82 82 { 83 83 struct device_node *dp = dev->dev.of_node; ··· 116 116 information. */ 117 117 static const char *part_probe_types_def[] = { "cmdlinepart", "RedBoot", 118 118 "ofpart", "ofoldpart", NULL }; 119 119 - static const char ** __devinit of_get_probes(struct device_node *dp) 119 119 + static const char **of_get_probes(struct device_node *dp) 120 120 { 121 121 const char *cp; 122 122 int cplen; ··· 145 145 return res; 146 146 } 147 147 148 148 - static void __devinit of_free_probes(const char **probes) 148 148 + static void of_free_probes(const char **probes) 149 149 { 150 150 if (probes != part_probe_types_def) 151 151 kfree(probes); 152 152 } 153 153 154 154 static struct of_device_id of_flash_match[]; 155 155 - static int __devinit of_flash_probe(struct platform_device *dev) 155 155 + static int of_flash_probe(struct platform_device *dev) 156 156 { 157 157 const char **part_probe_types; 158 158 const struct of_device_id *match;

+7 -7

drivers/mtd/maps/pismo.c

reviewed

··· 58 58 pismo->vpp(pismo->vpp_data, on); 59 59 } 60 60 61 61 - static unsigned int __devinit pismo_width_to_bytes(unsigned int width) 61 61 + static unsigned int pismo_width_to_bytes(unsigned int width) 62 62 { 63 63 width &= 15; 64 64 if (width > 2) ··· 66 66 return 1 << width; 67 67 } 68 68 69 69 - static int __devinit pismo_eeprom_read(struct i2c_client *client, void *buf, 69 69 + static int pismo_eeprom_read(struct i2c_client *client, void *buf, 70 70 u8 addr, size_t size) 71 71 { 72 72 int ret; ··· 88 88 return ret == ARRAY_SIZE(msg) ? size : -EIO; 89 89 } 90 90 91 91 - static int __devinit pismo_add_device(struct pismo_data *pismo, int i, 91 91 + static int pismo_add_device(struct pismo_data *pismo, int i, 92 92 struct pismo_mem *region, const char *name, void *pdata, size_t psize) 93 93 { 94 94 struct platform_device *dev; ··· 129 129 return ret; 130 130 } 131 131 132 132 - static int __devinit pismo_add_nor(struct pismo_data *pismo, int i, 132 132 + static int pismo_add_nor(struct pismo_data *pismo, int i, 133 133 struct pismo_mem *region) 134 134 { 135 135 struct physmap_flash_data data = { ··· 143 143 &data, sizeof(data)); 144 144 } 145 145 146 146 - static int __devinit pismo_add_sram(struct pismo_data *pismo, int i, 146 146 + static int pismo_add_sram(struct pismo_data *pismo, int i, 147 147 struct pismo_mem *region) 148 148 { 149 149 struct platdata_mtd_ram data = { ··· 154 154 &data, sizeof(data)); 155 155 } 156 156 157 157 - static void __devinit pismo_add_one(struct pismo_data *pismo, int i, 157 157 + static void pismo_add_one(struct pismo_data *pismo, int i, 158 158 const struct pismo_cs_block *cs, phys_addr_t base) 159 159 { 160 160 struct device *dev = &pismo->client->dev; ··· 210 210 return 0; 211 211 } 212 212 213 213 - static int __devinit pismo_probe(struct i2c_client *client, 213 213 + static int pismo_probe(struct i2c_client *client, 214 214 const struct i2c_device_id *id) 215 215 { 216 216 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);

+1 -1

drivers/mtd/maps/pxa2xx-flash.c

reviewed

··· 49 49 static const char *probes[] = { "RedBoot", "cmdlinepart", NULL }; 50 50 51 51 52 52 - static int __devinit pxa2xx_flash_probe(struct platform_device *pdev) 52 52 + static int pxa2xx_flash_probe(struct platform_device *pdev) 53 53 { 54 54 struct flash_platform_data *flash = pdev->dev.platform_data; 55 55 struct pxa2xx_flash_info *info;

+2 -3

drivers/mtd/maps/sa1100-flash.c

reviewed

··· 149 149 plat->exit(); 150 150 } 151 151 152 152 - static struct sa_info *__devinit 153 153 - sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *plat) 152 152 + static struct sa_info *sa1100_setup_mtd(struct platform_device *pdev, struct flash_platform_data *plat) 154 153 { 155 154 struct sa_info *info; 156 155 int nr, size, i, ret = 0; ··· 245 246 246 247 static const char *part_probes[] = { "cmdlinepart", "RedBoot", NULL }; 247 248 248 248 - static int __devinit sa1100_mtd_probe(struct platform_device *pdev) 249 249 + static int sa1100_mtd_probe(struct platform_device *pdev) 249 250 { 250 251 struct flash_platform_data *plat = pdev->dev.platform_data; 251 252 struct sa_info *info;

+2 -2

drivers/mtd/maps/scb2_flash.c

reviewed

··· 69 69 }; 70 70 static int region_fail; 71 71 72 72 - static int __devinit 72 72 + static int 73 73 scb2_fixup_mtd(struct mtd_info *mtd) 74 74 { 75 75 int i; ··· 133 133 /* CSB5's 'Function Control Register' has bits for decoding @ >= 0xffc00000 */ 134 134 #define CSB5_FCR 0x41 135 135 #define CSB5_FCR_DECODE_ALL 0x0e 136 136 - static int __devinit 136 136 + static int 137 137 scb2_flash_probe(struct pci_dev *dev, const struct pci_device_id *ent) 138 138 { 139 139 u8 reg;

+1 -1

drivers/mtd/maps/sun_uflash.c

reviewed

··· 108 108 return 0; 109 109 } 110 110 111 111 - static int __devinit uflash_probe(struct platform_device *op) 111 111 + static int uflash_probe(struct platform_device *op) 112 112 { 113 113 struct device_node *dp = op->dev.of_node; 114 114

+2 -2

drivers/mtd/maps/vmu-flash.c

reviewed

··· 596 596 } 597 597 598 598 /* Handles very basic info about the flash, queries for details */ 599 599 - static int __devinit vmu_connect(struct maple_device *mdev) 599 599 + static int vmu_connect(struct maple_device *mdev) 600 600 { 601 601 unsigned long test_flash_data, basic_flash_data; 602 602 int c, error; ··· 772 772 } 773 773 774 774 775 775 - static int __devinit probe_maple_vmu(struct device *dev) 775 775 + static int probe_maple_vmu(struct device *dev) 776 776 { 777 777 int error; 778 778 struct maple_device *mdev = to_maple_dev(dev);

+1 -1

drivers/mtd/nand/ams-delta.c

reviewed

··· 173 173 /* 174 174 * Main initialization routine 175 175 */ 176 176 - static int __devinit ams_delta_init(struct platform_device *pdev) 176 176 + static int ams_delta_init(struct platform_device *pdev) 177 177 { 178 178 struct nand_chip *this; 179 179 struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

+6 -6

drivers/mtd/nand/atmel_nand.c

reviewed

··· 330 330 * 12-bits 20-bytes 21-bytes 331 331 * 24-bits 39-bytes 42-bytes 332 332 */ 333 333 - static int __devinit pmecc_get_ecc_bytes(int cap, int sector_size) 333 333 + static int pmecc_get_ecc_bytes(int cap, int sector_size) 334 334 { 335 335 int m = 12 + sector_size / 512; 336 336 return (m * cap + 7) / 8; 337 337 } 338 338 339 339 - static void __devinit pmecc_config_ecc_layout(struct nand_ecclayout *layout, 339 339 + static void pmecc_config_ecc_layout(struct nand_ecclayout *layout, 340 340 int oobsize, int ecc_len) 341 341 { 342 342 int i; ··· 352 352 oobsize - ecc_len - layout->oobfree[0].offset; 353 353 } 354 354 355 355 - static void __devinit __iomem *pmecc_get_alpha_to(struct atmel_nand_host *host) 355 355 + static void __iomem *pmecc_get_alpha_to(struct atmel_nand_host *host) 356 356 { 357 357 int table_size; 358 358 ··· 374 374 kfree(host->pmecc_delta); 375 375 } 376 376 377 377 - static int __devinit pmecc_data_alloc(struct atmel_nand_host *host) 377 377 + static int pmecc_data_alloc(struct atmel_nand_host *host) 378 378 { 379 379 const int cap = host->pmecc_corr_cap; 380 380 ··· 1205 1205 } 1206 1206 1207 1207 #if defined(CONFIG_OF) 1208 1208 - static int __devinit atmel_of_init_port(struct atmel_nand_host *host, 1208 1208 + static int atmel_of_init_port(struct atmel_nand_host *host, 1209 1209 struct device_node *np) 1210 1210 { 1211 1211 u32 val, table_offset; ··· 1292 1292 return 0; 1293 1293 } 1294 1294 #else 1295 1295 - static int __devinit atmel_of_init_port(struct atmel_nand_host *host, 1295 1295 + static int atmel_of_init_port(struct atmel_nand_host *host, 1296 1296 struct device_node *np) 1297 1297 { 1298 1298 return -EINVAL;

+2 -2

drivers/mtd/nand/au1550nd.c

reviewed

··· 382 382 while(!this->dev_ready(mtd)); 383 383 } 384 384 385 385 - static int __devinit find_nand_cs(unsigned long nand_base) 385 385 + static int find_nand_cs(unsigned long nand_base) 386 386 { 387 387 void __iomem *base = 388 388 (void __iomem *)KSEG1ADDR(AU1000_STATIC_MEM_PHYS_ADDR); ··· 403 403 return -ENODEV; 404 404 } 405 405 406 406 - static int __devinit au1550nd_probe(struct platform_device *pdev) 406 406 + static int au1550nd_probe(struct platform_device *pdev) 407 407 { 408 408 struct au1550nd_platdata *pd; 409 409 struct au1550nd_ctx *ctx;

+2 -2

drivers/mtd/nand/bf5xx_nand.c

reviewed

··· 658 658 /* 659 659 * Device management interface 660 660 */ 661 661 - static int __devinit bf5xx_nand_add_partition(struct bf5xx_nand_info *info) 661 661 + static int bf5xx_nand_add_partition(struct bf5xx_nand_info *info) 662 662 { 663 663 struct mtd_info *mtd = &info->mtd; 664 664 struct mtd_partition *parts = info->platform->partitions; ··· 725 725 * it can allocate all necessary resources then calls the 726 726 * nand layer to look for devices 727 727 */ 728 728 - static int __devinit bf5xx_nand_probe(struct platform_device *pdev) 728 728 + static int bf5xx_nand_probe(struct platform_device *pdev) 729 729 { 730 730 struct bf5xx_nand_platform *plat = to_nand_plat(pdev); 731 731 struct bf5xx_nand_info *info = NULL;

+4 -4

drivers/mtd/nand/cafe_nand.c

reviewed

··· 585 585 } 586 586 587 587 /* F_2[X]/(X**6+X+1) */ 588 588 - static unsigned short __devinit gf64_mul(u8 a, u8 b) 588 588 + static unsigned short gf64_mul(u8 a, u8 b) 589 589 { 590 590 u8 c; 591 591 unsigned int i; ··· 604 604 } 605 605 606 606 /* F_64[X]/(X**2+X+A**-1) with A the generator of F_64[X] */ 607 607 - static u16 __devinit gf4096_mul(u16 a, u16 b) 607 607 + static u16 gf4096_mul(u16 a, u16 b) 608 608 { 609 609 u8 ah, al, bh, bl, ch, cl; 610 610 ··· 619 619 return (ch << 6) ^ cl; 620 620 } 621 621 622 622 - static int __devinit cafe_mul(int x) 622 622 + static int cafe_mul(int x) 623 623 { 624 624 if (x == 0) 625 625 return 1; 626 626 return gf4096_mul(x, 0xe01); 627 627 } 628 628 629 629 - static int __devinit cafe_nand_probe(struct pci_dev *pdev, 629 629 + static int cafe_nand_probe(struct pci_dev *pdev, 630 630 const struct pci_device_id *ent) 631 631 { 632 632 struct mtd_info *mtd;

+1 -1

drivers/mtd/nand/denali_dt.c

reviewed

··· 57 57 58 58 static u64 denali_dma_mask; 59 59 60 60 - static int __devinit denali_dt_probe(struct platform_device *ofdev) 60 60 + static int denali_dt_probe(struct platform_device *ofdev) 61 61 { 62 62 struct resource *denali_reg, *nand_data; 63 63 struct denali_dt *dt;

+1 -1

drivers/mtd/nand/denali_pci.c

reviewed

··· 130 130 .remove = denali_pci_remove, 131 131 }; 132 132 133 133 - static int __devinit denali_init_pci(void) 133 133 + static int denali_init_pci(void) 134 134 { 135 135 pr_info("Spectra MTD driver built on %s @ %s\n", __DATE__, __TIME__); 136 136 return pci_register_driver(&denali_pci_driver);

+1 -1

drivers/mtd/nand/fsl_elbc_nand.c

reviewed

··· 799 799 800 800 static DEFINE_MUTEX(fsl_elbc_nand_mutex); 801 801 802 802 - static int __devinit fsl_elbc_nand_probe(struct platform_device *pdev) 802 802 + static int fsl_elbc_nand_probe(struct platform_device *pdev) 803 803 { 804 804 struct fsl_lbc_regs __iomem *lbc; 805 805 struct fsl_elbc_mtd *priv;

+1 -1

drivers/mtd/nand/fsl_ifc_nand.c

reviewed

··· 922 922 923 923 static DEFINE_MUTEX(fsl_ifc_nand_mutex); 924 924 925 925 - static int __devinit fsl_ifc_nand_probe(struct platform_device *dev) 925 925 + static int fsl_ifc_nand_probe(struct platform_device *dev) 926 926 { 927 927 struct fsl_ifc_regs __iomem *ifc; 928 928 struct fsl_ifc_mtd *priv;

+2 -2

drivers/mtd/nand/fsl_upm.c

reviewed

··· 152 152 fun_wait_rnb(fun); 153 153 } 154 154 155 155 - static int __devinit fun_chip_init(struct fsl_upm_nand *fun, 155 155 + static int fun_chip_init(struct fsl_upm_nand *fun, 156 156 const struct device_node *upm_np, 157 157 const struct resource *io_res) 158 158 { ··· 201 201 return ret; 202 202 } 203 203 204 204 - static int __devinit fun_probe(struct platform_device *ofdev) 204 204 + static int fun_probe(struct platform_device *ofdev) 205 205 { 206 206 struct fsl_upm_nand *fun; 207 207 struct resource io_res;

+2 -2

drivers/mtd/nand/fsmc_nand.c

reviewed

··· 864 864 } 865 865 866 866 #ifdef CONFIG_OF 867 867 - static int __devinit fsmc_nand_probe_config_dt(struct platform_device *pdev, 867 867 + static int fsmc_nand_probe_config_dt(struct platform_device *pdev, 868 868 struct device_node *np) 869 869 { 870 870 struct fsmc_nand_platform_data *pdata = dev_get_platdata(&pdev->dev); ··· 886 886 return 0; 887 887 } 888 888 #else 889 889 - static int __devinit fsmc_nand_probe_config_dt(struct platform_device *pdev, 889 889 + static int fsmc_nand_probe_config_dt(struct platform_device *pdev, 890 890 struct device_node *np) 891 891 { 892 892 return -ENOSYS;

+1 -1

drivers/mtd/nand/gpio.c

reviewed

··· 282 282 return ptr; 283 283 } 284 284 285 285 - static int __devinit gpio_nand_probe(struct platform_device *dev) 285 285 + static int gpio_nand_probe(struct platform_device *dev) 286 286 { 287 287 struct gpiomtd *gpiomtd; 288 288 struct nand_chip *this;

+8 -8

drivers/mtd/nand/gpmi-nand/gpmi-nand.c

reviewed

··· 319 319 return 0; 320 320 } 321 321 322 322 - static int __devinit 322 322 + static int 323 323 acquire_register_block(struct gpmi_nand_data *this, const char *res_name) 324 324 { 325 325 struct platform_device *pdev = this->pdev; ··· 360 360 res->bch_regs = NULL; 361 361 } 362 362 363 363 - static int __devinit 363 363 + static int 364 364 acquire_bch_irq(struct gpmi_nand_data *this, irq_handler_t irq_h) 365 365 { 366 366 struct platform_device *pdev = this->pdev; ··· 427 427 } 428 428 } 429 429 430 430 - static int __devinit acquire_dma_channels(struct gpmi_nand_data *this) 430 430 + static int acquire_dma_channels(struct gpmi_nand_data *this) 431 431 { 432 432 struct platform_device *pdev = this->pdev; 433 433 struct resource *r_dma; ··· 492 492 "gpmi_apb", "gpmi_bch", "gpmi_bch_apb", "per1_bch", 493 493 }; 494 494 495 495 - static int __devinit gpmi_get_clks(struct gpmi_nand_data *this) 495 495 + static int gpmi_get_clks(struct gpmi_nand_data *this) 496 496 { 497 497 struct resources *r = &this->resources; 498 498 char **extra_clks = NULL; ··· 538 538 return -ENOMEM; 539 539 } 540 540 541 541 - static int __devinit acquire_resources(struct gpmi_nand_data *this) 541 541 + static int acquire_resources(struct gpmi_nand_data *this) 542 542 { 543 543 struct pinctrl *pinctrl; 544 544 int ret; ··· 588 588 release_dma_channels(this); 589 589 } 590 590 591 591 - static int __devinit init_hardware(struct gpmi_nand_data *this) 591 591 + static int init_hardware(struct gpmi_nand_data *this) 592 592 { 593 593 int ret; 594 594 ··· 1542 1542 gpmi_free_dma_buffer(this); 1543 1543 } 1544 1544 1545 1545 - static int __devinit gpmi_nfc_init(struct gpmi_nand_data *this) 1545 1545 + static int gpmi_nfc_init(struct gpmi_nand_data *this) 1546 1546 { 1547 1547 struct mtd_info *mtd = &this->mtd; 1548 1548 struct nand_chip *chip = &this->nand; ··· 1625 1625 }; 1626 1626 MODULE_DEVICE_TABLE(of, gpmi_nand_id_table); 1627 1627 1628 1628 - static int __devinit gpmi_nand_probe(struct platform_device *pdev) 1628 1628 + static int gpmi_nand_probe(struct platform_device *pdev) 1629 1629 { 1630 1630 struct gpmi_nand_data *this; 1631 1631 const struct of_device_id *of_id;

+2 -2

drivers/mtd/nand/jz4740_nand.c

reviewed

··· 322 322 release_mem_region(res->start, resource_size(res)); 323 323 } 324 324 325 325 - static int __devinit jz_nand_detect_bank(struct platform_device *pdev, struct jz_nand *nand, unsigned char bank, size_t chipnr, uint8_t *nand_maf_id, uint8_t *nand_dev_id) { 325 325 + static int jz_nand_detect_bank(struct platform_device *pdev, struct jz_nand *nand, unsigned char bank, size_t chipnr, uint8_t *nand_maf_id, uint8_t *nand_dev_id) { 326 326 int ret; 327 327 int gpio; 328 328 char gpio_name[9]; ··· 400 400 return ret; 401 401 } 402 402 403 403 - static int __devinit jz_nand_probe(struct platform_device *pdev) 403 403 + static int jz_nand_probe(struct platform_device *pdev) 404 404 { 405 405 int ret; 406 406 struct jz_nand *nand;

+1 -1

drivers/mtd/nand/lpc32xx_mlc.c

reviewed

··· 655 655 /* 656 656 * Probe for NAND controller 657 657 */ 658 658 - static int __devinit lpc32xx_nand_probe(struct platform_device *pdev) 658 658 + static int lpc32xx_nand_probe(struct platform_device *pdev) 659 659 { 660 660 struct lpc32xx_nand_host *host; 661 661 struct mtd_info *mtd;

+1 -1

drivers/mtd/nand/lpc32xx_slc.c

reviewed

··· 755 755 /* 756 756 * Probe for NAND controller 757 757 */ 758 758 - static int __devinit lpc32xx_nand_probe(struct platform_device *pdev) 758 758 + static int lpc32xx_nand_probe(struct platform_device *pdev) 759 759 { 760 760 struct lpc32xx_nand_host *host; 761 761 struct mtd_info *mtd;

+1 -1

drivers/mtd/nand/mpc5121_nfc.c

reviewed

··· 626 626 iounmap(prv->csreg); 627 627 } 628 628 629 629 - static int __devinit mpc5121_nfc_probe(struct platform_device *op) 629 629 + static int mpc5121_nfc_probe(struct platform_device *op) 630 630 { 631 631 struct device_node *rootnode, *dn = op->dev.of_node; 632 632 struct device *dev = &op->dev;

+1 -1

drivers/mtd/nand/mxc_nand.c

reviewed

··· 1363 1363 return 0; 1364 1364 } 1365 1365 1366 1366 - static int __devinit mxcnd_probe(struct platform_device *pdev) 1366 1366 + static int mxcnd_probe(struct platform_device *pdev) 1367 1367 { 1368 1368 struct nand_chip *this; 1369 1369 struct mtd_info *mtd;

+1 -1

drivers/mtd/nand/ndfc.c

reviewed

··· 197 197 return ret; 198 198 } 199 199 200 200 - static int __devinit ndfc_probe(struct platform_device *ofdev) 200 200 + static int ndfc_probe(struct platform_device *ofdev) 201 201 { 202 202 struct ndfc_controller *ndfc; 203 203 const __be32 *reg;

+1 -1

drivers/mtd/nand/nuc900_nand.c

reviewed

··· 246 246 spin_unlock(&nand->lock); 247 247 } 248 248 249 249 - static int __devinit nuc900_nand_probe(struct platform_device *pdev) 249 249 + static int nuc900_nand_probe(struct platform_device *pdev) 250 250 { 251 251 struct nuc900_nand *nuc900_nand; 252 252 struct nand_chip *chip;

+1 -1

drivers/mtd/nand/omap2.c

reviewed

··· 1239 1239 } 1240 1240 #endif /* CONFIG_MTD_NAND_OMAP_BCH */ 1241 1241 1242 1242 - static int __devinit omap_nand_probe(struct platform_device *pdev) 1242 1242 + static int omap_nand_probe(struct platform_device *pdev) 1243 1243 { 1244 1244 struct omap_nand_info *info; 1245 1245 struct omap_nand_platform_data *pdata;

+1 -1

drivers/mtd/nand/pasemi_nand.c

reviewed

··· 89 89 return !!(inl(lpcctl) & LBICTRL_LPCCTL_NR); 90 90 } 91 91 92 92 - static int __devinit pasemi_nand_probe(struct platform_device *ofdev) 92 92 + static int pasemi_nand_probe(struct platform_device *ofdev) 93 93 { 94 94 struct pci_dev *pdev; 95 95 struct device_node *np = ofdev->dev.of_node;

+1 -1

drivers/mtd/nand/plat_nand.c

reviewed

··· 28 28 /* 29 29 * Probe for the NAND device. 30 30 */ 31 31 - static int __devinit plat_nand_probe(struct platform_device *pdev) 31 31 + static int plat_nand_probe(struct platform_device *pdev) 32 32 { 33 33 struct platform_nand_data *pdata = pdev->dev.platform_data; 34 34 struct mtd_part_parser_data ppdata;

+1 -1

drivers/mtd/nand/sh_flctl.c

reviewed

··· 1086 1086 } 1087 1087 #endif /* CONFIG_OF */ 1088 1088 1089 1089 - static int __devinit flctl_probe(struct platform_device *pdev) 1089 1089 + static int flctl_probe(struct platform_device *pdev) 1090 1090 { 1091 1091 struct resource *res; 1092 1092 struct sh_flctl *flctl;

+1 -1

drivers/mtd/nand/sharpsl.c

reviewed

··· 106 106 /* 107 107 * Main initialization routine 108 108 */ 109 109 - static int __devinit sharpsl_nand_probe(struct platform_device *pdev) 109 109 + static int sharpsl_nand_probe(struct platform_device *pdev) 110 110 { 111 111 struct nand_chip *this; 112 112 struct resource *r;

+1 -1

drivers/mtd/nand/socrates_nand.c

reviewed

··· 140 140 /* 141 141 * Probe for the NAND device. 142 142 */ 143 143 - static int __devinit socrates_nand_probe(struct platform_device *ofdev) 143 143 + static int socrates_nand_probe(struct platform_device *ofdev) 144 144 { 145 145 struct socrates_nand_host *host; 146 146 struct mtd_info *mtd;

+1 -1

drivers/mtd/onenand/generic.c

reviewed

··· 35 35 struct onenand_chip onenand; 36 36 }; 37 37 38 38 - static int __devinit generic_onenand_probe(struct platform_device *pdev) 38 38 + static int generic_onenand_probe(struct platform_device *pdev) 39 39 { 40 40 struct onenand_info *info; 41 41 struct onenand_platform_data *pdata = pdev->dev.platform_data;

+1 -1

drivers/mtd/onenand/omap2.c

reviewed

··· 619 619 return ret; 620 620 } 621 621 622 622 - static int __devinit omap2_onenand_probe(struct platform_device *pdev) 622 622 + static int omap2_onenand_probe(struct platform_device *pdev) 623 623 { 624 624 struct omap_onenand_platform_data *pdata; 625 625 struct omap2_onenand *c;