+33

Documentation/devicetree/bindings/mtd/fsmc-nand.txt

reviewed

··· 1 1 + * FSMC NAND 2 2 + 3 3 + Required properties: 4 4 + - compatible : "st,spear600-fsmc-nand" 5 5 + - reg : Address range of the mtd chip 6 6 + - reg-names: Should contain the reg names "fsmc_regs" and "nand_data" 7 7 + - st,ale-off : Chip specific offset to ALE 8 8 + - st,cle-off : Chip specific offset to CLE 9 9 + 10 10 + Optional properties: 11 11 + - bank-width : Width (in bytes) of the device. If not present, the width 12 12 + defaults to 1 byte 13 13 + - nand-skip-bbtscan: Indicates the the BBT scanning should be skipped 14 14 + 15 15 + Example: 16 16 + 17 17 + fsmc: flash@d1800000 { 18 18 + compatible = "st,spear600-fsmc-nand"; 19 19 + #address-cells = <1>; 20 20 + #size-cells = <1>; 21 21 + reg = <0xd1800000 0x1000 /* FSMC Register */ 22 22 + 0xd2000000 0x4000>; /* NAND Base */ 23 23 + reg-names = "fsmc_regs", "nand_data"; 24 24 + st,ale-off = <0x20000>; 25 25 + st,cle-off = <0x10000>; 26 26 + 27 27 + bank-width = <1>; 28 28 + nand-skip-bbtscan; 29 29 + 30 30 + partition@0 { 31 31 + ... 32 32 + }; 33 33 + };

+31

Documentation/devicetree/bindings/mtd/spear_smi.txt

reviewed

··· 1 1 + * SPEAr SMI 2 2 + 3 3 + Required properties: 4 4 + - compatible : "st,spear600-smi" 5 5 + - reg : Address range of the mtd chip 6 6 + - #address-cells, #size-cells : Must be present if the device has sub-nodes 7 7 + representing partitions. 8 8 + - interrupt-parent: Should be the phandle for the interrupt controller 9 9 + that services interrupts for this device 10 10 + - interrupts: Should contain the STMMAC interrupts 11 11 + - clock-rate : Functional clock rate of SMI in Hz 12 12 + 13 13 + Optional properties: 14 14 + - st,smi-fast-mode : Flash supports read in fast mode 15 15 + 16 16 + Example: 17 17 + 18 18 + smi: flash@fc000000 { 19 19 + compatible = "st,spear600-smi"; 20 20 + #address-cells = <1>; 21 21 + #size-cells = <1>; 22 22 + reg = <0xfc000000 0x1000>; 23 23 + interrupt-parent = <&vic1>; 24 24 + interrupts = <12>; 25 25 + clock-rate = <50000000>; /* 50MHz */ 26 26 + 27 27 + flash@f8000000 { 28 28 + st,smi-fast-mode; 29 29 + ... 30 30 + }; 31 31 + };

arch/arm/mach-mxs/include/mach/dma.h include/linux/fsl/mxs-dma.h

reviewed

+6 -14

arch/arm/mach-omap1/flash.c

reviewed

··· 17 17 18 18 void omap1_set_vpp(struct platform_device *pdev, int enable) 19 19 { 20 20 - static int count; 21 20 u32 l; 22 21 23 23 - if (enable) { 24 24 - if (count++ == 0) { 25 25 - l = omap_readl(EMIFS_CONFIG); 26 26 - l |= OMAP_EMIFS_CONFIG_WP; 27 27 - omap_writel(l, EMIFS_CONFIG); 28 28 - } 29 29 - } else { 30 30 - if (count && (--count == 0)) { 31 31 - l = omap_readl(EMIFS_CONFIG); 32 32 - l &= ~OMAP_EMIFS_CONFIG_WP; 33 33 - omap_writel(l, EMIFS_CONFIG); 34 34 - } 35 35 - } 22 22 + l = omap_readl(EMIFS_CONFIG); 23 23 + if (enable) 24 24 + l |= OMAP_EMIFS_CONFIG_WP; 25 25 + else 26 26 + l &= ~OMAP_EMIFS_CONFIG_WP; 27 27 + omap_writel(l, EMIFS_CONFIG); 36 28 }

-3

arch/arm/mach-s3c24xx/simtec-nor.c

reviewed

··· 35 35 static void simtec_nor_vpp(struct platform_device *pdev, int vpp) 36 36 { 37 37 unsigned int val; 38 38 - unsigned long flags; 39 38 40 40 - local_irq_save(flags); 41 39 val = __raw_readb(BAST_VA_CTRL3); 42 40 43 41 printk(KERN_DEBUG "%s(%d)\n", __func__, vpp); ··· 46 48 val &= ~BAST_CPLD_CTRL3_ROMWEN; 47 49 48 50 __raw_writeb(val, BAST_VA_CTRL3); 49 49 - local_irq_restore(flags); 50 51 } 51 52 52 53 static struct physmap_flash_data simtec_nor_pdata = {

+71

arch/arm/mach-shmobile/board-mackerel.c

reviewed

··· 39 39 #include <linux/mtd/mtd.h> 40 40 #include <linux/mtd/partitions.h> 41 41 #include <linux/mtd/physmap.h> 42 42 + #include <linux/mtd/sh_flctl.h> 42 43 #include <linux/pm_clock.h> 43 44 #include <linux/smsc911x.h> 44 45 #include <linux/sh_intc.h> ··· 957 956 }, 958 957 }; 959 958 959 959 + /* FLCTL */ 960 960 + static struct mtd_partition nand_partition_info[] = { 961 961 + { 962 962 + .name = "system", 963 963 + .offset = 0, 964 964 + .size = 128 * 1024 * 1024, 965 965 + }, 966 966 + { 967 967 + .name = "userdata", 968 968 + .offset = MTDPART_OFS_APPEND, 969 969 + .size = 256 * 1024 * 1024, 970 970 + }, 971 971 + { 972 972 + .name = "cache", 973 973 + .offset = MTDPART_OFS_APPEND, 974 974 + .size = 128 * 1024 * 1024, 975 975 + }, 976 976 + }; 977 977 + 978 978 + static struct resource nand_flash_resources[] = { 979 979 + [0] = { 980 980 + .start = 0xe6a30000, 981 981 + .end = 0xe6a3009b, 982 982 + .flags = IORESOURCE_MEM, 983 983 + } 984 984 + }; 985 985 + 986 986 + static struct sh_flctl_platform_data nand_flash_data = { 987 987 + .parts = nand_partition_info, 988 988 + .nr_parts = ARRAY_SIZE(nand_partition_info), 989 989 + .flcmncr_val = CLK_16B_12L_4H | TYPESEL_SET 990 990 + | SHBUSSEL | SEL_16BIT | SNAND_E, 991 991 + .use_holden = 1, 992 992 + }; 993 993 + 994 994 + static struct platform_device nand_flash_device = { 995 995 + .name = "sh_flctl", 996 996 + .resource = nand_flash_resources, 997 997 + .num_resources = ARRAY_SIZE(nand_flash_resources), 998 998 + .dev = { 999 999 + .platform_data = &nand_flash_data, 1000 1000 + }, 1001 1001 + }; 1002 1002 + 960 1003 /* 961 1004 * The card detect pin of the top SD/MMC slot (CN7) is active low and is 962 1005 * connected to GPIO A22 of SH7372 (GPIO_PORT41). ··· 1304 1259 &fsi_device, 1305 1260 &fsi_ak4643_device, 1306 1261 &fsi_hdmi_device, 1262 1262 + &nand_flash_device, 1307 1263 &sdhi0_device, 1308 1264 #if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE) 1309 1265 &sdhi1_device, ··· 1534 1488 gpio_request(GPIO_FN_MMCCMD0, NULL); 1535 1489 gpio_request(GPIO_FN_MMCCLK0, NULL); 1536 1490 1491 1491 + /* FLCTL */ 1492 1492 + gpio_request(GPIO_FN_D0_NAF0, NULL); 1493 1493 + gpio_request(GPIO_FN_D1_NAF1, NULL); 1494 1494 + gpio_request(GPIO_FN_D2_NAF2, NULL); 1495 1495 + gpio_request(GPIO_FN_D3_NAF3, NULL); 1496 1496 + gpio_request(GPIO_FN_D4_NAF4, NULL); 1497 1497 + gpio_request(GPIO_FN_D5_NAF5, NULL); 1498 1498 + gpio_request(GPIO_FN_D6_NAF6, NULL); 1499 1499 + gpio_request(GPIO_FN_D7_NAF7, NULL); 1500 1500 + gpio_request(GPIO_FN_D8_NAF8, NULL); 1501 1501 + gpio_request(GPIO_FN_D9_NAF9, NULL); 1502 1502 + gpio_request(GPIO_FN_D10_NAF10, NULL); 1503 1503 + gpio_request(GPIO_FN_D11_NAF11, NULL); 1504 1504 + gpio_request(GPIO_FN_D12_NAF12, NULL); 1505 1505 + gpio_request(GPIO_FN_D13_NAF13, NULL); 1506 1506 + gpio_request(GPIO_FN_D14_NAF14, NULL); 1507 1507 + gpio_request(GPIO_FN_D15_NAF15, NULL); 1508 1508 + gpio_request(GPIO_FN_FCE0, NULL); 1509 1509 + gpio_request(GPIO_FN_WE0_FWE, NULL); 1510 1510 + gpio_request(GPIO_FN_FRB, NULL); 1511 1511 + gpio_request(GPIO_FN_A4_FOE, NULL); 1512 1512 + gpio_request(GPIO_FN_A5_FCDE, NULL); 1513 1513 + gpio_request(GPIO_FN_RD_FSC, NULL); 1514 1514 + 1537 1515 /* enable GPS module (GT-720F) */ 1538 1516 gpio_request(GPIO_FN_SCIFA2_TXD1, NULL); 1539 1517 gpio_request(GPIO_FN_SCIFA2_RXD1, NULL); ··· 1602 1532 sh7372_add_device_to_domain(&sh7372_a4mp, &fsi_device); 1603 1533 sh7372_add_device_to_domain(&sh7372_a3sp, &usbhs0_device); 1604 1534 sh7372_add_device_to_domain(&sh7372_a3sp, &usbhs1_device); 1535 1535 + sh7372_add_device_to_domain(&sh7372_a3sp, &nand_flash_device); 1605 1536 sh7372_add_device_to_domain(&sh7372_a3sp, &sh_mmcif_device); 1606 1537 sh7372_add_device_to_domain(&sh7372_a3sp, &sdhi0_device); 1607 1538 #if !defined(CONFIG_MMC_SH_MMCIF) && !defined(CONFIG_MMC_SH_MMCIF_MODULE)

+3 -1

arch/arm/mach-shmobile/clock-sh7372.c

reviewed

··· 511 511 MSTP223, 512 512 MSTP218, MSTP217, MSTP216, MSTP214, MSTP208, MSTP207, 513 513 MSTP206, MSTP205, MSTP204, MSTP203, MSTP202, MSTP201, MSTP200, 514 514 - MSTP328, MSTP323, MSTP322, MSTP314, MSTP313, MSTP312, 514 514 + MSTP328, MSTP323, MSTP322, MSTP315, MSTP314, MSTP313, MSTP312, 515 515 MSTP423, MSTP415, MSTP413, MSTP411, MSTP410, MSTP407, MSTP406, 516 516 MSTP405, MSTP404, MSTP403, MSTP400, 517 517 MSTP_NR }; ··· 553 553 [MSTP328] = MSTP(&div6_clks[DIV6_SPU], SMSTPCR3, 28, 0), /* FSI2 */ 554 554 [MSTP323] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR3, 23, 0), /* IIC1 */ 555 555 [MSTP322] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR3, 22, 0), /* USB0 */ 556 556 + [MSTP315] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 15, 0), /* FLCTL*/ 556 557 [MSTP314] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 14, 0), /* SDHI0 */ 557 558 [MSTP313] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 13, 0), /* SDHI1 */ 558 559 [MSTP312] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 12, 0), /* MMC */ ··· 654 653 CLKDEV_DEV_ID("r8a66597_hcd.0", &mstp_clks[MSTP322]), /* USB0 */ 655 654 CLKDEV_DEV_ID("r8a66597_udc.0", &mstp_clks[MSTP322]), /* USB0 */ 656 655 CLKDEV_DEV_ID("renesas_usbhs.0", &mstp_clks[MSTP322]), /* USB0 */ 656 656 + CLKDEV_DEV_ID("sh_flctl.0", &mstp_clks[MSTP315]), /* FLCTL */ 657 657 CLKDEV_DEV_ID("sh_mobile_sdhi.0", &mstp_clks[MSTP314]), /* SDHI0 */ 658 658 CLKDEV_DEV_ID("sh_mobile_sdhi.1", &mstp_clks[MSTP313]), /* SDHI1 */ 659 659 CLKDEV_DEV_ID("sh_mmcif.0", &mstp_clks[MSTP312]), /* MMC */

+2

arch/arm/mach-u300/core.c

reviewed

··· 1544 1544 .nr_partitions = ARRAY_SIZE(u300_partitions), 1545 1545 .options = NAND_SKIP_BBTSCAN, 1546 1546 .width = FSMC_NAND_BW8, 1547 1547 + .ale_off = PLAT_NAND_ALE, 1548 1548 + .cle_off = PLAT_NAND_CLE, 1547 1549 }; 1548 1550 1549 1551 static struct platform_device nand_device = {

+5

arch/arm/mach-u300/include/mach/u300-regs.h

reviewed

··· 24 24 /* NFIF */ 25 25 #define U300_NAND_IF_PHYS_BASE 0x9f800000 26 26 27 27 + /* ALE, CLE offset for FSMC NAND */ 28 28 + #define PLAT_NAND_CLE (1 << 16) 29 29 + #define PLAT_NAND_ALE (1 << 17) 30 30 + 31 31 + 27 32 /* AHB Peripherals */ 28 33 #define U300_AHB_PER_PHYS_BASE 0xa0000000 29 34 #define U300_AHB_PER_VIRT_BASE 0xff010000

+1 -1

arch/mips/cavium-octeon/flash_setup.c

reviewed

··· 60 60 if (mymtd) { 61 61 mymtd->owner = THIS_MODULE; 62 62 mtd_device_parse_register(mymtd, part_probe_types, 63 63 - 0, NULL, 0); 63 63 + NULL, NULL, 0); 64 64 } else { 65 65 pr_err("Failed to register MTD device for flash\n"); 66 66 }

+29 -5

drivers/dma/mxs-dma.c

reviewed

··· 22 22 #include <linux/platform_device.h> 23 23 #include <linux/dmaengine.h> 24 24 #include <linux/delay.h> 25 25 + #include <linux/fsl/mxs-dma.h> 25 26 26 27 #include <asm/irq.h> 27 28 #include <mach/mxs.h> 28 28 - #include <mach/dma.h> 29 29 #include <mach/common.h> 30 30 31 31 #include "dmaengine.h" ··· 337 337 clk_disable_unprepare(mxs_dma->clk); 338 338 } 339 339 340 340 + /* 341 341 + * How to use the flags for ->device_prep_slave_sg() : 342 342 + * [1] If there is only one DMA command in the DMA chain, the code should be: 343 343 + * ...... 344 344 + * ->device_prep_slave_sg(DMA_CTRL_ACK); 345 345 + * ...... 346 346 + * [2] If there are two DMA commands in the DMA chain, the code should be 347 347 + * ...... 348 348 + * ->device_prep_slave_sg(0); 349 349 + * ...... 350 350 + * ->device_prep_slave_sg(DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 351 351 + * ...... 352 352 + * [3] If there are more than two DMA commands in the DMA chain, the code 353 353 + * should be: 354 354 + * ...... 355 355 + * ->device_prep_slave_sg(0); // First 356 356 + * ...... 357 357 + * ->device_prep_slave_sg(DMA_PREP_INTERRUPT [| DMA_CTRL_ACK]); 358 358 + * ...... 359 359 + * ->device_prep_slave_sg(DMA_PREP_INTERRUPT | DMA_CTRL_ACK); // Last 360 360 + * ...... 361 361 + */ 340 362 static struct dma_async_tx_descriptor *mxs_dma_prep_slave_sg( 341 363 struct dma_chan *chan, struct scatterlist *sgl, 342 364 unsigned int sg_len, enum dma_transfer_direction direction, 343 343 - unsigned long append, void *context) 365 365 + unsigned long flags, void *context) 344 366 { 345 367 struct mxs_dma_chan *mxs_chan = to_mxs_dma_chan(chan); 346 368 struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma; ··· 370 348 struct scatterlist *sg; 371 349 int i, j; 372 350 u32 *pio; 351 351 + bool append = flags & DMA_PREP_INTERRUPT; 373 352 int idx = append ? mxs_chan->desc_count : 0; 374 353 375 354 if (mxs_chan->status == DMA_IN_PROGRESS && !append) ··· 397 374 ccw->bits |= CCW_CHAIN; 398 375 ccw->bits &= ~CCW_IRQ; 399 376 ccw->bits &= ~CCW_DEC_SEM; 400 400 - ccw->bits &= ~CCW_WAIT4END; 401 377 } else { 402 378 idx = 0; 403 379 } ··· 411 389 ccw->bits = 0; 412 390 ccw->bits |= CCW_IRQ; 413 391 ccw->bits |= CCW_DEC_SEM; 414 414 - ccw->bits |= CCW_WAIT4END; 392 392 + if (flags & DMA_CTRL_ACK) 393 393 + ccw->bits |= CCW_WAIT4END; 415 394 ccw->bits |= CCW_HALT_ON_TERM; 416 395 ccw->bits |= CCW_TERM_FLUSH; 417 396 ccw->bits |= BF_CCW(sg_len, PIO_NUM); ··· 443 420 ccw->bits &= ~CCW_CHAIN; 444 421 ccw->bits |= CCW_IRQ; 445 422 ccw->bits |= CCW_DEC_SEM; 446 446 - ccw->bits |= CCW_WAIT4END; 423 423 + if (flags & DMA_CTRL_ACK) 424 424 + ccw->bits |= CCW_WAIT4END; 447 425 } 448 426 } 449 427 }

+6 -6

drivers/mmc/host/mxs-mmc.c

reviewed

··· 38 38 #include <linux/gpio.h> 39 39 #include <linux/regulator/consumer.h> 40 40 #include <linux/module.h> 41 41 + #include <linux/fsl/mxs-dma.h> 41 42 42 43 #include <mach/mxs.h> 43 44 #include <mach/common.h> 44 44 - #include <mach/dma.h> 45 45 #include <mach/mmc.h> 46 46 47 47 #define DRIVER_NAME "mxs-mmc" ··· 305 305 } 306 306 307 307 static struct dma_async_tx_descriptor *mxs_mmc_prep_dma( 308 308 - struct mxs_mmc_host *host, unsigned int append) 308 308 + struct mxs_mmc_host *host, unsigned long flags) 309 309 { 310 310 struct dma_async_tx_descriptor *desc; 311 311 struct mmc_data *data = host->data; ··· 325 325 } 326 326 327 327 desc = dmaengine_prep_slave_sg(host->dmach, 328 328 - sgl, sg_len, host->slave_dirn, append); 328 328 + sgl, sg_len, host->slave_dirn, flags); 329 329 if (desc) { 330 330 desc->callback = mxs_mmc_dma_irq_callback; 331 331 desc->callback_param = host; ··· 358 358 host->ssp_pio_words[2] = cmd1; 359 359 host->dma_dir = DMA_NONE; 360 360 host->slave_dirn = DMA_TRANS_NONE; 361 361 - desc = mxs_mmc_prep_dma(host, 0); 361 361 + desc = mxs_mmc_prep_dma(host, DMA_CTRL_ACK); 362 362 if (!desc) 363 363 goto out; 364 364 ··· 398 398 host->ssp_pio_words[2] = cmd1; 399 399 host->dma_dir = DMA_NONE; 400 400 host->slave_dirn = DMA_TRANS_NONE; 401 401 - desc = mxs_mmc_prep_dma(host, 0); 401 401 + desc = mxs_mmc_prep_dma(host, DMA_CTRL_ACK); 402 402 if (!desc) 403 403 goto out; 404 404 ··· 526 526 host->data = data; 527 527 host->dma_dir = dma_data_dir; 528 528 host->slave_dirn = slave_dirn; 529 529 - desc = mxs_mmc_prep_dma(host, 1); 529 529 + desc = mxs_mmc_prep_dma(host, DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 530 530 if (!desc) 531 531 goto out; 532 532

-3

drivers/mtd/Kconfig

reviewed

··· 304 304 buffer in a flash partition where it can be read back at some 305 305 later point. 306 306 307 307 - To use, add console=ttyMTDx to the kernel command line, 308 308 - where x is the MTD device number to use. 309 309 - 310 307 config MTD_SWAP 311 308 tristate "Swap on MTD device support" 312 309 depends on MTD && SWAP

+41 -42

drivers/mtd/chips/cfi_cmdset_0001.c

reviewed

··· 87 87 88 88 static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len, 89 89 size_t *retlen, void **virt, resource_size_t *phys); 90 90 - static void cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len); 90 90 + static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len); 91 91 92 92 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode); 93 93 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode); ··· 262 262 static void fixup_use_point(struct mtd_info *mtd) 263 263 { 264 264 struct map_info *map = mtd->priv; 265 265 - if (!mtd->point && map_is_linear(map)) { 266 266 - mtd->point = cfi_intelext_point; 267 267 - mtd->unpoint = cfi_intelext_unpoint; 265 265 + if (!mtd->_point && map_is_linear(map)) { 266 266 + mtd->_point = cfi_intelext_point; 267 267 + mtd->_unpoint = cfi_intelext_unpoint; 268 268 } 269 269 } 270 270 ··· 274 274 struct cfi_private *cfi = map->fldrv_priv; 275 275 if (cfi->cfiq->BufWriteTimeoutTyp) { 276 276 printk(KERN_INFO "Using buffer write method\n" ); 277 277 - mtd->write = cfi_intelext_write_buffers; 278 278 - mtd->writev = cfi_intelext_writev; 277 277 + mtd->_write = cfi_intelext_write_buffers; 278 278 + mtd->_writev = cfi_intelext_writev; 279 279 } 280 280 } 281 281 ··· 443 443 mtd->type = MTD_NORFLASH; 444 444 445 445 /* Fill in the default mtd operations */ 446 446 - mtd->erase = cfi_intelext_erase_varsize; 447 447 - mtd->read = cfi_intelext_read; 448 448 - mtd->write = cfi_intelext_write_words; 449 449 - mtd->sync = cfi_intelext_sync; 450 450 - mtd->lock = cfi_intelext_lock; 451 451 - mtd->unlock = cfi_intelext_unlock; 452 452 - mtd->is_locked = cfi_intelext_is_locked; 453 453 - mtd->suspend = cfi_intelext_suspend; 454 454 - mtd->resume = cfi_intelext_resume; 446 446 + mtd->_erase = cfi_intelext_erase_varsize; 447 447 + mtd->_read = cfi_intelext_read; 448 448 + mtd->_write = cfi_intelext_write_words; 449 449 + mtd->_sync = cfi_intelext_sync; 450 450 + mtd->_lock = cfi_intelext_lock; 451 451 + mtd->_unlock = cfi_intelext_unlock; 452 452 + mtd->_is_locked = cfi_intelext_is_locked; 453 453 + mtd->_suspend = cfi_intelext_suspend; 454 454 + mtd->_resume = cfi_intelext_resume; 455 455 mtd->flags = MTD_CAP_NORFLASH; 456 456 mtd->name = map->name; 457 457 mtd->writesize = 1; ··· 600 600 } 601 601 602 602 #ifdef CONFIG_MTD_OTP 603 603 - mtd->read_fact_prot_reg = cfi_intelext_read_fact_prot_reg; 604 604 - mtd->read_user_prot_reg = cfi_intelext_read_user_prot_reg; 605 605 - mtd->write_user_prot_reg = cfi_intelext_write_user_prot_reg; 606 606 - mtd->lock_user_prot_reg = cfi_intelext_lock_user_prot_reg; 607 607 - mtd->get_fact_prot_info = cfi_intelext_get_fact_prot_info; 608 608 - mtd->get_user_prot_info = cfi_intelext_get_user_prot_info; 603 603 + mtd->_read_fact_prot_reg = cfi_intelext_read_fact_prot_reg; 604 604 + mtd->_read_user_prot_reg = cfi_intelext_read_user_prot_reg; 605 605 + mtd->_write_user_prot_reg = cfi_intelext_write_user_prot_reg; 606 606 + mtd->_lock_user_prot_reg = cfi_intelext_lock_user_prot_reg; 607 607 + mtd->_get_fact_prot_info = cfi_intelext_get_fact_prot_info; 608 608 + mtd->_get_user_prot_info = cfi_intelext_get_user_prot_info; 609 609 #endif 610 610 611 611 /* This function has the potential to distort the reality ··· 1017 1017 case FL_READY: 1018 1018 case FL_STATUS: 1019 1019 case FL_JEDEC_QUERY: 1020 1020 - /* We should really make set_vpp() count, rather than doing this */ 1021 1021 - DISABLE_VPP(map); 1022 1020 break; 1023 1021 default: 1024 1022 printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate); ··· 1322 1324 int chipnum; 1323 1325 int ret = 0; 1324 1326 1325 1325 - if (!map->virt || (from + len > mtd->size)) 1327 1327 + if (!map->virt) 1326 1328 return -EINVAL; 1327 1329 1328 1330 /* Now lock the chip(s) to POINT state */ ··· 1332 1334 ofs = from - (chipnum << cfi->chipshift); 1333 1335 1334 1336 *virt = map->virt + cfi->chips[chipnum].start + ofs; 1335 1335 - *retlen = 0; 1336 1337 if (phys) 1337 1338 *phys = map->phys + cfi->chips[chipnum].start + ofs; 1338 1339 ··· 1366 1369 return 0; 1367 1370 } 1368 1371 1369 1369 - static void cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 1372 1372 + static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 1370 1373 { 1371 1374 struct map_info *map = mtd->priv; 1372 1375 struct cfi_private *cfi = map->fldrv_priv; 1373 1376 unsigned long ofs; 1374 1374 - int chipnum; 1377 1377 + int chipnum, err = 0; 1375 1378 1376 1379 /* Now unlock the chip(s) POINT state */ 1377 1380 ··· 1379 1382 chipnum = (from >> cfi->chipshift); 1380 1383 ofs = from - (chipnum << cfi->chipshift); 1381 1384 1382 1382 - while (len) { 1385 1385 + while (len && !err) { 1383 1386 unsigned long thislen; 1384 1387 struct flchip *chip; 1385 1388 ··· 1397 1400 chip->ref_point_counter--; 1398 1401 if(chip->ref_point_counter == 0) 1399 1402 chip->state = FL_READY; 1400 1400 - } else 1401 1401 - printk(KERN_ERR "%s: Warning: unpoint called on non pointed region\n", map->name); /* Should this give an error? */ 1403 1403 + } else { 1404 1404 + printk(KERN_ERR "%s: Error: unpoint called on non pointed region\n", map->name); 1405 1405 + err = -EINVAL; 1406 1406 + } 1402 1407 1403 1408 put_chip(map, chip, chip->start); 1404 1409 mutex_unlock(&chip->mutex); ··· 1409 1410 ofs = 0; 1410 1411 chipnum++; 1411 1412 } 1413 1413 + 1414 1414 + return err; 1412 1415 } 1413 1416 1414 1417 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf) ··· 1456 1455 /* ofs: offset within the first chip that the first read should start */ 1457 1456 chipnum = (from >> cfi->chipshift); 1458 1457 ofs = from - (chipnum << cfi->chipshift); 1459 1459 - 1460 1460 - *retlen = 0; 1461 1458 1462 1459 while (len) { 1463 1460 unsigned long thislen; ··· 1550 1551 } 1551 1552 1552 1553 xip_enable(map, chip, adr); 1553 1553 - out: put_chip(map, chip, adr); 1554 1554 + out: DISABLE_VPP(map); 1555 1555 + put_chip(map, chip, adr); 1554 1556 mutex_unlock(&chip->mutex); 1555 1557 return ret; 1556 1558 } ··· 1564 1564 int ret = 0; 1565 1565 int chipnum; 1566 1566 unsigned long ofs; 1567 1567 - 1568 1568 - *retlen = 0; 1569 1569 - if (!len) 1570 1570 - return 0; 1571 1567 1572 1568 chipnum = to >> cfi->chipshift; 1573 1569 ofs = to - (chipnum << cfi->chipshift); ··· 1790 1794 } 1791 1795 1792 1796 xip_enable(map, chip, cmd_adr); 1793 1793 - out: put_chip(map, chip, cmd_adr); 1797 1797 + out: DISABLE_VPP(map); 1798 1798 + put_chip(map, chip, cmd_adr); 1794 1799 mutex_unlock(&chip->mutex); 1795 1800 return ret; 1796 1801 } ··· 1810 1813 for (i = 0; i < count; i++) 1811 1814 len += vecs[i].iov_len; 1812 1815 1813 1813 - *retlen = 0; 1814 1816 if (!len) 1815 1817 return 0; 1816 1818 ··· 1928 1932 ret = -EIO; 1929 1933 } else if (chipstatus & 0x20 && retries--) { 1930 1934 printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus); 1935 1935 + DISABLE_VPP(map); 1931 1936 put_chip(map, chip, adr); 1932 1937 mutex_unlock(&chip->mutex); 1933 1938 goto retry; ··· 1941 1944 } 1942 1945 1943 1946 xip_enable(map, chip, adr); 1944 1944 - out: put_chip(map, chip, adr); 1947 1947 + out: DISABLE_VPP(map); 1948 1948 + put_chip(map, chip, adr); 1945 1949 mutex_unlock(&chip->mutex); 1946 1950 return ret; 1947 1951 } ··· 2084 2086 } 2085 2087 2086 2088 xip_enable(map, chip, adr); 2087 2087 - out: put_chip(map, chip, adr); 2089 2089 + out: DISABLE_VPP(map); 2090 2090 + put_chip(map, chip, adr); 2088 2091 mutex_unlock(&chip->mutex); 2089 2092 return ret; 2090 2093 } ··· 2482 2483 allowed to. Or should we return -EAGAIN, because the upper layers 2483 2484 ought to have already shut down anything which was using the device 2484 2485 anyway? The latter for now. */ 2485 2485 - printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->oldstate); 2486 2486 + printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->state); 2486 2487 ret = -EAGAIN; 2487 2488 case FL_PM_SUSPENDED: 2488 2489 break;

+252 -31

drivers/mtd/chips/cfi_cmdset_0002.c

reviewed

··· 59 59 static int cfi_amdstd_reboot(struct notifier_block *, unsigned long, void *); 60 60 static int cfi_amdstd_secsi_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *); 61 61 62 62 + static int cfi_amdstd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, 63 63 + size_t *retlen, const u_char *buf); 64 64 + 62 65 static void cfi_amdstd_destroy(struct mtd_info *); 63 66 64 67 struct mtd_info *cfi_cmdset_0002(struct map_info *, int); ··· 192 189 struct cfi_private *cfi = map->fldrv_priv; 193 190 if (cfi->cfiq->BufWriteTimeoutTyp) { 194 191 pr_debug("Using buffer write method\n" ); 195 195 - mtd->write = cfi_amdstd_write_buffers; 192 192 + mtd->_write = cfi_amdstd_write_buffers; 196 193 } 197 194 } 198 195 ··· 231 228 static void fixup_use_secsi(struct mtd_info *mtd) 232 229 { 233 230 /* Setup for chips with a secsi area */ 234 234 - mtd->read_user_prot_reg = cfi_amdstd_secsi_read; 235 235 - mtd->read_fact_prot_reg = cfi_amdstd_secsi_read; 231 231 + mtd->_read_user_prot_reg = cfi_amdstd_secsi_read; 232 232 + mtd->_read_fact_prot_reg = cfi_amdstd_secsi_read; 236 233 } 237 234 238 235 static void fixup_use_erase_chip(struct mtd_info *mtd) ··· 241 238 struct cfi_private *cfi = map->fldrv_priv; 242 239 if ((cfi->cfiq->NumEraseRegions == 1) && 243 240 ((cfi->cfiq->EraseRegionInfo[0] & 0xffff) == 0)) { 244 244 - mtd->erase = cfi_amdstd_erase_chip; 241 241 + mtd->_erase = cfi_amdstd_erase_chip; 245 242 } 246 243 247 244 } ··· 252 249 */ 253 250 static void fixup_use_atmel_lock(struct mtd_info *mtd) 254 251 { 255 255 - mtd->lock = cfi_atmel_lock; 256 256 - mtd->unlock = cfi_atmel_unlock; 252 252 + mtd->_lock = cfi_atmel_lock; 253 253 + mtd->_unlock = cfi_atmel_unlock; 257 254 mtd->flags |= MTD_POWERUP_LOCK; 258 255 } 259 256 ··· 432 429 mtd->type = MTD_NORFLASH; 433 430 434 431 /* Fill in the default mtd operations */ 435 435 - mtd->erase = cfi_amdstd_erase_varsize; 436 436 - mtd->write = cfi_amdstd_write_words; 437 437 - mtd->read = cfi_amdstd_read; 438 438 - mtd->sync = cfi_amdstd_sync; 439 439 - mtd->suspend = cfi_amdstd_suspend; 440 440 - mtd->resume = cfi_amdstd_resume; 432 432 + mtd->_erase = cfi_amdstd_erase_varsize; 433 433 + mtd->_write = cfi_amdstd_write_words; 434 434 + mtd->_read = cfi_amdstd_read; 435 435 + mtd->_sync = cfi_amdstd_sync; 436 436 + mtd->_suspend = cfi_amdstd_suspend; 437 437 + mtd->_resume = cfi_amdstd_resume; 441 438 mtd->flags = MTD_CAP_NORFLASH; 442 439 mtd->name = map->name; 443 440 mtd->writesize = 1; ··· 446 443 pr_debug("MTD %s(): write buffer size %d\n", __func__, 447 444 mtd->writebufsize); 448 445 446 446 + mtd->_panic_write = cfi_amdstd_panic_write; 449 447 mtd->reboot_notifier.notifier_call = cfi_amdstd_reboot; 450 448 451 449 if (cfi->cfi_mode==CFI_MODE_CFI){ ··· 774 770 775 771 case FL_READY: 776 772 case FL_STATUS: 777 777 - /* We should really make set_vpp() count, rather than doing this */ 778 778 - DISABLE_VPP(map); 779 773 break; 780 774 default: 781 775 printk(KERN_ERR "MTD: put_chip() called with oldstate %d!!\n", chip->oldstate); ··· 1015 1013 int ret = 0; 1016 1014 1017 1015 /* ofs: offset within the first chip that the first read should start */ 1018 1018 - 1019 1016 chipnum = (from >> cfi->chipshift); 1020 1017 ofs = from - (chipnum << cfi->chipshift); 1021 1021 - 1022 1022 - 1023 1023 - *retlen = 0; 1024 1018 1025 1019 while (len) { 1026 1020 unsigned long thislen; ··· 1095 1097 int chipnum; 1096 1098 int ret = 0; 1097 1099 1098 1098 - 1099 1100 /* ofs: offset within the first chip that the first read should start */ 1100 1100 - 1101 1101 /* 8 secsi bytes per chip */ 1102 1102 chipnum=from>>3; 1103 1103 ofs=from & 7; 1104 1104 - 1105 1105 - 1106 1106 - *retlen = 0; 1107 1104 1108 1105 while (len) { 1109 1106 unsigned long thislen; ··· 1227 1234 xip_enable(map, chip, adr); 1228 1235 op_done: 1229 1236 chip->state = FL_READY; 1237 1237 + DISABLE_VPP(map); 1230 1238 put_chip(map, chip, adr); 1231 1239 mutex_unlock(&chip->mutex); 1232 1240 ··· 1244 1250 int chipnum; 1245 1251 unsigned long ofs, chipstart; 1246 1252 DECLARE_WAITQUEUE(wait, current); 1247 1247 - 1248 1248 - *retlen = 0; 1249 1249 - if (!len) 1250 1250 - return 0; 1251 1253 1252 1254 chipnum = to >> cfi->chipshift; 1253 1255 ofs = to - (chipnum << cfi->chipshift); ··· 1466 1476 ret = -EIO; 1467 1477 op_done: 1468 1478 chip->state = FL_READY; 1479 1479 + DISABLE_VPP(map); 1469 1480 put_chip(map, chip, adr); 1470 1481 mutex_unlock(&chip->mutex); 1471 1482 ··· 1483 1492 int ret = 0; 1484 1493 int chipnum; 1485 1494 unsigned long ofs; 1486 1486 - 1487 1487 - *retlen = 0; 1488 1488 - if (!len) 1489 1489 - return 0; 1490 1495 1491 1496 chipnum = to >> cfi->chipshift; 1492 1497 ofs = to - (chipnum << cfi->chipshift); ··· 1544 1557 1545 1558 *retlen += retlen_dregs; 1546 1559 return ret; 1560 1560 + } 1561 1561 + 1562 1562 + return 0; 1563 1563 + } 1564 1564 + 1565 1565 + /* 1566 1566 + * Wait for the flash chip to become ready to write data 1567 1567 + * 1568 1568 + * This is only called during the panic_write() path. When panic_write() 1569 1569 + * is called, the kernel is in the process of a panic, and will soon be 1570 1570 + * dead. Therefore we don't take any locks, and attempt to get access 1571 1571 + * to the chip as soon as possible. 1572 1572 + */ 1573 1573 + static int cfi_amdstd_panic_wait(struct map_info *map, struct flchip *chip, 1574 1574 + unsigned long adr) 1575 1575 + { 1576 1576 + struct cfi_private *cfi = map->fldrv_priv; 1577 1577 + int retries = 10; 1578 1578 + int i; 1579 1579 + 1580 1580 + /* 1581 1581 + * If the driver thinks the chip is idle, and no toggle bits 1582 1582 + * are changing, then the chip is actually idle for sure. 1583 1583 + */ 1584 1584 + if (chip->state == FL_READY && chip_ready(map, adr)) 1585 1585 + return 0; 1586 1586 + 1587 1587 + /* 1588 1588 + * Try several times to reset the chip and then wait for it 1589 1589 + * to become idle. The upper limit of a few milliseconds of 1590 1590 + * delay isn't a big problem: the kernel is dying anyway. It 1591 1591 + * is more important to save the messages. 1592 1592 + */ 1593 1593 + while (retries > 0) { 1594 1594 + const unsigned long timeo = (HZ / 1000) + 1; 1595 1595 + 1596 1596 + /* send the reset command */ 1597 1597 + map_write(map, CMD(0xF0), chip->start); 1598 1598 + 1599 1599 + /* wait for the chip to become ready */ 1600 1600 + for (i = 0; i < jiffies_to_usecs(timeo); i++) { 1601 1601 + if (chip_ready(map, adr)) 1602 1602 + return 0; 1603 1603 + 1604 1604 + udelay(1); 1605 1605 + } 1606 1606 + } 1607 1607 + 1608 1608 + /* the chip never became ready */ 1609 1609 + return -EBUSY; 1610 1610 + } 1611 1611 + 1612 1612 + /* 1613 1613 + * Write out one word of data to a single flash chip during a kernel panic 1614 1614 + * 1615 1615 + * This is only called during the panic_write() path. When panic_write() 1616 1616 + * is called, the kernel is in the process of a panic, and will soon be 1617 1617 + * dead. Therefore we don't take any locks, and attempt to get access 1618 1618 + * to the chip as soon as possible. 1619 1619 + * 1620 1620 + * The implementation of this routine is intentionally similar to 1621 1621 + * do_write_oneword(), in order to ease code maintenance. 1622 1622 + */ 1623 1623 + static int do_panic_write_oneword(struct map_info *map, struct flchip *chip, 1624 1624 + unsigned long adr, map_word datum) 1625 1625 + { 1626 1626 + const unsigned long uWriteTimeout = (HZ / 1000) + 1; 1627 1627 + struct cfi_private *cfi = map->fldrv_priv; 1628 1628 + int retry_cnt = 0; 1629 1629 + map_word oldd; 1630 1630 + int ret = 0; 1631 1631 + int i; 1632 1632 + 1633 1633 + adr += chip->start; 1634 1634 + 1635 1635 + ret = cfi_amdstd_panic_wait(map, chip, adr); 1636 1636 + if (ret) 1637 1637 + return ret; 1638 1638 + 1639 1639 + pr_debug("MTD %s(): PANIC WRITE 0x%.8lx(0x%.8lx)\n", 1640 1640 + __func__, adr, datum.x[0]); 1641 1641 + 1642 1642 + /* 1643 1643 + * Check for a NOP for the case when the datum to write is already 1644 1644 + * present - it saves time and works around buggy chips that corrupt 1645 1645 + * data at other locations when 0xff is written to a location that 1646 1646 + * already contains 0xff. 1647 1647 + */ 1648 1648 + oldd = map_read(map, adr); 1649 1649 + if (map_word_equal(map, oldd, datum)) { 1650 1650 + pr_debug("MTD %s(): NOP\n", __func__); 1651 1651 + goto op_done; 1652 1652 + } 1653 1653 + 1654 1654 + ENABLE_VPP(map); 1655 1655 + 1656 1656 + retry: 1657 1657 + cfi_send_gen_cmd(0xAA, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL); 1658 1658 + cfi_send_gen_cmd(0x55, cfi->addr_unlock2, chip->start, map, cfi, cfi->device_type, NULL); 1659 1659 + cfi_send_gen_cmd(0xA0, cfi->addr_unlock1, chip->start, map, cfi, cfi->device_type, NULL); 1660 1660 + map_write(map, datum, adr); 1661 1661 + 1662 1662 + for (i = 0; i < jiffies_to_usecs(uWriteTimeout); i++) { 1663 1663 + if (chip_ready(map, adr)) 1664 1664 + break; 1665 1665 + 1666 1666 + udelay(1); 1667 1667 + } 1668 1668 + 1669 1669 + if (!chip_good(map, adr, datum)) { 1670 1670 + /* reset on all failures. */ 1671 1671 + map_write(map, CMD(0xF0), chip->start); 1672 1672 + /* FIXME - should have reset delay before continuing */ 1673 1673 + 1674 1674 + if (++retry_cnt <= MAX_WORD_RETRIES) 1675 1675 + goto retry; 1676 1676 + 1677 1677 + ret = -EIO; 1678 1678 + } 1679 1679 + 1680 1680 + op_done: 1681 1681 + DISABLE_VPP(map); 1682 1682 + return ret; 1683 1683 + } 1684 1684 + 1685 1685 + /* 1686 1686 + * Write out some data during a kernel panic 1687 1687 + * 1688 1688 + * This is used by the mtdoops driver to save the dying messages from a 1689 1689 + * kernel which has panic'd. 1690 1690 + * 1691 1691 + * This routine ignores all of the locking used throughout the rest of the 1692 1692 + * driver, in order to ensure that the data gets written out no matter what 1693 1693 + * state this driver (and the flash chip itself) was in when the kernel crashed. 1694 1694 + * 1695 1695 + * The implementation of this routine is intentionally similar to 1696 1696 + * cfi_amdstd_write_words(), in order to ease code maintenance. 1697 1697 + */ 1698 1698 + static int cfi_amdstd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, 1699 1699 + size_t *retlen, const u_char *buf) 1700 1700 + { 1701 1701 + struct map_info *map = mtd->priv; 1702 1702 + struct cfi_private *cfi = map->fldrv_priv; 1703 1703 + unsigned long ofs, chipstart; 1704 1704 + int ret = 0; 1705 1705 + int chipnum; 1706 1706 + 1707 1707 + chipnum = to >> cfi->chipshift; 1708 1708 + ofs = to - (chipnum << cfi->chipshift); 1709 1709 + chipstart = cfi->chips[chipnum].start; 1710 1710 + 1711 1711 + /* If it's not bus aligned, do the first byte write */ 1712 1712 + if (ofs & (map_bankwidth(map) - 1)) { 1713 1713 + unsigned long bus_ofs = ofs & ~(map_bankwidth(map) - 1); 1714 1714 + int i = ofs - bus_ofs; 1715 1715 + int n = 0; 1716 1716 + map_word tmp_buf; 1717 1717 + 1718 1718 + ret = cfi_amdstd_panic_wait(map, &cfi->chips[chipnum], bus_ofs); 1719 1719 + if (ret) 1720 1720 + return ret; 1721 1721 + 1722 1722 + /* Load 'tmp_buf' with old contents of flash */ 1723 1723 + tmp_buf = map_read(map, bus_ofs + chipstart); 1724 1724 + 1725 1725 + /* Number of bytes to copy from buffer */ 1726 1726 + n = min_t(int, len, map_bankwidth(map) - i); 1727 1727 + 1728 1728 + tmp_buf = map_word_load_partial(map, tmp_buf, buf, i, n); 1729 1729 + 1730 1730 + ret = do_panic_write_oneword(map, &cfi->chips[chipnum], 1731 1731 + bus_ofs, tmp_buf); 1732 1732 + if (ret) 1733 1733 + return ret; 1734 1734 + 1735 1735 + ofs += n; 1736 1736 + buf += n; 1737 1737 + (*retlen) += n; 1738 1738 + len -= n; 1739 1739 + 1740 1740 + if (ofs >> cfi->chipshift) { 1741 1741 + chipnum++; 1742 1742 + ofs = 0; 1743 1743 + if (chipnum == cfi->numchips) 1744 1744 + return 0; 1745 1745 + } 1746 1746 + } 1747 1747 + 1748 1748 + /* We are now aligned, write as much as possible */ 1749 1749 + while (len >= map_bankwidth(map)) { 1750 1750 + map_word datum; 1751 1751 + 1752 1752 + datum = map_word_load(map, buf); 1753 1753 + 1754 1754 + ret = do_panic_write_oneword(map, &cfi->chips[chipnum], 1755 1755 + ofs, datum); 1756 1756 + if (ret) 1757 1757 + return ret; 1758 1758 + 1759 1759 + ofs += map_bankwidth(map); 1760 1760 + buf += map_bankwidth(map); 1761 1761 + (*retlen) += map_bankwidth(map); 1762 1762 + len -= map_bankwidth(map); 1763 1763 + 1764 1764 + if (ofs >> cfi->chipshift) { 1765 1765 + chipnum++; 1766 1766 + ofs = 0; 1767 1767 + if (chipnum == cfi->numchips) 1768 1768 + return 0; 1769 1769 + 1770 1770 + chipstart = cfi->chips[chipnum].start; 1771 1771 + } 1772 1772 + } 1773 1773 + 1774 1774 + /* Write the trailing bytes if any */ 1775 1775 + if (len & (map_bankwidth(map) - 1)) { 1776 1776 + map_word tmp_buf; 1777 1777 + 1778 1778 + ret = cfi_amdstd_panic_wait(map, &cfi->chips[chipnum], ofs); 1779 1779 + if (ret) 1780 1780 + return ret; 1781 1781 + 1782 1782 + tmp_buf = map_read(map, ofs + chipstart); 1783 1783 + 1784 1784 + tmp_buf = map_word_load_partial(map, tmp_buf, buf, 0, len); 1785 1785 + 1786 1786 + ret = do_panic_write_oneword(map, &cfi->chips[chipnum], 1787 1787 + ofs, tmp_buf); 1788 1788 + if (ret) 1789 1789 + return ret; 1790 1790 + 1791 1791 + (*retlen) += len; 1547 1792 } 1548 1793 1549 1794 return 0; ··· 1868 1649 1869 1650 chip->state = FL_READY; 1870 1651 xip_enable(map, chip, adr); 1652 1652 + DISABLE_VPP(map); 1871 1653 put_chip(map, chip, adr); 1872 1654 mutex_unlock(&chip->mutex); 1873 1655 ··· 1959 1739 } 1960 1740 1961 1741 chip->state = FL_READY; 1742 1742 + DISABLE_VPP(map); 1962 1743 put_chip(map, chip, adr); 1963 1744 mutex_unlock(&chip->mutex); 1964 1745 return ret;

+9 -24

drivers/mtd/chips/cfi_cmdset_0020.c

reviewed

··· 228 228 } 229 229 230 230 /* Also select the correct geometry setup too */ 231 231 - mtd->erase = cfi_staa_erase_varsize; 232 232 - mtd->read = cfi_staa_read; 233 233 - mtd->write = cfi_staa_write_buffers; 234 234 - mtd->writev = cfi_staa_writev; 235 235 - mtd->sync = cfi_staa_sync; 236 236 - mtd->lock = cfi_staa_lock; 237 237 - mtd->unlock = cfi_staa_unlock; 238 238 - mtd->suspend = cfi_staa_suspend; 239 239 - mtd->resume = cfi_staa_resume; 231 231 + mtd->_erase = cfi_staa_erase_varsize; 232 232 + mtd->_read = cfi_staa_read; 233 233 + mtd->_write = cfi_staa_write_buffers; 234 234 + mtd->_writev = cfi_staa_writev; 235 235 + mtd->_sync = cfi_staa_sync; 236 236 + mtd->_lock = cfi_staa_lock; 237 237 + mtd->_unlock = cfi_staa_unlock; 238 238 + mtd->_suspend = cfi_staa_suspend; 239 239 + mtd->_resume = cfi_staa_resume; 240 240 mtd->flags = MTD_CAP_NORFLASH & ~MTD_BIT_WRITEABLE; 241 241 mtd->writesize = 8; /* FIXME: Should be 0 for STMicro flashes w/out ECC */ 242 242 mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize; ··· 393 393 /* ofs: offset within the first chip that the first read should start */ 394 394 chipnum = (from >> cfi->chipshift); 395 395 ofs = from - (chipnum << cfi->chipshift); 396 396 - 397 397 - *retlen = 0; 398 396 399 397 while (len) { 400 398 unsigned long thislen; ··· 614 616 int ret = 0; 615 617 int chipnum; 616 618 unsigned long ofs; 617 617 - 618 618 - *retlen = 0; 619 619 - if (!len) 620 620 - return 0; 621 619 622 620 chipnum = to >> cfi->chipshift; 623 621 ofs = to - (chipnum << cfi->chipshift); ··· 898 904 int i, first; 899 905 struct mtd_erase_region_info *regions = mtd->eraseregions; 900 906 901 901 - if (instr->addr > mtd->size) 902 902 - return -EINVAL; 903 903 - 904 904 - if ((instr->len + instr->addr) > mtd->size) 905 905 - return -EINVAL; 906 906 - 907 907 /* Check that both start and end of the requested erase are 908 908 * aligned with the erasesize at the appropriate addresses. 909 909 */ ··· 1141 1153 return -EINVAL; 1142 1154 1143 1155 if (len & (mtd->erasesize -1)) 1144 1144 - return -EINVAL; 1145 1145 - 1146 1146 - if ((len + ofs) > mtd->size) 1147 1156 return -EINVAL; 1148 1157 1149 1158 chipnum = ofs >> cfi->chipshift;

-6

drivers/mtd/chips/cfi_util.c

reviewed

··· 173 173 int i, first; 174 174 struct mtd_erase_region_info *regions = mtd->eraseregions; 175 175 176 176 - if (ofs > mtd->size) 177 177 - return -EINVAL; 178 178 - 179 179 - if ((len + ofs) > mtd->size) 180 180 - return -EINVAL; 181 181 - 182 176 /* Check that both start and end of the requested erase are 183 177 * aligned with the erasesize at the appropriate addresses. 184 178 */

+2 -2

drivers/mtd/chips/fwh_lock.h

reviewed

··· 101 101 { 102 102 printk(KERN_NOTICE "using fwh lock/unlock method\n"); 103 103 /* Setup for the chips with the fwh lock method */ 104 104 - mtd->lock = fwh_lock_varsize; 105 105 - mtd->unlock = fwh_unlock_varsize; 104 104 + mtd->_lock = fwh_lock_varsize; 105 105 + mtd->_unlock = fwh_unlock_varsize; 106 106 } 107 107 #endif /* FWH_LOCK_H */

+4 -6

drivers/mtd/chips/map_absent.c

reviewed

··· 55 55 mtd->name = map->name; 56 56 mtd->type = MTD_ABSENT; 57 57 mtd->size = map->size; 58 58 - mtd->erase = map_absent_erase; 59 59 - mtd->read = map_absent_read; 60 60 - mtd->write = map_absent_write; 61 61 - mtd->sync = map_absent_sync; 58 58 + mtd->_erase = map_absent_erase; 59 59 + mtd->_read = map_absent_read; 60 60 + mtd->_write = map_absent_write; 61 61 + mtd->_sync = map_absent_sync; 62 62 mtd->flags = 0; 63 63 mtd->erasesize = PAGE_SIZE; 64 64 mtd->writesize = 1; ··· 70 70 71 71 static int map_absent_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf) 72 72 { 73 73 - *retlen = 0; 74 73 return -ENODEV; 75 74 } 76 75 77 76 static int map_absent_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf) 78 77 { 79 79 - *retlen = 0; 80 78 return -ENODEV; 81 79 } 82 80

+5 -9

drivers/mtd/chips/map_ram.c

reviewed

··· 64 64 mtd->name = map->name; 65 65 mtd->type = MTD_RAM; 66 66 mtd->size = map->size; 67 67 - mtd->erase = mapram_erase; 68 68 - mtd->get_unmapped_area = mapram_unmapped_area; 69 69 - mtd->read = mapram_read; 70 70 - mtd->write = mapram_write; 71 71 - mtd->sync = mapram_nop; 67 67 + mtd->_erase = mapram_erase; 68 68 + mtd->_get_unmapped_area = mapram_unmapped_area; 69 69 + mtd->_read = mapram_read; 70 70 + mtd->_write = mapram_write; 71 71 + mtd->_sync = mapram_nop; 72 72 mtd->flags = MTD_CAP_RAM; 73 73 mtd->writesize = 1; 74 74 ··· 122 122 unsigned long i; 123 123 124 124 allff = map_word_ff(map); 125 125 - 126 125 for (i=0; i<instr->len; i += map_bankwidth(map)) 127 126 map_write(map, allff, instr->addr + i); 128 128 - 129 127 instr->state = MTD_ERASE_DONE; 130 130 - 131 128 mtd_erase_callback(instr); 132 132 - 133 129 return 0; 134 130 } 135 131

+6 -7

drivers/mtd/chips/map_rom.c

reviewed

··· 41 41 mtd->name = map->name; 42 42 mtd->type = MTD_ROM; 43 43 mtd->size = map->size; 44 44 - mtd->get_unmapped_area = maprom_unmapped_area; 45 45 - mtd->read = maprom_read; 46 46 - mtd->write = maprom_write; 47 47 - mtd->sync = maprom_nop; 48 48 - mtd->erase = maprom_erase; 44 44 + mtd->_get_unmapped_area = maprom_unmapped_area; 45 45 + mtd->_read = maprom_read; 46 46 + mtd->_write = maprom_write; 47 47 + mtd->_sync = maprom_nop; 48 48 + mtd->_erase = maprom_erase; 49 49 mtd->flags = MTD_CAP_ROM; 50 50 mtd->erasesize = map->size; 51 51 mtd->writesize = 1; ··· 85 85 86 86 static int maprom_write (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf) 87 87 { 88 88 - printk(KERN_NOTICE "maprom_write called\n"); 89 89 - return -EIO; 88 88 + return -EROFS; 90 89 } 91 90 92 91 static int maprom_erase (struct mtd_info *mtd, struct erase_info *info)

+7

drivers/mtd/devices/Kconfig

reviewed

··· 103 103 help 104 104 This option enables FAST_READ access supported by ST M25Pxx. 105 105 106 106 + config MTD_SPEAR_SMI 107 107 + tristate "SPEAR MTD NOR Support through SMI controller" 108 108 + depends on PLAT_SPEAR 109 109 + default y 110 110 + help 111 111 + This enable SNOR support on SPEAR platforms using SMI controller 112 112 + 106 113 config MTD_SST25L 107 114 tristate "Support SST25L (non JEDEC) SPI Flash chips" 108 115 depends on SPI_MASTER

+1

drivers/mtd/devices/Makefile

reviewed

··· 17 17 obj-$(CONFIG_MTD_BLOCK2MTD) += block2mtd.o 18 18 obj-$(CONFIG_MTD_DATAFLASH) += mtd_dataflash.o 19 19 obj-$(CONFIG_MTD_M25P80) += m25p80.o 20 20 + obj-$(CONFIG_MTD_SPEAR_SMI) += spear_smi.o 20 21 obj-$(CONFIG_MTD_SST25L) += sst25l.o 21 22 22 23 CFLAGS_docg3.o += -I$(src)

+6 -22

drivers/mtd/devices/block2mtd.c

reviewed

··· 104 104 int offset = from & (PAGE_SIZE-1); 105 105 int cpylen; 106 106 107 107 - if (from > mtd->size) 108 108 - return -EINVAL; 109 109 - if (from + len > mtd->size) 110 110 - len = mtd->size - from; 111 111 - 112 112 - if (retlen) 113 113 - *retlen = 0; 114 114 - 115 107 while (len) { 116 108 if ((offset + len) > PAGE_SIZE) 117 109 cpylen = PAGE_SIZE - offset; // multiple pages ··· 140 148 int offset = to & ~PAGE_MASK; // page offset 141 149 int cpylen; 142 150 143 143 - if (retlen) 144 144 - *retlen = 0; 145 151 while (len) { 146 152 if ((offset+len) > PAGE_SIZE) 147 153 cpylen = PAGE_SIZE - offset; // multiple pages ··· 177 187 { 178 188 struct block2mtd_dev *dev = mtd->priv; 179 189 int err; 180 180 - 181 181 - if (!len) 182 182 - return 0; 183 183 - if (to >= mtd->size) 184 184 - return -ENOSPC; 185 185 - if (to + len > mtd->size) 186 186 - len = mtd->size - to; 187 190 188 191 mutex_lock(&dev->write_mutex); 189 192 err = _block2mtd_write(dev, buf, to, len, retlen); ··· 266 283 dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK; 267 284 dev->mtd.erasesize = erase_size; 268 285 dev->mtd.writesize = 1; 286 286 + dev->mtd.writebufsize = PAGE_SIZE; 269 287 dev->mtd.type = MTD_RAM; 270 288 dev->mtd.flags = MTD_CAP_RAM; 271 271 - dev->mtd.erase = block2mtd_erase; 272 272 - dev->mtd.write = block2mtd_write; 273 273 - dev->mtd.writev = mtd_writev; 274 274 - dev->mtd.sync = block2mtd_sync; 275 275 - dev->mtd.read = block2mtd_read; 289 289 + dev->mtd._erase = block2mtd_erase; 290 290 + dev->mtd._write = block2mtd_write; 291 291 + dev->mtd._writev = mtd_writev; 292 292 + dev->mtd._sync = block2mtd_sync; 293 293 + dev->mtd._read = block2mtd_read; 276 294 dev->mtd.priv = dev; 277 295 dev->mtd.owner = THIS_MODULE; 278 296

+7 -18

drivers/mtd/devices/doc2000.c

reviewed

··· 562 562 563 563 mtd->type = MTD_NANDFLASH; 564 564 mtd->flags = MTD_CAP_NANDFLASH; 565 565 - mtd->writesize = 512; 565 565 + mtd->writebufsize = mtd->writesize = 512; 566 566 mtd->oobsize = 16; 567 567 + mtd->ecc_strength = 2; 567 568 mtd->owner = THIS_MODULE; 568 568 - mtd->erase = doc_erase; 569 569 - mtd->read = doc_read; 570 570 - mtd->write = doc_write; 571 571 - mtd->read_oob = doc_read_oob; 572 572 - mtd->write_oob = doc_write_oob; 569 569 + mtd->_erase = doc_erase; 570 570 + mtd->_read = doc_read; 571 571 + mtd->_write = doc_write; 572 572 + mtd->_read_oob = doc_read_oob; 573 573 + mtd->_write_oob = doc_write_oob; 573 574 this->curfloor = -1; 574 575 this->curchip = -1; 575 576 mutex_init(&this->lock); ··· 603 602 int i, len256 = 0, ret=0; 604 603 size_t left = len; 605 604 606 606 - /* Don't allow read past end of device */ 607 607 - if (from >= this->totlen) 608 608 - return -EINVAL; 609 609 - 610 605 mutex_lock(&this->lock); 611 611 - 612 612 - *retlen = 0; 613 606 while (left) { 614 607 len = left; 615 608 ··· 743 748 size_t left = len; 744 749 int status; 745 750 746 746 - /* Don't allow write past end of device */ 747 747 - if (to >= this->totlen) 748 748 - return -EINVAL; 749 749 - 750 751 mutex_lock(&this->lock); 751 751 - 752 752 - *retlen = 0; 753 752 while (left) { 754 753 len = left; 755 754

+7 -15

drivers/mtd/devices/doc2001.c

reviewed

··· 346 346 347 347 /* FIXME: erase size is not always 8KiB */ 348 348 mtd->erasesize = 0x2000; 349 349 - mtd->writesize = 512; 349 349 + mtd->writebufsize = mtd->writesize = 512; 350 350 mtd->oobsize = 16; 351 351 + mtd->ecc_strength = 2; 351 352 mtd->owner = THIS_MODULE; 352 352 - mtd->erase = doc_erase; 353 353 - mtd->read = doc_read; 354 354 - mtd->write = doc_write; 355 355 - mtd->read_oob = doc_read_oob; 356 356 - mtd->write_oob = doc_write_oob; 353 353 + mtd->_erase = doc_erase; 354 354 + mtd->_read = doc_read; 355 355 + mtd->_write = doc_write; 356 356 + mtd->_read_oob = doc_read_oob; 357 357 + mtd->_write_oob = doc_write_oob; 357 358 this->curfloor = -1; 358 359 this->curchip = -1; 359 360 ··· 383 382 struct DiskOnChip *this = mtd->priv; 384 383 void __iomem *docptr = this->virtadr; 385 384 struct Nand *mychip = &this->chips[from >> (this->chipshift)]; 386 386 - 387 387 - /* Don't allow read past end of device */ 388 388 - if (from >= this->totlen) 389 389 - return -EINVAL; 390 385 391 386 /* Don't allow a single read to cross a 512-byte block boundary */ 392 387 if (from + len > ((from | 0x1ff) + 1)) ··· 491 494 void __iomem *docptr = this->virtadr; 492 495 struct Nand *mychip = &this->chips[to >> (this->chipshift)]; 493 496 494 494 - /* Don't allow write past end of device */ 495 495 - if (to >= this->totlen) 496 496 - return -EINVAL; 497 497 - 498 497 #if 0 499 498 /* Don't allow a single write to cross a 512-byte block boundary */ 500 499 if (to + len > ( (to | 0x1ff) + 1)) ··· 592 599 printk("Error programming flash\n"); 593 600 /* Error in programming 594 601 FIXME: implement Bad Block Replacement (in nftl.c ??) */ 595 595 - *retlen = 0; 596 602 ret = -EIO; 597 603 } 598 604 dummy = ReadDOC(docptr, LastDataRead);

+7 -15

drivers/mtd/devices/doc2001plus.c

reviewed

··· 467 467 468 468 mtd->type = MTD_NANDFLASH; 469 469 mtd->flags = MTD_CAP_NANDFLASH; 470 470 - mtd->writesize = 512; 470 470 + mtd->writebufsize = mtd->writesize = 512; 471 471 mtd->oobsize = 16; 472 472 + mtd->ecc_strength = 2; 472 473 mtd->owner = THIS_MODULE; 473 473 - mtd->erase = doc_erase; 474 474 - mtd->read = doc_read; 475 475 - mtd->write = doc_write; 476 476 - mtd->read_oob = doc_read_oob; 477 477 - mtd->write_oob = doc_write_oob; 474 474 + mtd->_erase = doc_erase; 475 475 + mtd->_read = doc_read; 476 476 + mtd->_write = doc_write; 477 477 + mtd->_read_oob = doc_read_oob; 478 478 + mtd->_write_oob = doc_write_oob; 478 479 this->curfloor = -1; 479 480 this->curchip = -1; 480 481 ··· 581 580 struct DiskOnChip *this = mtd->priv; 582 581 void __iomem * docptr = this->virtadr; 583 582 struct Nand *mychip = &this->chips[from >> (this->chipshift)]; 584 584 - 585 585 - /* Don't allow read past end of device */ 586 586 - if (from >= this->totlen) 587 587 - return -EINVAL; 588 583 589 584 /* Don't allow a single read to cross a 512-byte block boundary */ 590 585 if (from + len > ((from | 0x1ff) + 1)) ··· 697 700 void __iomem * docptr = this->virtadr; 698 701 struct Nand *mychip = &this->chips[to >> (this->chipshift)]; 699 702 700 700 - /* Don't allow write past end of device */ 701 701 - if (to >= this->totlen) 702 702 - return -EINVAL; 703 703 - 704 703 /* Don't allow writes which aren't exactly one block (512 bytes) */ 705 704 if ((to & 0x1ff) || (len != 0x200)) 706 705 return -EINVAL; ··· 793 800 printk("MTD: Error 0x%x programming at 0x%x\n", dummy, (int)to); 794 801 /* Error in programming 795 802 FIXME: implement Bad Block Replacement (in nftl.c ??) */ 796 796 - *retlen = 0; 797 803 ret = -EIO; 798 804 } 799 805 dummy = ReadDOC(docptr, Mplus_LastDataRead);

+115 -86

drivers/mtd/devices/docg3.c

reviewed

··· 80 80 .oobavail = 8, 81 81 }; 82 82 83 83 - /** 84 84 - * struct docg3_bch - BCH engine 85 85 - */ 86 86 - static struct bch_control *docg3_bch; 87 87 - 88 83 static inline u8 doc_readb(struct docg3 *docg3, u16 reg) 89 84 { 90 90 - u8 val = readb(docg3->base + reg); 85 85 + u8 val = readb(docg3->cascade->base + reg); 91 86 92 87 trace_docg3_io(0, 8, reg, (int)val); 93 88 return val; ··· 90 95 91 96 static inline u16 doc_readw(struct docg3 *docg3, u16 reg) 92 97 { 93 93 - u16 val = readw(docg3->base + reg); 98 98 + u16 val = readw(docg3->cascade->base + reg); 94 99 95 100 trace_docg3_io(0, 16, reg, (int)val); 96 101 return val; ··· 98 103 99 104 static inline void doc_writeb(struct docg3 *docg3, u8 val, u16 reg) 100 105 { 101 101 - writeb(val, docg3->base + reg); 106 106 + writeb(val, docg3->cascade->base + reg); 102 107 trace_docg3_io(1, 8, reg, val); 103 108 } 104 109 105 110 static inline void doc_writew(struct docg3 *docg3, u16 val, u16 reg) 106 111 { 107 107 - writew(val, docg3->base + reg); 112 112 + writew(val, docg3->cascade->base + reg); 108 113 trace_docg3_io(1, 16, reg, val); 109 114 } 110 115 ··· 638 643 639 644 for (i = 0; i < DOC_ECC_BCH_SIZE; i++) 640 645 ecc[i] = bitrev8(hwecc[i]); 641 641 - numerrs = decode_bch(docg3_bch, NULL, DOC_ECC_BCH_COVERED_BYTES, 646 646 + numerrs = decode_bch(docg3->cascade->bch, NULL, 647 647 + DOC_ECC_BCH_COVERED_BYTES, 642 648 NULL, ecc, NULL, errorpos); 643 649 BUG_ON(numerrs == -EINVAL); 644 650 if (numerrs < 0) ··· 730 734 * doc_read_page_getbytes - Reads bytes from a prepared page 731 735 * @docg3: the device 732 736 * @len: the number of bytes to be read (must be a multiple of 4) 733 733 - * @buf: the buffer to be filled in 737 737 + * @buf: the buffer to be filled in (or NULL is forget bytes) 734 738 * @first: 1 if first time read, DOC_READADDRESS should be set 735 739 * 736 740 */ ··· 845 849 struct mtd_oob_ops *ops) 846 850 { 847 851 struct docg3 *docg3 = mtd->priv; 848 848 - int block0, block1, page, ret, ofs = 0; 852 852 + int block0, block1, page, ret, skip, ofs = 0; 849 853 u8 *oobbuf = ops->oobbuf; 850 854 u8 *buf = ops->datbuf; 851 855 size_t len, ooblen, nbdata, nboob; ··· 865 869 866 870 doc_dbg("doc_read_oob(from=%lld, mode=%d, data=(%p:%zu), oob=(%p:%zu))\n", 867 871 from, ops->mode, buf, len, oobbuf, ooblen); 868 868 - if ((len % DOC_LAYOUT_PAGE_SIZE) || (ooblen % DOC_LAYOUT_OOB_SIZE) || 869 869 - (from % DOC_LAYOUT_PAGE_SIZE)) 872 872 + if (ooblen % DOC_LAYOUT_OOB_SIZE) 870 873 return -EINVAL; 871 874 872 872 - ret = -EINVAL; 873 873 - calc_block_sector(from + len, &block0, &block1, &page, &ofs, 874 874 - docg3->reliable); 875 875 - if (block1 > docg3->max_block) 876 876 - goto err; 875 875 + if (from + len > mtd->size) 876 876 + return -EINVAL; 877 877 878 878 ops->oobretlen = 0; 879 879 ops->retlen = 0; 880 880 ret = 0; 881 881 + skip = from % DOC_LAYOUT_PAGE_SIZE; 882 882 + mutex_lock(&docg3->cascade->lock); 881 883 while (!ret && (len > 0 || ooblen > 0)) { 882 882 - calc_block_sector(from, &block0, &block1, &page, &ofs, 884 884 + calc_block_sector(from - skip, &block0, &block1, &page, &ofs, 883 885 docg3->reliable); 884 884 - nbdata = min_t(size_t, len, (size_t)DOC_LAYOUT_PAGE_SIZE); 886 886 + nbdata = min_t(size_t, len, DOC_LAYOUT_PAGE_SIZE - skip); 885 887 nboob = min_t(size_t, ooblen, (size_t)DOC_LAYOUT_OOB_SIZE); 886 888 ret = doc_read_page_prepare(docg3, block0, block1, page, ofs); 887 889 if (ret < 0) 888 888 - goto err; 890 890 + goto out; 889 891 ret = doc_read_page_ecc_init(docg3, DOC_ECC_BCH_TOTAL_BYTES); 890 892 if (ret < 0) 891 893 goto err_in_read; 892 892 - ret = doc_read_page_getbytes(docg3, nbdata, buf, 1); 894 894 + ret = doc_read_page_getbytes(docg3, skip, NULL, 1); 895 895 + if (ret < skip) 896 896 + goto err_in_read; 897 897 + ret = doc_read_page_getbytes(docg3, nbdata, buf, 0); 893 898 if (ret < nbdata) 894 899 goto err_in_read; 895 895 - doc_read_page_getbytes(docg3, DOC_LAYOUT_PAGE_SIZE - nbdata, 900 900 + doc_read_page_getbytes(docg3, 901 901 + DOC_LAYOUT_PAGE_SIZE - nbdata - skip, 896 902 NULL, 0); 897 903 ret = doc_read_page_getbytes(docg3, nboob, oobbuf, 0); 898 904 if (ret < nboob) ··· 948 950 len -= nbdata; 949 951 ooblen -= nboob; 950 952 from += DOC_LAYOUT_PAGE_SIZE; 953 953 + skip = 0; 951 954 } 952 955 956 956 + out: 957 957 + mutex_unlock(&docg3->cascade->lock); 953 958 return ret; 954 959 err_in_read: 955 960 doc_read_page_finish(docg3); 956 956 - err: 957 957 - return ret; 961 961 + goto out; 958 962 } 959 963 960 964 /** ··· 1114 1114 */ 1115 1115 static int doc_write_erase_wait_status(struct docg3 *docg3) 1116 1116 { 1117 1117 - int status, ret = 0; 1117 1117 + int i, status, ret = 0; 1118 1118 1119 1119 - if (!doc_is_ready(docg3)) 1120 1120 - usleep_range(3000, 3000); 1119 1119 + for (i = 0; !doc_is_ready(docg3) && i < 5; i++) 1120 1120 + msleep(20); 1121 1121 if (!doc_is_ready(docg3)) { 1122 1122 doc_dbg("Timeout reached and the chip is still not ready\n"); 1123 1123 ret = -EAGAIN; ··· 1196 1196 int block0, block1, page, ret, ofs = 0; 1197 1197 1198 1198 doc_dbg("doc_erase(from=%lld, len=%lld\n", info->addr, info->len); 1199 1199 - doc_set_device_id(docg3, docg3->device_id); 1200 1199 1201 1200 info->state = MTD_ERASE_PENDING; 1202 1201 calc_block_sector(info->addr + info->len, &block0, &block1, &page, 1203 1202 &ofs, docg3->reliable); 1204 1203 ret = -EINVAL; 1205 1205 - if (block1 > docg3->max_block || page || ofs) 1204 1204 + if (info->addr + info->len > mtd->size || page || ofs) 1206 1205 goto reset_err; 1207 1206 1208 1207 ret = 0; 1209 1208 calc_block_sector(info->addr, &block0, &block1, &page, &ofs, 1210 1209 docg3->reliable); 1210 1210 + mutex_lock(&docg3->cascade->lock); 1211 1211 + doc_set_device_id(docg3, docg3->device_id); 1211 1212 doc_set_reliable_mode(docg3); 1212 1213 for (len = info->len; !ret && len > 0; len -= mtd->erasesize) { 1213 1214 info->state = MTD_ERASING; ··· 1216 1215 block0 += 2; 1217 1216 block1 += 2; 1218 1217 } 1218 1218 + mutex_unlock(&docg3->cascade->lock); 1219 1219 1220 1220 if (ret) 1221 1221 goto reset_err; ··· 1403 1401 struct mtd_oob_ops *ops) 1404 1402 { 1405 1403 struct docg3 *docg3 = mtd->priv; 1406 1406 - int block0, block1, page, ret, pofs = 0, autoecc, oobdelta; 1404 1404 + int ret, autoecc, oobdelta; 1407 1405 u8 *oobbuf = ops->oobbuf; 1408 1406 u8 *buf = ops->datbuf; 1409 1407 size_t len, ooblen; ··· 1440 1438 if (len && ooblen && 1441 1439 (len / DOC_LAYOUT_PAGE_SIZE) != (ooblen / oobdelta)) 1442 1440 return -EINVAL; 1443 1443 - 1444 1444 - ret = -EINVAL; 1445 1445 - calc_block_sector(ofs + len, &block0, &block1, &page, &pofs, 1446 1446 - docg3->reliable); 1447 1447 - if (block1 > docg3->max_block) 1448 1448 - goto err; 1441 1441 + if (ofs + len > mtd->size) 1442 1442 + return -EINVAL; 1449 1443 1450 1444 ops->oobretlen = 0; 1451 1445 ops->retlen = 0; ··· 1455 1457 if (autoecc < 0) 1456 1458 return autoecc; 1457 1459 1460 1460 + mutex_lock(&docg3->cascade->lock); 1458 1461 while (!ret && len > 0) { 1459 1462 memset(oob, 0, sizeof(oob)); 1460 1463 if (ofs == docg3->oob_write_ofs) ··· 1476 1477 } 1477 1478 ops->retlen += DOC_LAYOUT_PAGE_SIZE; 1478 1479 } 1479 1479 - err: 1480 1480 + 1480 1481 doc_set_device_id(docg3, 0); 1482 1482 + mutex_unlock(&docg3->cascade->lock); 1481 1483 return ret; 1482 1484 } 1483 1485 ··· 1535 1535 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr); 1536 1536 int dps0; 1537 1537 1538 1538 + mutex_lock(&docg3->cascade->lock); 1538 1539 doc_set_device_id(docg3, docg3->device_id); 1539 1540 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS); 1540 1541 doc_set_device_id(docg3, 0); 1542 1542 + mutex_unlock(&docg3->cascade->lock); 1541 1543 1542 1544 return sprintf(buf, "%d\n", !(dps0 & DOC_DPS_KEY_OK)); 1543 1545 } ··· 1550 1548 struct docg3 *docg3 = sysfs_dev2docg3(dev, attr); 1551 1549 int dps1; 1552 1550 1551 1551 + mutex_lock(&docg3->cascade->lock); 1553 1552 doc_set_device_id(docg3, docg3->device_id); 1554 1553 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS); 1555 1554 doc_set_device_id(docg3, 0); 1555 1555 + mutex_unlock(&docg3->cascade->lock); 1556 1556 1557 1557 return sprintf(buf, "%d\n", !(dps1 & DOC_DPS_KEY_OK)); 1558 1558 } ··· 1569 1565 if (count != DOC_LAYOUT_DPS_KEY_LENGTH) 1570 1566 return -EINVAL; 1571 1567 1568 1568 + mutex_lock(&docg3->cascade->lock); 1572 1569 doc_set_device_id(docg3, docg3->device_id); 1573 1570 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++) 1574 1571 doc_writeb(docg3, buf[i], DOC_DPS0_KEY); 1575 1572 doc_set_device_id(docg3, 0); 1573 1573 + mutex_unlock(&docg3->cascade->lock); 1576 1574 return count; 1577 1575 } 1578 1576 ··· 1588 1582 if (count != DOC_LAYOUT_DPS_KEY_LENGTH) 1589 1583 return -EINVAL; 1590 1584 1585 1585 + mutex_lock(&docg3->cascade->lock); 1591 1586 doc_set_device_id(docg3, docg3->device_id); 1592 1587 for (i = 0; i < DOC_LAYOUT_DPS_KEY_LENGTH; i++) 1593 1588 doc_writeb(docg3, buf[i], DOC_DPS1_KEY); 1594 1589 doc_set_device_id(docg3, 0); 1590 1590 + mutex_unlock(&docg3->cascade->lock); 1595 1591 return count; 1596 1592 } 1597 1593 ··· 1609 1601 }; 1610 1602 1611 1603 static int doc_register_sysfs(struct platform_device *pdev, 1612 1612 - struct mtd_info **floors) 1604 1604 + struct docg3_cascade *cascade) 1613 1605 { 1614 1606 int ret = 0, floor, i = 0; 1615 1607 struct device *dev = &pdev->dev; 1616 1608 1617 1617 - for (floor = 0; !ret && floor < DOC_MAX_NBFLOORS && floors[floor]; 1618 1618 - floor++) 1609 1609 + for (floor = 0; !ret && floor < DOC_MAX_NBFLOORS && 1610 1610 + cascade->floors[floor]; floor++) 1619 1611 for (i = 0; !ret && i < 4; i++) 1620 1612 ret = device_create_file(dev, &doc_sys_attrs[floor][i]); 1621 1613 if (!ret) ··· 1629 1621 } 1630 1622 1631 1623 static void doc_unregister_sysfs(struct platform_device *pdev, 1632 1632 - struct mtd_info **floors) 1624 1624 + struct docg3_cascade *cascade) 1633 1625 { 1634 1626 struct device *dev = &pdev->dev; 1635 1627 int floor, i; 1636 1628 1637 1637 - for (floor = 0; floor < DOC_MAX_NBFLOORS && floors[floor]; 1629 1629 + for (floor = 0; floor < DOC_MAX_NBFLOORS && cascade->floors[floor]; 1638 1630 floor++) 1639 1631 for (i = 0; i < 4; i++) 1640 1632 device_remove_file(dev, &doc_sys_attrs[floor][i]); ··· 1648 1640 struct docg3 *docg3 = (struct docg3 *)s->private; 1649 1641 1650 1642 int pos = 0; 1651 1651 - u8 fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL); 1643 1643 + u8 fctrl; 1644 1644 + 1645 1645 + mutex_lock(&docg3->cascade->lock); 1646 1646 + fctrl = doc_register_readb(docg3, DOC_FLASHCONTROL); 1647 1647 + mutex_unlock(&docg3->cascade->lock); 1652 1648 1653 1649 pos += seq_printf(s, 1654 1650 "FlashControl : 0x%02x (%s,CE# %s,%s,%s,flash %s)\n", ··· 1670 1658 { 1671 1659 struct docg3 *docg3 = (struct docg3 *)s->private; 1672 1660 1673 1673 - int pos = 0; 1674 1674 - int pctrl = doc_register_readb(docg3, DOC_ASICMODE); 1675 1675 - int mode = pctrl & 0x03; 1661 1661 + int pos = 0, pctrl, mode; 1662 1662 + 1663 1663 + mutex_lock(&docg3->cascade->lock); 1664 1664 + pctrl = doc_register_readb(docg3, DOC_ASICMODE); 1665 1665 + mode = pctrl & 0x03; 1666 1666 + mutex_unlock(&docg3->cascade->lock); 1676 1667 1677 1668 pos += seq_printf(s, 1678 1669 "%04x : RAM_WE=%d,RSTIN_RESET=%d,BDETCT_RESET=%d,WRITE_ENABLE=%d,POWERDOWN=%d,MODE=%d%d (", ··· 1707 1692 { 1708 1693 struct docg3 *docg3 = (struct docg3 *)s->private; 1709 1694 int pos = 0; 1710 1710 - int id = doc_register_readb(docg3, DOC_DEVICESELECT); 1695 1695 + int id; 1696 1696 + 1697 1697 + mutex_lock(&docg3->cascade->lock); 1698 1698 + id = doc_register_readb(docg3, DOC_DEVICESELECT); 1699 1699 + mutex_unlock(&docg3->cascade->lock); 1711 1700 1712 1701 pos += seq_printf(s, "DeviceId = %d\n", id); 1713 1702 return pos; ··· 1724 1705 int pos = 0; 1725 1706 int protect, dps0, dps0_low, dps0_high, dps1, dps1_low, dps1_high; 1726 1707 1708 1708 + mutex_lock(&docg3->cascade->lock); 1727 1709 protect = doc_register_readb(docg3, DOC_PROTECTION); 1728 1710 dps0 = doc_register_readb(docg3, DOC_DPS0_STATUS); 1729 1711 dps0_low = doc_register_readw(docg3, DOC_DPS0_ADDRLOW); ··· 1732 1712 dps1 = doc_register_readb(docg3, DOC_DPS1_STATUS); 1733 1713 dps1_low = doc_register_readw(docg3, DOC_DPS1_ADDRLOW); 1734 1714 dps1_high = doc_register_readw(docg3, DOC_DPS1_ADDRHIGH); 1715 1715 + mutex_unlock(&docg3->cascade->lock); 1735 1716 1736 1717 pos += seq_printf(s, "Protection = 0x%02x (", 1737 1718 protect); ··· 1825 1804 1826 1805 switch (chip_id) { 1827 1806 case DOC_CHIPID_G3: 1828 1828 - mtd->name = kasprintf(GFP_KERNEL, "DiskOnChip G3 floor %d", 1807 1807 + mtd->name = kasprintf(GFP_KERNEL, "docg3.%d", 1829 1808 docg3->device_id); 1830 1809 docg3->max_block = 2047; 1831 1810 break; ··· 1838 1817 mtd->erasesize = DOC_LAYOUT_BLOCK_SIZE * DOC_LAYOUT_NBPLANES; 1839 1818 if (docg3->reliable == 2) 1840 1819 mtd->erasesize /= 2; 1841 1841 - mtd->writesize = DOC_LAYOUT_PAGE_SIZE; 1820 1820 + mtd->writebufsize = mtd->writesize = DOC_LAYOUT_PAGE_SIZE; 1842 1821 mtd->oobsize = DOC_LAYOUT_OOB_SIZE; 1843 1822 mtd->owner = THIS_MODULE; 1844 1844 - mtd->erase = doc_erase; 1845 1845 - mtd->read = doc_read; 1846 1846 - mtd->write = doc_write; 1847 1847 - mtd->read_oob = doc_read_oob; 1848 1848 - mtd->write_oob = doc_write_oob; 1849 1849 - mtd->block_isbad = doc_block_isbad; 1823 1823 + mtd->_erase = doc_erase; 1824 1824 + mtd->_read = doc_read; 1825 1825 + mtd->_write = doc_write; 1826 1826 + mtd->_read_oob = doc_read_oob; 1827 1827 + mtd->_write_oob = doc_write_oob; 1828 1828 + mtd->_block_isbad = doc_block_isbad; 1850 1829 mtd->ecclayout = &docg3_oobinfo; 1830 1830 + mtd->ecc_strength = DOC_ECC_BCH_T; 1851 1831 } 1852 1832 1853 1833 /** ··· 1856 1834 * @base: the io space where the device is probed 1857 1835 * @floor: the floor of the probed device 1858 1836 * @dev: the device 1837 1837 + * @cascade: the cascade of chips this devices will belong to 1859 1838 * 1860 1839 * Checks whether a device at the specified IO range, and floor is available. 1861 1840 * ··· 1864 1841 * if a memory allocation failed. If floor 0 is checked, a reset of the ASIC is 1865 1842 * launched. 1866 1843 */ 1867 1867 - static struct mtd_info *doc_probe_device(void __iomem *base, int floor, 1868 1868 - struct device *dev) 1844 1844 + static struct mtd_info * __init 1845 1845 + doc_probe_device(struct docg3_cascade *cascade, int floor, struct device *dev) 1869 1846 { 1870 1847 int ret, bbt_nbpages; 1871 1848 u16 chip_id, chip_id_inv; ··· 1888 1865 1889 1866 docg3->dev = dev; 1890 1867 docg3->device_id = floor; 1891 1891 - docg3->base = base; 1868 1868 + docg3->cascade = cascade; 1892 1869 doc_set_device_id(docg3, docg3->device_id); 1893 1870 if (!floor) 1894 1871 doc_set_asic_mode(docg3, DOC_ASICMODE_RESET); ··· 1905 1882 switch (chip_id) { 1906 1883 case DOC_CHIPID_G3: 1907 1884 doc_info("Found a G3 DiskOnChip at addr %p, floor %d\n", 1908 1908 - base, floor); 1885 1885 + docg3->cascade->base, floor); 1909 1886 break; 1910 1887 default: 1911 1888 doc_err("Chip id %04x is not a DiskOnChip G3 chip\n", chip_id); ··· 1950 1927 static int docg3_resume(struct platform_device *pdev) 1951 1928 { 1952 1929 int i; 1930 1930 + struct docg3_cascade *cascade; 1953 1931 struct mtd_info **docg3_floors, *mtd; 1954 1932 struct docg3 *docg3; 1955 1933 1956 1956 - docg3_floors = platform_get_drvdata(pdev); 1934 1934 + cascade = platform_get_drvdata(pdev); 1935 1935 + docg3_floors = cascade->floors; 1957 1936 mtd = docg3_floors[0]; 1958 1937 docg3 = mtd->priv; 1959 1938 ··· 1977 1952 static int docg3_suspend(struct platform_device *pdev, pm_message_t state) 1978 1953 { 1979 1954 int floor, i; 1955 1955 + struct docg3_cascade *cascade; 1980 1956 struct mtd_info **docg3_floors, *mtd; 1981 1957 struct docg3 *docg3; 1982 1958 u8 ctrl, pwr_down; 1983 1959 1984 1984 - docg3_floors = platform_get_drvdata(pdev); 1960 1960 + cascade = platform_get_drvdata(pdev); 1961 1961 + docg3_floors = cascade->floors; 1985 1962 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) { 1986 1963 mtd = docg3_floors[floor]; 1987 1964 if (!mtd) ··· 2033 2006 struct resource *ress; 2034 2007 void __iomem *base; 2035 2008 int ret, floor, found = 0; 2036 2036 - struct mtd_info **docg3_floors; 2009 2009 + struct docg3_cascade *cascade; 2037 2010 2038 2011 ret = -ENXIO; 2039 2012 ress = platform_get_resource(pdev, IORESOURCE_MEM, 0); ··· 2044 2017 base = ioremap(ress->start, DOC_IOSPACE_SIZE); 2045 2018 2046 2019 ret = -ENOMEM; 2047 2047 - docg3_floors = kzalloc(sizeof(*docg3_floors) * DOC_MAX_NBFLOORS, 2048 2048 - GFP_KERNEL); 2049 2049 - if (!docg3_floors) 2020 2020 + cascade = kzalloc(sizeof(*cascade) * DOC_MAX_NBFLOORS, 2021 2021 + GFP_KERNEL); 2022 2022 + if (!cascade) 2050 2023 goto nomem1; 2051 2051 - docg3_bch = init_bch(DOC_ECC_BCH_M, DOC_ECC_BCH_T, 2024 2024 + cascade->base = base; 2025 2025 + mutex_init(&cascade->lock); 2026 2026 + cascade->bch = init_bch(DOC_ECC_BCH_M, DOC_ECC_BCH_T, 2052 2027 DOC_ECC_BCH_PRIMPOLY); 2053 2053 - if (!docg3_bch) 2028 2028 + if (!cascade->bch) 2054 2029 goto nomem2; 2055 2030 2056 2031 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) { 2057 2057 - mtd = doc_probe_device(base, floor, dev); 2032 2032 + mtd = doc_probe_device(cascade, floor, dev); 2058 2033 if (IS_ERR(mtd)) { 2059 2034 ret = PTR_ERR(mtd); 2060 2035 goto err_probe; ··· 2067 2038 else 2068 2039 continue; 2069 2040 } 2070 2070 - docg3_floors[floor] = mtd; 2041 2041 + cascade->floors[floor] = mtd; 2071 2042 ret = mtd_device_parse_register(mtd, part_probes, NULL, NULL, 2072 2043 0); 2073 2044 if (ret) ··· 2075 2046 found++; 2076 2047 } 2077 2048 2078 2078 - ret = doc_register_sysfs(pdev, docg3_floors); 2049 2049 + ret = doc_register_sysfs(pdev, cascade); 2079 2050 if (ret) 2080 2051 goto err_probe; 2081 2052 if (!found) 2082 2053 goto notfound; 2083 2054 2084 2084 - platform_set_drvdata(pdev, docg3_floors); 2085 2085 - doc_dbg_register(docg3_floors[0]->priv); 2055 2055 + platform_set_drvdata(pdev, cascade); 2056 2056 + doc_dbg_register(cascade->floors[0]->priv); 2086 2057 return 0; 2087 2058 2088 2059 notfound: 2089 2060 ret = -ENODEV; 2090 2061 dev_info(dev, "No supported DiskOnChip found\n"); 2091 2062 err_probe: 2092 2092 - free_bch(docg3_bch); 2063 2063 + kfree(cascade->bch); 2093 2064 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) 2094 2094 - if (docg3_floors[floor]) 2095 2095 - doc_release_device(docg3_floors[floor]); 2065 2065 + if (cascade->floors[floor]) 2066 2066 + doc_release_device(cascade->floors[floor]); 2096 2067 nomem2: 2097 2097 - kfree(docg3_floors); 2068 2068 + kfree(cascade); 2098 2069 nomem1: 2099 2070 iounmap(base); 2100 2071 noress: ··· 2109 2080 */ 2110 2081 static int __exit docg3_release(struct platform_device *pdev) 2111 2082 { 2112 2112 - struct mtd_info **docg3_floors = platform_get_drvdata(pdev); 2113 2113 - struct docg3 *docg3 = docg3_floors[0]->priv; 2114 2114 - void __iomem *base = docg3->base; 2083 2083 + struct docg3_cascade *cascade = platform_get_drvdata(pdev); 2084 2084 + struct docg3 *docg3 = cascade->floors[0]->priv; 2085 2085 + void __iomem *base = cascade->base; 2115 2086 int floor; 2116 2087 2117 2117 - doc_unregister_sysfs(pdev, docg3_floors); 2088 2088 + doc_unregister_sysfs(pdev, cascade); 2118 2089 doc_dbg_unregister(docg3); 2119 2090 for (floor = 0; floor < DOC_MAX_NBFLOORS; floor++) 2120 2120 - if (docg3_floors[floor]) 2121 2121 - doc_release_device(docg3_floors[floor]); 2091 2091 + if (cascade->floors[floor]) 2092 2092 + doc_release_device(cascade->floors[floor]); 2122 2093 2123 2123 - kfree(docg3_floors); 2124 2124 - free_bch(docg3_bch); 2094 2094 + free_bch(docg3->cascade->bch); 2095 2095 + kfree(cascade); 2125 2096 iounmap(base); 2126 2097 return 0; 2127 2098 }

+18 -2

drivers/mtd/devices/docg3.h

reviewed

··· 22 22 #ifndef _MTD_DOCG3_H 23 23 #define _MTD_DOCG3_H 24 24 25 25 + #include <linux/mtd/mtd.h> 26 26 + 25 27 /* 26 28 * Flash memory areas : 27 29 * - 0x0000 .. 0x07ff : IPL ··· 269 267 #define DOC_LAYOUT_DPS_KEY_LENGTH 8 270 268 271 269 /** 270 270 + * struct docg3_cascade - Cascade of 1 to 4 docg3 chips 271 271 + * @floors: floors (ie. one physical docg3 chip is one floor) 272 272 + * @base: IO space to access all chips in the cascade 273 273 + * @bch: the BCH correcting control structure 274 274 + * @lock: lock to protect docg3 IO space from concurrent accesses 275 275 + */ 276 276 + struct docg3_cascade { 277 277 + struct mtd_info *floors[DOC_MAX_NBFLOORS]; 278 278 + void __iomem *base; 279 279 + struct bch_control *bch; 280 280 + struct mutex lock; 281 281 + }; 282 282 + 283 283 + /** 272 284 * struct docg3 - DiskOnChip driver private data 273 285 * @dev: the device currently under control 274 274 - * @base: mapped IO space 286 286 + * @cascade: the cascade this device belongs to 275 287 * @device_id: number of the cascaded DoCG3 device (0, 1, 2 or 3) 276 288 * @if_cfg: if true, reads are on 16bits, else reads are on 8bits 277 289 ··· 303 287 */ 304 288 struct docg3 { 305 289 struct device *dev; 306 306 - void __iomem *base; 290 290 + struct docg3_cascade *cascade; 307 291 unsigned int device_id:4; 308 292 unsigned int if_cfg:1; 309 293 unsigned int reliable:2;

+4 -13

drivers/mtd/devices/lart.c

reviewed

··· 367 367 printk (KERN_DEBUG "%s(addr = 0x%.8x, len = %d)\n", __func__, instr->addr, instr->len); 368 368 #endif 369 369 370 370 - /* sanity checks */ 371 371 - if (instr->addr + instr->len > mtd->size) return (-EINVAL); 372 372 - 373 370 /* 374 371 * check that both start and end of the requested erase are 375 372 * aligned with the erasesize at the appropriate addresses. ··· 436 439 #ifdef LART_DEBUG 437 440 printk (KERN_DEBUG "%s(from = 0x%.8x, len = %d)\n", __func__, (__u32)from, len); 438 441 #endif 439 439 - 440 440 - /* sanity checks */ 441 441 - if (!len) return (0); 442 442 - if (from + len > mtd->size) return (-EINVAL); 443 442 444 443 /* we always read len bytes */ 445 444 *retlen = len; ··· 515 522 printk (KERN_DEBUG "%s(to = 0x%.8x, len = %d)\n", __func__, (__u32)to, len); 516 523 #endif 517 524 518 518 - *retlen = 0; 519 519 - 520 525 /* sanity checks */ 521 526 if (!len) return (0); 522 522 - if (to + len > mtd->size) return (-EINVAL); 523 527 524 528 /* first, we write a 0xFF.... padded byte until we reach a dword boundary */ 525 529 if (to & (BUSWIDTH - 1)) ··· 620 630 mtd.name = module_name; 621 631 mtd.type = MTD_NORFLASH; 622 632 mtd.writesize = 1; 633 633 + mtd.writebufsize = 4; 623 634 mtd.flags = MTD_CAP_NORFLASH; 624 635 mtd.size = FLASH_BLOCKSIZE_PARAM * FLASH_NUMBLOCKS_16m_PARAM + FLASH_BLOCKSIZE_MAIN * FLASH_NUMBLOCKS_16m_MAIN; 625 636 mtd.erasesize = FLASH_BLOCKSIZE_MAIN; 626 637 mtd.numeraseregions = ARRAY_SIZE(erase_regions); 627 638 mtd.eraseregions = erase_regions; 628 628 - mtd.erase = flash_erase; 629 629 - mtd.read = flash_read; 630 630 - mtd.write = flash_write; 639 639 + mtd._erase = flash_erase; 640 640 + mtd._read = flash_read; 641 641 + mtd._write = flash_write; 631 642 mtd.owner = THIS_MODULE; 632 643 633 644 #ifdef LART_DEBUG

+6 -50

drivers/mtd/devices/m25p80.c

reviewed

··· 288 288 __func__, (long long)instr->addr, 289 289 (long long)instr->len); 290 290 291 291 - /* sanity checks */ 292 292 - if (instr->addr + instr->len > flash->mtd.size) 293 293 - return -EINVAL; 294 291 div_u64_rem(instr->len, mtd->erasesize, &rem); 295 292 if (rem) 296 293 return -EINVAL; ··· 346 349 pr_debug("%s: %s from 0x%08x, len %zd\n", dev_name(&flash->spi->dev), 347 350 __func__, (u32)from, len); 348 351 349 349 - /* sanity checks */ 350 350 - if (!len) 351 351 - return 0; 352 352 - 353 353 - if (from + len > flash->mtd.size) 354 354 - return -EINVAL; 355 355 - 356 352 spi_message_init(&m); 357 353 memset(t, 0, (sizeof t)); 358 354 ··· 360 370 t[1].rx_buf = buf; 361 371 t[1].len = len; 362 372 spi_message_add_tail(&t[1], &m); 363 363 - 364 364 - /* Byte count starts at zero. */ 365 365 - *retlen = 0; 366 373 367 374 mutex_lock(&flash->lock); 368 375 ··· 403 416 404 417 pr_debug("%s: %s to 0x%08x, len %zd\n", dev_name(&flash->spi->dev), 405 418 __func__, (u32)to, len); 406 406 - 407 407 - *retlen = 0; 408 408 - 409 409 - /* sanity checks */ 410 410 - if (!len) 411 411 - return(0); 412 412 - 413 413 - if (to + len > flash->mtd.size) 414 414 - return -EINVAL; 415 419 416 420 spi_message_init(&m); 417 421 memset(t, 0, (sizeof t)); ··· 486 508 487 509 pr_debug("%s: %s to 0x%08x, len %zd\n", dev_name(&flash->spi->dev), 488 510 __func__, (u32)to, len); 489 489 - 490 490 - *retlen = 0; 491 491 - 492 492 - /* sanity checks */ 493 493 - if (!len) 494 494 - return 0; 495 495 - 496 496 - if (to + len > flash->mtd.size) 497 497 - return -EINVAL; 498 511 499 512 spi_message_init(&m); 500 513 memset(t, 0, (sizeof t)); ··· 877 908 flash->mtd.writesize = 1; 878 909 flash->mtd.flags = MTD_CAP_NORFLASH; 879 910 flash->mtd.size = info->sector_size * info->n_sectors; 880 880 - flash->mtd.erase = m25p80_erase; 881 881 - flash->mtd.read = m25p80_read; 911 911 + flash->mtd._erase = m25p80_erase; 912 912 + flash->mtd._read = m25p80_read; 882 913 883 914 /* sst flash chips use AAI word program */ 884 915 if (JEDEC_MFR(info->jedec_id) == CFI_MFR_SST) 885 885 - flash->mtd.write = sst_write; 916 916 + flash->mtd._write = sst_write; 886 917 else 887 887 - flash->mtd.write = m25p80_write; 918 918 + flash->mtd._write = m25p80_write; 888 919 889 920 /* prefer "small sector" erase if possible */ 890 921 if (info->flags & SECT_4K) { ··· 901 932 ppdata.of_node = spi->dev.of_node; 902 933 flash->mtd.dev.parent = &spi->dev; 903 934 flash->page_size = info->page_size; 935 935 + flash->mtd.writebufsize = flash->page_size; 904 936 905 937 if (info->addr_width) 906 938 flash->addr_width = info->addr_width; ··· 974 1004 */ 975 1005 }; 976 1006 977 977 - 978 978 - static int __init m25p80_init(void) 979 979 - { 980 980 - return spi_register_driver(&m25p80_driver); 981 981 - } 982 982 - 983 983 - 984 984 - static void __exit m25p80_exit(void) 985 985 - { 986 986 - spi_unregister_driver(&m25p80_driver); 987 987 - } 988 988 - 989 989 - 990 990 - module_init(m25p80_init); 991 991 - module_exit(m25p80_exit); 1007 1007 + module_spi_driver(m25p80_driver); 992 1008 993 1009 MODULE_LICENSE("GPL"); 994 1010 MODULE_AUTHOR("Mike Lavender");

+2 -10

drivers/mtd/devices/ms02-nv.c

reviewed

··· 59 59 { 60 60 struct ms02nv_private *mp = mtd->priv; 61 61 62 62 - if (from + len > mtd->size) 63 63 - return -EINVAL; 64 64 - 65 62 memcpy(buf, mp->uaddr + from, len); 66 63 *retlen = len; 67 67 - 68 64 return 0; 69 65 } 70 66 ··· 69 73 { 70 74 struct ms02nv_private *mp = mtd->priv; 71 75 72 72 - if (to + len > mtd->size) 73 73 - return -EINVAL; 74 74 - 75 76 memcpy(mp->uaddr + to, buf, len); 76 77 *retlen = len; 77 77 - 78 78 return 0; 79 79 } 80 80 ··· 207 215 mtd->size = fixsize; 208 216 mtd->name = (char *)ms02nv_name; 209 217 mtd->owner = THIS_MODULE; 210 210 - mtd->read = ms02nv_read; 211 211 - mtd->write = ms02nv_write; 218 218 + mtd->_read = ms02nv_read; 219 219 + mtd->_write = ms02nv_write; 212 220 mtd->writesize = 1; 213 221 214 222 ret = -EIO;

+9 -41

drivers/mtd/devices/mtd_dataflash.c

reviewed

··· 164 164 dev_name(&spi->dev), (long long)instr->addr, 165 165 (long long)instr->len); 166 166 167 167 - /* Sanity checks */ 168 168 - if (instr->addr + instr->len > mtd->size) 169 169 - return -EINVAL; 170 167 div_u64_rem(instr->len, priv->page_size, &rem); 171 168 if (rem) 172 169 return -EINVAL; ··· 249 252 pr_debug("%s: read 0x%x..0x%x\n", dev_name(&priv->spi->dev), 250 253 (unsigned)from, (unsigned)(from + len)); 251 254 252 252 - *retlen = 0; 253 253 - 254 254 - /* Sanity checks */ 255 255 - if (!len) 256 256 - return 0; 257 257 - if (from + len > mtd->size) 258 258 - return -EINVAL; 259 259 - 260 255 /* Calculate flash page/byte address */ 261 256 addr = (((unsigned)from / priv->page_size) << priv->page_offset) 262 257 + ((unsigned)from % priv->page_size); ··· 316 327 317 328 pr_debug("%s: write 0x%x..0x%x\n", 318 329 dev_name(&spi->dev), (unsigned)to, (unsigned)(to + len)); 319 319 - 320 320 - *retlen = 0; 321 321 - 322 322 - /* Sanity checks */ 323 323 - if (!len) 324 324 - return 0; 325 325 - if ((to + len) > mtd->size) 326 326 - return -EINVAL; 327 330 328 331 spi_message_init(&msg); 329 332 ··· 471 490 472 491 if ((off + len) > 64) 473 492 len = 64 - off; 474 474 - if (len == 0) 475 475 - return len; 476 493 477 494 spi_message_init(&m); 478 495 ··· 590 611 591 612 static char *otp_setup(struct mtd_info *device, char revision) 592 613 { 593 593 - device->get_fact_prot_info = dataflash_get_otp_info; 594 594 - device->read_fact_prot_reg = dataflash_read_fact_otp; 595 595 - device->get_user_prot_info = dataflash_get_otp_info; 596 596 - device->read_user_prot_reg = dataflash_read_user_otp; 614 614 + device->_get_fact_prot_info = dataflash_get_otp_info; 615 615 + device->_read_fact_prot_reg = dataflash_read_fact_otp; 616 616 + device->_get_user_prot_info = dataflash_get_otp_info; 617 617 + device->_read_user_prot_reg = dataflash_read_user_otp; 597 618 598 619 /* rev c parts (at45db321c and at45db1281 only!) use a 599 620 * different write procedure; not (yet?) implemented. 600 621 */ 601 622 if (revision > 'c') 602 602 - device->write_user_prot_reg = dataflash_write_user_otp; 623 623 + device->_write_user_prot_reg = dataflash_write_user_otp; 603 624 604 625 return ", OTP"; 605 626 } ··· 651 672 device->owner = THIS_MODULE; 652 673 device->type = MTD_DATAFLASH; 653 674 device->flags = MTD_WRITEABLE; 654 654 - device->erase = dataflash_erase; 655 655 - device->read = dataflash_read; 656 656 - device->write = dataflash_write; 675 675 + device->_erase = dataflash_erase; 676 676 + device->_read = dataflash_read; 677 677 + device->_write = dataflash_write; 657 678 device->priv = priv; 658 679 659 680 device->dev.parent = &spi->dev; ··· 925 946 /* FIXME: investigate suspend and resume... */ 926 947 }; 927 948 928 928 - static int __init dataflash_init(void) 929 929 - { 930 930 - return spi_register_driver(&dataflash_driver); 931 931 - } 932 932 - module_init(dataflash_init); 933 933 - 934 934 - static void __exit dataflash_exit(void) 935 935 - { 936 936 - spi_unregister_driver(&dataflash_driver); 937 937 - } 938 938 - module_exit(dataflash_exit); 939 939 - 949 949 + module_spi_driver(dataflash_driver); 940 950 941 951 MODULE_LICENSE("GPL"); 942 952 MODULE_AUTHOR("Andrew Victor, David Brownell");

+8 -27

drivers/mtd/devices/mtdram.c

reviewed

··· 34 34 35 35 static int ram_erase(struct mtd_info *mtd, struct erase_info *instr) 36 36 { 37 37 - if (instr->addr + instr->len > mtd->size) 38 38 - return -EINVAL; 39 39 - 40 37 memset((char *)mtd->priv + instr->addr, 0xff, instr->len); 41 41 - 42 38 instr->state = MTD_ERASE_DONE; 43 39 mtd_erase_callback(instr); 44 44 - 45 40 return 0; 46 41 } 47 42 48 43 static int ram_point(struct mtd_info *mtd, loff_t from, size_t len, 49 44 size_t *retlen, void **virt, resource_size_t *phys) 50 45 { 51 51 - if (from + len > mtd->size) 52 52 - return -EINVAL; 53 53 - 54 54 - /* can we return a physical address with this driver? */ 55 55 - if (phys) 56 56 - return -EINVAL; 57 57 - 58 46 *virt = mtd->priv + from; 59 47 *retlen = len; 60 48 return 0; 61 49 } 62 50 63 63 - static void ram_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 51 51 + static int ram_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 64 52 { 53 53 + return 0; 65 54 } 66 55 67 56 /* ··· 69 80 static int ram_read(struct mtd_info *mtd, loff_t from, size_t len, 70 81 size_t *retlen, u_char *buf) 71 82 { 72 72 - if (from + len > mtd->size) 73 73 - return -EINVAL; 74 74 - 75 83 memcpy(buf, mtd->priv + from, len); 76 76 - 77 84 *retlen = len; 78 85 return 0; 79 86 } ··· 77 92 static int ram_write(struct mtd_info *mtd, loff_t to, size_t len, 78 93 size_t *retlen, const u_char *buf) 79 94 { 80 80 - if (to + len > mtd->size) 81 81 - return -EINVAL; 82 82 - 83 95 memcpy((char *)mtd->priv + to, buf, len); 84 84 - 85 96 *retlen = len; 86 97 return 0; 87 98 } ··· 107 126 mtd->priv = mapped_address; 108 127 109 128 mtd->owner = THIS_MODULE; 110 110 - mtd->erase = ram_erase; 111 111 - mtd->point = ram_point; 112 112 - mtd->unpoint = ram_unpoint; 113 113 - mtd->get_unmapped_area = ram_get_unmapped_area; 114 114 - mtd->read = ram_read; 115 115 - mtd->write = ram_write; 129 129 + mtd->_erase = ram_erase; 130 130 + mtd->_point = ram_point; 131 131 + mtd->_unpoint = ram_unpoint; 132 132 + mtd->_get_unmapped_area = ram_get_unmapped_area; 133 133 + mtd->_read = ram_read; 134 134 + mtd->_write = ram_write; 116 135 117 136 if (mtd_device_register(mtd, NULL, 0)) 118 137 return -EIO;

+37 -39

drivers/mtd/devices/phram.c

reviewed

··· 33 33 34 34 static LIST_HEAD(phram_list); 35 35 36 36 - 37 36 static int phram_erase(struct mtd_info *mtd, struct erase_info *instr) 38 37 { 39 38 u_char *start = mtd->priv; 40 39 41 41 - if (instr->addr + instr->len > mtd->size) 42 42 - return -EINVAL; 43 43 - 44 40 memset(start + instr->addr, 0xff, instr->len); 45 41 46 46 - /* This'll catch a few races. Free the thing before returning :) 42 42 + /* 43 43 + * This'll catch a few races. Free the thing before returning :) 47 44 * I don't feel at all ashamed. This kind of thing is possible anyway 48 45 * with flash, but unlikely. 49 46 */ 50 50 - 51 47 instr->state = MTD_ERASE_DONE; 52 52 - 53 48 mtd_erase_callback(instr); 54 54 - 55 49 return 0; 56 50 } 57 51 58 52 static int phram_point(struct mtd_info *mtd, loff_t from, size_t len, 59 53 size_t *retlen, void **virt, resource_size_t *phys) 60 54 { 61 61 - if (from + len > mtd->size) 62 62 - return -EINVAL; 63 63 - 64 64 - /* can we return a physical address with this driver? */ 65 65 - if (phys) 66 66 - return -EINVAL; 67 67 - 68 55 *virt = mtd->priv + from; 69 56 *retlen = len; 70 57 return 0; 71 58 } 72 59 73 73 - static void phram_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 60 60 + static int phram_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 74 61 { 62 62 + return 0; 75 63 } 76 64 77 65 static int phram_read(struct mtd_info *mtd, loff_t from, size_t len, ··· 67 79 { 68 80 u_char *start = mtd->priv; 69 81 70 70 - if (from >= mtd->size) 71 71 - return -EINVAL; 72 72 - 73 73 - if (len > mtd->size - from) 74 74 - len = mtd->size - from; 75 75 - 76 82 memcpy(buf, start + from, len); 77 77 - 78 83 *retlen = len; 79 84 return 0; 80 85 } ··· 77 96 { 78 97 u_char *start = mtd->priv; 79 98 80 80 - if (to >= mtd->size) 81 81 - return -EINVAL; 82 82 - 83 83 - if (len > mtd->size - to) 84 84 - len = mtd->size - to; 85 85 - 86 99 memcpy(start + to, buf, len); 87 87 - 88 100 *retlen = len; 89 101 return 0; 90 102 } 91 91 - 92 92 - 93 103 94 104 static void unregister_devices(void) 95 105 { ··· 114 142 new->mtd.name = name; 115 143 new->mtd.size = len; 116 144 new->mtd.flags = MTD_CAP_RAM; 117 117 - new->mtd.erase = phram_erase; 118 118 - new->mtd.point = phram_point; 119 119 - new->mtd.unpoint = phram_unpoint; 120 120 - new->mtd.read = phram_read; 121 121 - new->mtd.write = phram_write; 145 145 + new->mtd._erase = phram_erase; 146 146 + new->mtd._point = phram_point; 147 147 + new->mtd._unpoint = phram_unpoint; 148 148 + new->mtd._read = phram_read; 149 149 + new->mtd._write = phram_write; 122 150 new->mtd.owner = THIS_MODULE; 123 151 new->mtd.type = MTD_RAM; 124 152 new->mtd.erasesize = PAGE_SIZE; ··· 205 233 return 1; \ 206 234 } while (0) 207 235 208 208 - static int phram_setup(const char *val, struct kernel_param *kp) 236 236 + /* 237 237 + * This shall contain the module parameter if any. It is of the form: 238 238 + * - phram=<device>,<address>,<size> for module case 239 239 + * - phram.phram=<device>,<address>,<size> for built-in case 240 240 + * We leave 64 bytes for the device name, 12 for the address and 12 for the 241 241 + * size. 242 242 + * Example: phram.phram=rootfs,0xa0000000,512Mi 243 243 + */ 244 244 + static __initdata char phram_paramline[64+12+12]; 245 245 + 246 246 + static int __init phram_setup(const char *val) 209 247 { 210 248 char buf[64+12+12], *str = buf; 211 249 char *token[3]; ··· 264 282 return ret; 265 283 } 266 284 267 267 - module_param_call(phram, phram_setup, NULL, NULL, 000); 285 285 + static int __init phram_param_call(const char *val, struct kernel_param *kp) 286 286 + { 287 287 + /* 288 288 + * This function is always called before 'init_phram()', whether 289 289 + * built-in or module. 290 290 + */ 291 291 + if (strlen(val) >= sizeof(phram_paramline)) 292 292 + return -ENOSPC; 293 293 + strcpy(phram_paramline, val); 294 294 + 295 295 + return 0; 296 296 + } 297 297 + 298 298 + module_param_call(phram, phram_param_call, NULL, NULL, 000); 268 299 MODULE_PARM_DESC(phram, "Memory region to map. \"phram=<name>,<start>,<length>\""); 269 300 270 301 271 302 static int __init init_phram(void) 272 303 { 304 304 + if (phram_paramline[0]) 305 305 + return phram_setup(phram_paramline); 306 306 + 273 307 return 0; 274 308 } 275 309

+47 -52

drivers/mtd/devices/pmc551.c

reviewed

··· 94 94 #include <linux/ioctl.h> 95 95 #include <asm/io.h> 96 96 #include <linux/pci.h> 97 97 - 98 97 #include <linux/mtd/mtd.h> 99 99 - #include <linux/mtd/pmc551.h> 98 98 + 99 99 + #define PMC551_VERSION \ 100 100 + "Ramix PMC551 PCI Mezzanine Ram Driver. (C) 1999,2000 Nortel Networks.\n" 101 101 + 102 102 + #define PCI_VENDOR_ID_V3_SEMI 0x11b0 103 103 + #define PCI_DEVICE_ID_V3_SEMI_V370PDC 0x0200 104 104 + 105 105 + #define PMC551_PCI_MEM_MAP0 0x50 106 106 + #define PMC551_PCI_MEM_MAP1 0x54 107 107 + #define PMC551_PCI_MEM_MAP_MAP_ADDR_MASK 0x3ff00000 108 108 + #define PMC551_PCI_MEM_MAP_APERTURE_MASK 0x000000f0 109 109 + #define PMC551_PCI_MEM_MAP_REG_EN 0x00000002 110 110 + #define PMC551_PCI_MEM_MAP_ENABLE 0x00000001 111 111 + 112 112 + #define PMC551_SDRAM_MA 0x60 113 113 + #define PMC551_SDRAM_CMD 0x62 114 114 + #define PMC551_DRAM_CFG 0x64 115 115 + #define PMC551_SYS_CTRL_REG 0x78 116 116 + 117 117 + #define PMC551_DRAM_BLK0 0x68 118 118 + #define PMC551_DRAM_BLK1 0x6c 119 119 + #define PMC551_DRAM_BLK2 0x70 120 120 + #define PMC551_DRAM_BLK3 0x74 121 121 + #define PMC551_DRAM_BLK_GET_SIZE(x) (524288 << ((x >> 4) & 0x0f)) 122 122 + #define PMC551_DRAM_BLK_SET_COL_MUX(x, v) (((x) & ~0x00007000) | (((v) & 0x7) << 12)) 123 123 + #define PMC551_DRAM_BLK_SET_ROW_MUX(x, v) (((x) & ~0x00000f00) | (((v) & 0xf) << 8)) 124 124 + 125 125 + struct mypriv { 126 126 + struct pci_dev *dev; 127 127 + u_char *start; 128 128 + u32 base_map0; 129 129 + u32 curr_map0; 130 130 + u32 asize; 131 131 + struct mtd_info *nextpmc551; 132 132 + }; 100 133 101 134 static struct mtd_info *pmc551list; 135 135 + 136 136 + static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len, 137 137 + size_t *retlen, void **virt, resource_size_t *phys); 102 138 103 139 static int pmc551_erase(struct mtd_info *mtd, struct erase_info *instr) 104 140 { ··· 151 115 #endif 152 116 153 117 end = instr->addr + instr->len - 1; 154 154 - 155 155 - /* Is it past the end? */ 156 156 - if (end > mtd->size) { 157 157 - #ifdef CONFIG_MTD_PMC551_DEBUG 158 158 - printk(KERN_DEBUG "pmc551_erase() out of bounds (%ld > %ld)\n", 159 159 - (long)end, (long)mtd->size); 160 160 - #endif 161 161 - return -EINVAL; 162 162 - } 163 163 - 164 118 eoff_hi = end & ~(priv->asize - 1); 165 119 soff_hi = instr->addr & ~(priv->asize - 1); 166 120 eoff_lo = end & (priv->asize - 1); ··· 204 178 printk(KERN_DEBUG "pmc551_point(%ld, %ld)\n", (long)from, (long)len); 205 179 #endif 206 180 207 207 - if (from + len > mtd->size) { 208 208 - #ifdef CONFIG_MTD_PMC551_DEBUG 209 209 - printk(KERN_DEBUG "pmc551_point() out of bounds (%ld > %ld)\n", 210 210 - (long)from + len, (long)mtd->size); 211 211 - #endif 212 212 - return -EINVAL; 213 213 - } 214 214 - 215 215 - /* can we return a physical address with this driver? */ 216 216 - if (phys) 217 217 - return -EINVAL; 218 218 - 219 181 soff_hi = from & ~(priv->asize - 1); 220 182 soff_lo = from & (priv->asize - 1); 221 183 ··· 219 205 return 0; 220 206 } 221 207 222 222 - static void pmc551_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 208 208 + static int pmc551_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 223 209 { 224 210 #ifdef CONFIG_MTD_PMC551_DEBUG 225 211 printk(KERN_DEBUG "pmc551_unpoint()\n"); 226 212 #endif 213 213 + return 0; 227 214 } 228 215 229 216 static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len, ··· 243 228 #endif 244 229 245 230 end = from + len - 1; 246 246 - 247 247 - /* Is it past the end? */ 248 248 - if (end > mtd->size) { 249 249 - #ifdef CONFIG_MTD_PMC551_DEBUG 250 250 - printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)\n", 251 251 - (long)end, (long)mtd->size); 252 252 - #endif 253 253 - return -EINVAL; 254 254 - } 255 255 - 256 231 soff_hi = from & ~(priv->asize - 1); 257 232 eoff_hi = end & ~(priv->asize - 1); 258 233 soff_lo = from & (priv->asize - 1); ··· 300 295 #endif 301 296 302 297 end = to + len - 1; 303 303 - /* Is it past the end? or did the u32 wrap? */ 304 304 - if (end > mtd->size) { 305 305 - #ifdef CONFIG_MTD_PMC551_DEBUG 306 306 - printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, " 307 307 - "size: %ld, to: %ld)\n", (long)end, (long)mtd->size, 308 308 - (long)to); 309 309 - #endif 310 310 - return -EINVAL; 311 311 - } 312 312 - 313 298 soff_hi = to & ~(priv->asize - 1); 314 299 eoff_hi = end & ~(priv->asize - 1); 315 300 soff_lo = to & (priv->asize - 1); ··· 353 358 * mechanism 354 359 * returns the size of the memory region found. 355 360 */ 356 356 - static u32 fixup_pmc551(struct pci_dev *dev) 361 361 + static int fixup_pmc551(struct pci_dev *dev) 357 362 { 358 363 #ifdef CONFIG_MTD_PMC551_BUGFIX 359 364 u32 dram_data; ··· 663 668 struct mypriv *priv; 664 669 int found = 0; 665 670 struct mtd_info *mtd; 666 666 - u32 length = 0; 671 671 + int length = 0; 667 672 668 673 if (msize) { 669 674 msize = (1 << (ffs(msize) - 1)) << 20; ··· 781 786 782 787 mtd->size = msize; 783 788 mtd->flags = MTD_CAP_RAM; 784 784 - mtd->erase = pmc551_erase; 785 785 - mtd->read = pmc551_read; 786 786 - mtd->write = pmc551_write; 787 787 - mtd->point = pmc551_point; 788 788 - mtd->unpoint = pmc551_unpoint; 789 789 + mtd->_erase = pmc551_erase; 790 790 + mtd->_read = pmc551_read; 791 791 + mtd->_write = pmc551_write; 792 792 + mtd->_point = pmc551_point; 793 793 + mtd->_unpoint = pmc551_unpoint; 789 794 mtd->type = MTD_RAM; 790 795 mtd->name = "PMC551 RAM board"; 791 796 mtd->erasesize = 0x10000;

+8 -33

drivers/mtd/devices/slram.c

reviewed

··· 75 75 static int slram_erase(struct mtd_info *, struct erase_info *); 76 76 static int slram_point(struct mtd_info *, loff_t, size_t, size_t *, void **, 77 77 resource_size_t *); 78 78 - static void slram_unpoint(struct mtd_info *, loff_t, size_t); 78 78 + static int slram_unpoint(struct mtd_info *, loff_t, size_t); 79 79 static int slram_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *); 80 80 static int slram_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *); 81 81 ··· 83 83 { 84 84 slram_priv_t *priv = mtd->priv; 85 85 86 86 - if (instr->addr + instr->len > mtd->size) { 87 87 - return(-EINVAL); 88 88 - } 89 89 - 90 86 memset(priv->start + instr->addr, 0xff, instr->len); 91 91 - 92 87 /* This'll catch a few races. Free the thing before returning :) 93 88 * I don't feel at all ashamed. This kind of thing is possible anyway 94 89 * with flash, but unlikely. 95 90 */ 96 96 - 97 91 instr->state = MTD_ERASE_DONE; 98 98 - 99 92 mtd_erase_callback(instr); 100 100 - 101 93 return(0); 102 94 } 103 95 ··· 98 106 { 99 107 slram_priv_t *priv = mtd->priv; 100 108 101 101 - /* can we return a physical address with this driver? */ 102 102 - if (phys) 103 103 - return -EINVAL; 104 104 - 105 105 - if (from + len > mtd->size) 106 106 - return -EINVAL; 107 107 - 108 109 *virt = priv->start + from; 109 110 *retlen = len; 110 111 return(0); 111 112 } 112 113 113 113 - static void slram_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 114 114 + static int slram_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 114 115 { 116 116 + return 0; 115 117 } 116 118 117 119 static int slram_read(struct mtd_info *mtd, loff_t from, size_t len, ··· 113 127 { 114 128 slram_priv_t *priv = mtd->priv; 115 129 116 116 - if (from > mtd->size) 117 117 - return -EINVAL; 118 118 - 119 119 - if (from + len > mtd->size) 120 120 - len = mtd->size - from; 121 121 - 122 130 memcpy(buf, priv->start + from, len); 123 123 - 124 131 *retlen = len; 125 132 return(0); 126 133 } ··· 123 144 { 124 145 slram_priv_t *priv = mtd->priv; 125 146 126 126 - if (to + len > mtd->size) 127 127 - return -EINVAL; 128 128 - 129 147 memcpy(priv->start + to, buf, len); 130 130 - 131 148 *retlen = len; 132 149 return(0); 133 150 } ··· 174 199 (*curmtd)->mtdinfo->name = name; 175 200 (*curmtd)->mtdinfo->size = length; 176 201 (*curmtd)->mtdinfo->flags = MTD_CAP_RAM; 177 177 - (*curmtd)->mtdinfo->erase = slram_erase; 178 178 - (*curmtd)->mtdinfo->point = slram_point; 179 179 - (*curmtd)->mtdinfo->unpoint = slram_unpoint; 180 180 - (*curmtd)->mtdinfo->read = slram_read; 181 181 - (*curmtd)->mtdinfo->write = slram_write; 202 202 + (*curmtd)->mtdinfo->_erase = slram_erase; 203 203 + (*curmtd)->mtdinfo->_point = slram_point; 204 204 + (*curmtd)->mtdinfo->_unpoint = slram_unpoint; 205 205 + (*curmtd)->mtdinfo->_read = slram_read; 206 206 + (*curmtd)->mtdinfo->_write = slram_write; 182 207 (*curmtd)->mtdinfo->owner = THIS_MODULE; 183 208 (*curmtd)->mtdinfo->type = MTD_RAM; 184 209 (*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ;

+1147

drivers/mtd/devices/spear_smi.c

reviewed

··· 1 1 + /* 2 2 + * SMI (Serial Memory Controller) device driver for Serial NOR Flash on 3 3 + * SPEAr platform 4 4 + * The serial nor interface is largely based on drivers/mtd/m25p80.c, 5 5 + * however the SPI interface has been replaced by SMI. 6 6 + * 7 7 + * Copyright © 2010 STMicroelectronics. 8 8 + * Ashish Priyadarshi 9 9 + * Shiraz Hashim <shiraz.hashim@st.com> 10 10 + * 11 11 + * This file is licensed under the terms of the GNU General Public 12 12 + * License version 2. This program is licensed "as is" without any 13 13 + * warranty of any kind, whether express or implied. 14 14 + */ 15 15 + 16 16 + #include <linux/clk.h> 17 17 + #include <linux/delay.h> 18 18 + #include <linux/device.h> 19 19 + #include <linux/err.h> 20 20 + #include <linux/errno.h> 21 21 + #include <linux/interrupt.h> 22 22 + #include <linux/io.h> 23 23 + #include <linux/ioport.h> 24 24 + #include <linux/jiffies.h> 25 25 + #include <linux/kernel.h> 26 26 + #include <linux/module.h> 27 27 + #include <linux/param.h> 28 28 + #include <linux/platform_device.h> 29 29 + #include <linux/mtd/mtd.h> 30 30 + #include <linux/mtd/partitions.h> 31 31 + #include <linux/mtd/spear_smi.h> 32 32 + #include <linux/mutex.h> 33 33 + #include <linux/sched.h> 34 34 + #include <linux/slab.h> 35 35 + #include <linux/wait.h> 36 36 + #include <linux/of.h> 37 37 + #include <linux/of_address.h> 38 38 + 39 39 + /* SMI clock rate */ 40 40 + #define SMI_MAX_CLOCK_FREQ 50000000 /* 50 MHz */ 41 41 + 42 42 + /* MAX time out to safely come out of a erase or write busy conditions */ 43 43 + #define SMI_PROBE_TIMEOUT (HZ / 10) 44 44 + #define SMI_MAX_TIME_OUT (3 * HZ) 45 45 + 46 46 + /* timeout for command completion */ 47 47 + #define SMI_CMD_TIMEOUT (HZ / 10) 48 48 + 49 49 + /* registers of smi */ 50 50 + #define SMI_CR1 0x0 /* SMI control register 1 */ 51 51 + #define SMI_CR2 0x4 /* SMI control register 2 */ 52 52 + #define SMI_SR 0x8 /* SMI status register */ 53 53 + #define SMI_TR 0xC /* SMI transmit register */ 54 54 + #define SMI_RR 0x10 /* SMI receive register */ 55 55 + 56 56 + /* defines for control_reg 1 */ 57 57 + #define BANK_EN (0xF << 0) /* enables all banks */ 58 58 + #define DSEL_TIME (0x6 << 4) /* Deselect time 6 + 1 SMI_CK periods */ 59 59 + #define SW_MODE (0x1 << 28) /* enables SW Mode */ 60 60 + #define WB_MODE (0x1 << 29) /* Write Burst Mode */ 61 61 + #define FAST_MODE (0x1 << 15) /* Fast Mode */ 62 62 + #define HOLD1 (0x1 << 16) /* Clock Hold period selection */ 63 63 + 64 64 + /* defines for control_reg 2 */ 65 65 + #define SEND (0x1 << 7) /* Send data */ 66 66 + #define TFIE (0x1 << 8) /* Transmission Flag Interrupt Enable */ 67 67 + #define WCIE (0x1 << 9) /* Write Complete Interrupt Enable */ 68 68 + #define RD_STATUS_REG (0x1 << 10) /* reads status reg */ 69 69 + #define WE (0x1 << 11) /* Write Enable */ 70 70 + 71 71 + #define TX_LEN_SHIFT 0 72 72 + #define RX_LEN_SHIFT 4 73 73 + #define BANK_SHIFT 12 74 74 + 75 75 + /* defines for status register */ 76 76 + #define SR_WIP 0x1 /* Write in progress */ 77 77 + #define SR_WEL 0x2 /* Write enable latch */ 78 78 + #define SR_BP0 0x4 /* Block protect 0 */ 79 79 + #define SR_BP1 0x8 /* Block protect 1 */ 80 80 + #define SR_BP2 0x10 /* Block protect 2 */ 81 81 + #define SR_SRWD 0x80 /* SR write protect */ 82 82 + #define TFF 0x100 /* Transfer Finished Flag */ 83 83 + #define WCF 0x200 /* Transfer Finished Flag */ 84 84 + #define ERF1 0x400 /* Forbidden Write Request */ 85 85 + #define ERF2 0x800 /* Forbidden Access */ 86 86 + 87 87 + #define WM_SHIFT 12 88 88 + 89 89 + /* flash opcodes */ 90 90 + #define OPCODE_RDID 0x9f /* Read JEDEC ID */ 91 91 + 92 92 + /* Flash Device Ids maintenance section */ 93 93 + 94 94 + /* data structure to maintain flash ids from different vendors */ 95 95 + struct flash_device { 96 96 + char *name; 97 97 + u8 erase_cmd; 98 98 + u32 device_id; 99 99 + u32 pagesize; 100 100 + unsigned long sectorsize; 101 101 + unsigned long size_in_bytes; 102 102 + }; 103 103 + 104 104 + #define FLASH_ID(n, es, id, psize, ssize, size) \ 105 105 + { \ 106 106 + .name = n, \ 107 107 + .erase_cmd = es, \ 108 108 + .device_id = id, \ 109 109 + .pagesize = psize, \ 110 110 + .sectorsize = ssize, \ 111 111 + .size_in_bytes = size \ 112 112 + } 113 113 + 114 114 + static struct flash_device flash_devices[] = { 115 115 + FLASH_ID("st m25p16" , 0xd8, 0x00152020, 0x100, 0x10000, 0x200000), 116 116 + FLASH_ID("st m25p32" , 0xd8, 0x00162020, 0x100, 0x10000, 0x400000), 117 117 + FLASH_ID("st m25p64" , 0xd8, 0x00172020, 0x100, 0x10000, 0x800000), 118 118 + FLASH_ID("st m25p128" , 0xd8, 0x00182020, 0x100, 0x40000, 0x1000000), 119 119 + FLASH_ID("st m25p05" , 0xd8, 0x00102020, 0x80 , 0x8000 , 0x10000), 120 120 + FLASH_ID("st m25p10" , 0xd8, 0x00112020, 0x80 , 0x8000 , 0x20000), 121 121 + FLASH_ID("st m25p20" , 0xd8, 0x00122020, 0x100, 0x10000, 0x40000), 122 122 + FLASH_ID("st m25p40" , 0xd8, 0x00132020, 0x100, 0x10000, 0x80000), 123 123 + FLASH_ID("st m25p80" , 0xd8, 0x00142020, 0x100, 0x10000, 0x100000), 124 124 + FLASH_ID("st m45pe10" , 0xd8, 0x00114020, 0x100, 0x10000, 0x20000), 125 125 + FLASH_ID("st m45pe20" , 0xd8, 0x00124020, 0x100, 0x10000, 0x40000), 126 126 + FLASH_ID("st m45pe40" , 0xd8, 0x00134020, 0x100, 0x10000, 0x80000), 127 127 + FLASH_ID("st m45pe80" , 0xd8, 0x00144020, 0x100, 0x10000, 0x100000), 128 128 + FLASH_ID("sp s25fl004" , 0xd8, 0x00120201, 0x100, 0x10000, 0x80000), 129 129 + FLASH_ID("sp s25fl008" , 0xd8, 0x00130201, 0x100, 0x10000, 0x100000), 130 130 + FLASH_ID("sp s25fl016" , 0xd8, 0x00140201, 0x100, 0x10000, 0x200000), 131 131 + FLASH_ID("sp s25fl032" , 0xd8, 0x00150201, 0x100, 0x10000, 0x400000), 132 132 + FLASH_ID("sp s25fl064" , 0xd8, 0x00160201, 0x100, 0x10000, 0x800000), 133 133 + FLASH_ID("atmel 25f512" , 0x52, 0x0065001F, 0x80 , 0x8000 , 0x10000), 134 134 + FLASH_ID("atmel 25f1024" , 0x52, 0x0060001F, 0x100, 0x8000 , 0x20000), 135 135 + FLASH_ID("atmel 25f2048" , 0x52, 0x0063001F, 0x100, 0x10000, 0x40000), 136 136 + FLASH_ID("atmel 25f4096" , 0x52, 0x0064001F, 0x100, 0x10000, 0x80000), 137 137 + FLASH_ID("atmel 25fs040" , 0xd7, 0x0004661F, 0x100, 0x10000, 0x80000), 138 138 + FLASH_ID("mac 25l512" , 0xd8, 0x001020C2, 0x010, 0x10000, 0x10000), 139 139 + FLASH_ID("mac 25l1005" , 0xd8, 0x001120C2, 0x010, 0x10000, 0x20000), 140 140 + FLASH_ID("mac 25l2005" , 0xd8, 0x001220C2, 0x010, 0x10000, 0x40000), 141 141 + FLASH_ID("mac 25l4005" , 0xd8, 0x001320C2, 0x010, 0x10000, 0x80000), 142 142 + FLASH_ID("mac 25l4005a" , 0xd8, 0x001320C2, 0x010, 0x10000, 0x80000), 143 143 + FLASH_ID("mac 25l8005" , 0xd8, 0x001420C2, 0x010, 0x10000, 0x100000), 144 144 + FLASH_ID("mac 25l1605" , 0xd8, 0x001520C2, 0x100, 0x10000, 0x200000), 145 145 + FLASH_ID("mac 25l1605a" , 0xd8, 0x001520C2, 0x010, 0x10000, 0x200000), 146 146 + FLASH_ID("mac 25l3205" , 0xd8, 0x001620C2, 0x100, 0x10000, 0x400000), 147 147 + FLASH_ID("mac 25l3205a" , 0xd8, 0x001620C2, 0x100, 0x10000, 0x400000), 148 148 + FLASH_ID("mac 25l6405" , 0xd8, 0x001720C2, 0x100, 0x10000, 0x800000), 149 149 + }; 150 150 + 151 151 + /* Define spear specific structures */ 152 152 + 153 153 + struct spear_snor_flash; 154 154 + 155 155 + /** 156 156 + * struct spear_smi - Structure for SMI Device 157 157 + * 158 158 + * @clk: functional clock 159 159 + * @status: current status register of SMI. 160 160 + * @clk_rate: functional clock rate of SMI (default: SMI_MAX_CLOCK_FREQ) 161 161 + * @lock: lock to prevent parallel access of SMI. 162 162 + * @io_base: base address for registers of SMI. 163 163 + * @pdev: platform device 164 164 + * @cmd_complete: queue to wait for command completion of NOR-flash. 165 165 + * @num_flashes: number of flashes actually present on board. 166 166 + * @flash: separate structure for each Serial NOR-flash attached to SMI. 167 167 + */ 168 168 + struct spear_smi { 169 169 + struct clk *clk; 170 170 + u32 status; 171 171 + unsigned long clk_rate; 172 172 + struct mutex lock; 173 173 + void __iomem *io_base; 174 174 + struct platform_device *pdev; 175 175 + wait_queue_head_t cmd_complete; 176 176 + u32 num_flashes; 177 177 + struct spear_snor_flash *flash[MAX_NUM_FLASH_CHIP]; 178 178 + }; 179 179 + 180 180 + /** 181 181 + * struct spear_snor_flash - Structure for Serial NOR Flash 182 182 + * 183 183 + * @bank: Bank number(0, 1, 2, 3) for each NOR-flash. 184 184 + * @dev_id: Device ID of NOR-flash. 185 185 + * @lock: lock to manage flash read, write and erase operations 186 186 + * @mtd: MTD info for each NOR-flash. 187 187 + * @num_parts: Total number of partition in each bank of NOR-flash. 188 188 + * @parts: Partition info for each bank of NOR-flash. 189 189 + * @page_size: Page size of NOR-flash. 190 190 + * @base_addr: Base address of NOR-flash. 191 191 + * @erase_cmd: erase command may vary on different flash types 192 192 + * @fast_mode: flash supports read in fast mode 193 193 + */ 194 194 + struct spear_snor_flash { 195 195 + u32 bank; 196 196 + u32 dev_id; 197 197 + struct mutex lock; 198 198 + struct mtd_info mtd; 199 199 + u32 num_parts; 200 200 + struct mtd_partition *parts; 201 201 + u32 page_size; 202 202 + void __iomem *base_addr; 203 203 + u8 erase_cmd; 204 204 + u8 fast_mode; 205 205 + }; 206 206 + 207 207 + static inline struct spear_snor_flash *get_flash_data(struct mtd_info *mtd) 208 208 + { 209 209 + return container_of(mtd, struct spear_snor_flash, mtd); 210 210 + } 211 211 + 212 212 + /** 213 213 + * spear_smi_read_sr - Read status register of flash through SMI 214 214 + * @dev: structure of SMI information. 215 215 + * @bank: bank to which flash is connected 216 216 + * 217 217 + * This routine will return the status register of the flash chip present at the 218 218 + * given bank. 219 219 + */ 220 220 + static int spear_smi_read_sr(struct spear_smi *dev, u32 bank) 221 221 + { 222 222 + int ret; 223 223 + u32 ctrlreg1; 224 224 + 225 225 + mutex_lock(&dev->lock); 226 226 + dev->status = 0; /* Will be set in interrupt handler */ 227 227 + 228 228 + ctrlreg1 = readl(dev->io_base + SMI_CR1); 229 229 + /* program smi in hw mode */ 230 230 + writel(ctrlreg1 & ~(SW_MODE | WB_MODE), dev->io_base + SMI_CR1); 231 231 + 232 232 + /* performing a rsr instruction in hw mode */ 233 233 + writel((bank << BANK_SHIFT) | RD_STATUS_REG | TFIE, 234 234 + dev->io_base + SMI_CR2); 235 235 + 236 236 + /* wait for tff */ 237 237 + ret = wait_event_interruptible_timeout(dev->cmd_complete, 238 238 + dev->status & TFF, SMI_CMD_TIMEOUT); 239 239 + 240 240 + /* copy dev->status (lower 16 bits) in order to release lock */ 241 241 + if (ret > 0) 242 242 + ret = dev->status & 0xffff; 243 243 + else 244 244 + ret = -EIO; 245 245 + 246 246 + /* restore the ctrl regs state */ 247 247 + writel(ctrlreg1, dev->io_base + SMI_CR1); 248 248 + writel(0, dev->io_base + SMI_CR2); 249 249 + mutex_unlock(&dev->lock); 250 250 + 251 251 + return ret; 252 252 + } 253 253 + 254 254 + /** 255 255 + * spear_smi_wait_till_ready - wait till flash is ready 256 256 + * @dev: structure of SMI information. 257 257 + * @bank: flash corresponding to this bank 258 258 + * @timeout: timeout for busy wait condition 259 259 + * 260 260 + * This routine checks for WIP (write in progress) bit in Status register 261 261 + * If successful the routine returns 0 else -EBUSY 262 262 + */ 263 263 + static int spear_smi_wait_till_ready(struct spear_smi *dev, u32 bank, 264 264 + unsigned long timeout) 265 265 + { 266 266 + unsigned long finish; 267 267 + int status; 268 268 + 269 269 + finish = jiffies + timeout; 270 270 + do { 271 271 + status = spear_smi_read_sr(dev, bank); 272 272 + if (status < 0) 273 273 + continue; /* try till timeout */ 274 274 + else if (!(status & SR_WIP)) 275 275 + return 0; 276 276 + 277 277 + cond_resched(); 278 278 + } while (!time_after_eq(jiffies, finish)); 279 279 + 280 280 + dev_err(&dev->pdev->dev, "smi controller is busy, timeout\n"); 281 281 + return status; 282 282 + } 283 283 + 284 284 + /** 285 285 + * spear_smi_int_handler - SMI Interrupt Handler. 286 286 + * @irq: irq number 287 287 + * @dev_id: structure of SMI device, embedded in dev_id. 288 288 + * 289 289 + * The handler clears all interrupt conditions and records the status in 290 290 + * dev->status which is used by the driver later. 291 291 + */ 292 292 + static irqreturn_t spear_smi_int_handler(int irq, void *dev_id) 293 293 + { 294 294 + u32 status = 0; 295 295 + struct spear_smi *dev = dev_id; 296 296 + 297 297 + status = readl(dev->io_base + SMI_SR); 298 298 + 299 299 + if (unlikely(!status)) 300 300 + return IRQ_NONE; 301 301 + 302 302 + /* clear all interrupt conditions */ 303 303 + writel(0, dev->io_base + SMI_SR); 304 304 + 305 305 + /* copy the status register in dev->status */ 306 306 + dev->status |= status; 307 307 + 308 308 + /* send the completion */ 309 309 + wake_up_interruptible(&dev->cmd_complete); 310 310 + 311 311 + return IRQ_HANDLED; 312 312 + } 313 313 + 314 314 + /** 315 315 + * spear_smi_hw_init - initializes the smi controller. 316 316 + * @dev: structure of smi device 317 317 + * 318 318 + * this routine initializes the smi controller wit the default values 319 319 + */ 320 320 + static void spear_smi_hw_init(struct spear_smi *dev) 321 321 + { 322 322 + unsigned long rate = 0; 323 323 + u32 prescale = 0; 324 324 + u32 val; 325 325 + 326 326 + rate = clk_get_rate(dev->clk); 327 327 + 328 328 + /* functional clock of smi */ 329 329 + prescale = DIV_ROUND_UP(rate, dev->clk_rate); 330 330 + 331 331 + /* 332 332 + * setting the standard values, fast mode, prescaler for 333 333 + * SMI_MAX_CLOCK_FREQ (50MHz) operation and bank enable 334 334 + */ 335 335 + val = HOLD1 | BANK_EN | DSEL_TIME | (prescale << 8); 336 336 + 337 337 + mutex_lock(&dev->lock); 338 338 + writel(val, dev->io_base + SMI_CR1); 339 339 + mutex_unlock(&dev->lock); 340 340 + } 341 341 + 342 342 + /** 343 343 + * get_flash_index - match chip id from a flash list. 344 344 + * @flash_id: a valid nor flash chip id obtained from board. 345 345 + * 346 346 + * try to validate the chip id by matching from a list, if not found then simply 347 347 + * returns negative. In case of success returns index in to the flash devices 348 348 + * array. 349 349 + */ 350 350 + static int get_flash_index(u32 flash_id) 351 351 + { 352 352 + int index; 353 353 + 354 354 + /* Matches chip-id to entire list of 'serial-nor flash' ids */ 355 355 + for (index = 0; index < ARRAY_SIZE(flash_devices); index++) { 356 356 + if (flash_devices[index].device_id == flash_id) 357 357 + return index; 358 358 + } 359 359 + 360 360 + /* Memory chip is not listed and not supported */ 361 361 + return -ENODEV; 362 362 + } 363 363 + 364 364 + /** 365 365 + * spear_smi_write_enable - Enable the flash to do write operation 366 366 + * @dev: structure of SMI device 367 367 + * @bank: enable write for flash connected to this bank 368 368 + * 369 369 + * Set write enable latch with Write Enable command. 370 370 + * Returns 0 on success. 371 371 + */ 372 372 + static int spear_smi_write_enable(struct spear_smi *dev, u32 bank) 373 373 + { 374 374 + int ret; 375 375 + u32 ctrlreg1; 376 376 + 377 377 + mutex_lock(&dev->lock); 378 378 + dev->status = 0; /* Will be set in interrupt handler */ 379 379 + 380 380 + ctrlreg1 = readl(dev->io_base + SMI_CR1); 381 381 + /* program smi in h/w mode */ 382 382 + writel(ctrlreg1 & ~SW_MODE, dev->io_base + SMI_CR1); 383 383 + 384 384 + /* give the flash, write enable command */ 385 385 + writel((bank << BANK_SHIFT) | WE | TFIE, dev->io_base + SMI_CR2); 386 386 + 387 387 + ret = wait_event_interruptible_timeout(dev->cmd_complete, 388 388 + dev->status & TFF, SMI_CMD_TIMEOUT); 389 389 + 390 390 + /* restore the ctrl regs state */ 391 391 + writel(ctrlreg1, dev->io_base + SMI_CR1); 392 392 + writel(0, dev->io_base + SMI_CR2); 393 393 + 394 394 + if (ret <= 0) { 395 395 + ret = -EIO; 396 396 + dev_err(&dev->pdev->dev, 397 397 + "smi controller failed on write enable\n"); 398 398 + } else { 399 399 + /* check whether write mode status is set for required bank */ 400 400 + if (dev->status & (1 << (bank + WM_SHIFT))) 401 401 + ret = 0; 402 402 + else { 403 403 + dev_err(&dev->pdev->dev, "couldn't enable write\n"); 404 404 + ret = -EIO; 405 405 + } 406 406 + } 407 407 + 408 408 + mutex_unlock(&dev->lock); 409 409 + return ret; 410 410 + } 411 411 + 412 412 + static inline u32 413 413 + get_sector_erase_cmd(struct spear_snor_flash *flash, u32 offset) 414 414 + { 415 415 + u32 cmd; 416 416 + u8 *x = (u8 *)&cmd; 417 417 + 418 418 + x[0] = flash->erase_cmd; 419 419 + x[1] = offset >> 16; 420 420 + x[2] = offset >> 8; 421 421 + x[3] = offset; 422 422 + 423 423 + return cmd; 424 424 + } 425 425 + 426 426 + /** 427 427 + * spear_smi_erase_sector - erase one sector of flash 428 428 + * @dev: structure of SMI information 429 429 + * @command: erase command to be send 430 430 + * @bank: bank to which this command needs to be send 431 431 + * @bytes: size of command 432 432 + * 433 433 + * Erase one sector of flash memory at offset ``offset'' which is any 434 434 + * address within the sector which should be erased. 435 435 + * Returns 0 if successful, non-zero otherwise. 436 436 + */ 437 437 + static int spear_smi_erase_sector(struct spear_smi *dev, 438 438 + u32 bank, u32 command, u32 bytes) 439 439 + { 440 440 + u32 ctrlreg1 = 0; 441 441 + int ret; 442 442 + 443 443 + ret = spear_smi_wait_till_ready(dev, bank, SMI_MAX_TIME_OUT); 444 444 + if (ret) 445 445 + return ret; 446 446 + 447 447 + ret = spear_smi_write_enable(dev, bank); 448 448 + if (ret) 449 449 + return ret; 450 450 + 451 451 + mutex_lock(&dev->lock); 452 452 + 453 453 + ctrlreg1 = readl(dev->io_base + SMI_CR1); 454 454 + writel((ctrlreg1 | SW_MODE) & ~WB_MODE, dev->io_base + SMI_CR1); 455 455 + 456 456 + /* send command in sw mode */ 457 457 + writel(command, dev->io_base + SMI_TR); 458 458 + 459 459 + writel((bank << BANK_SHIFT) | SEND | TFIE | (bytes << TX_LEN_SHIFT), 460 460 + dev->io_base + SMI_CR2); 461 461 + 462 462 + ret = wait_event_interruptible_timeout(dev->cmd_complete, 463 463 + dev->status & TFF, SMI_CMD_TIMEOUT); 464 464 + 465 465 + if (ret <= 0) { 466 466 + ret = -EIO; 467 467 + dev_err(&dev->pdev->dev, "sector erase failed\n"); 468 468 + } else 469 469 + ret = 0; /* success */ 470 470 + 471 471 + /* restore ctrl regs */ 472 472 + writel(ctrlreg1, dev->io_base + SMI_CR1); 473 473 + writel(0, dev->io_base + SMI_CR2); 474 474 + 475 475 + mutex_unlock(&dev->lock); 476 476 + return ret; 477 477 + } 478 478 + 479 479 + /** 480 480 + * spear_mtd_erase - perform flash erase operation as requested by user 481 481 + * @mtd: Provides the memory characteristics 482 482 + * @e_info: Provides the erase information 483 483 + * 484 484 + * Erase an address range on the flash chip. The address range may extend 485 485 + * one or more erase sectors. Return an error is there is a problem erasing. 486 486 + */ 487 487 + static int spear_mtd_erase(struct mtd_info *mtd, struct erase_info *e_info) 488 488 + { 489 489 + struct spear_snor_flash *flash = get_flash_data(mtd); 490 490 + struct spear_smi *dev = mtd->priv; 491 491 + u32 addr, command, bank; 492 492 + int len, ret; 493 493 + 494 494 + if (!flash || !dev) 495 495 + return -ENODEV; 496 496 + 497 497 + bank = flash->bank; 498 498 + if (bank > dev->num_flashes - 1) { 499 499 + dev_err(&dev->pdev->dev, "Invalid Bank Num"); 500 500 + return -EINVAL; 501 501 + } 502 502 + 503 503 + addr = e_info->addr; 504 504 + len = e_info->len; 505 505 + 506 506 + mutex_lock(&flash->lock); 507 507 + 508 508 + /* now erase sectors in loop */ 509 509 + while (len) { 510 510 + command = get_sector_erase_cmd(flash, addr); 511 511 + /* preparing the command for flash */ 512 512 + ret = spear_smi_erase_sector(dev, bank, command, 4); 513 513 + if (ret) { 514 514 + e_info->state = MTD_ERASE_FAILED; 515 515 + mutex_unlock(&flash->lock); 516 516 + return ret; 517 517 + } 518 518 + addr += mtd->erasesize; 519 519 + len -= mtd->erasesize; 520 520 + } 521 521 + 522 522 + mutex_unlock(&flash->lock); 523 523 + e_info->state = MTD_ERASE_DONE; 524 524 + mtd_erase_callback(e_info); 525 525 + 526 526 + return 0; 527 527 + } 528 528 + 529 529 + /** 530 530 + * spear_mtd_read - performs flash read operation as requested by the user 531 531 + * @mtd: MTD information of the memory bank 532 532 + * @from: Address from which to start read 533 533 + * @len: Number of bytes to be read 534 534 + * @retlen: Fills the Number of bytes actually read 535 535 + * @buf: Fills this after reading 536 536 + * 537 537 + * Read an address range from the flash chip. The address range 538 538 + * may be any size provided it is within the physical boundaries. 539 539 + * Returns 0 on success, non zero otherwise 540 540 + */ 541 541 + static int spear_mtd_read(struct mtd_info *mtd, loff_t from, size_t len, 542 542 + size_t *retlen, u8 *buf) 543 543 + { 544 544 + struct spear_snor_flash *flash = get_flash_data(mtd); 545 545 + struct spear_smi *dev = mtd->priv; 546 546 + void *src; 547 547 + u32 ctrlreg1, val; 548 548 + int ret; 549 549 + 550 550 + if (!flash || !dev) 551 551 + return -ENODEV; 552 552 + 553 553 + if (flash->bank > dev->num_flashes - 1) { 554 554 + dev_err(&dev->pdev->dev, "Invalid Bank Num"); 555 555 + return -EINVAL; 556 556 + } 557 557 + 558 558 + /* select address as per bank number */ 559 559 + src = flash->base_addr + from; 560 560 + 561 561 + mutex_lock(&flash->lock); 562 562 + 563 563 + /* wait till previous write/erase is done. */ 564 564 + ret = spear_smi_wait_till_ready(dev, flash->bank, SMI_MAX_TIME_OUT); 565 565 + if (ret) { 566 566 + mutex_unlock(&flash->lock); 567 567 + return ret; 568 568 + } 569 569 + 570 570 + mutex_lock(&dev->lock); 571 571 + /* put smi in hw mode not wbt mode */ 572 572 + ctrlreg1 = val = readl(dev->io_base + SMI_CR1); 573 573 + val &= ~(SW_MODE | WB_MODE); 574 574 + if (flash->fast_mode) 575 575 + val |= FAST_MODE; 576 576 + 577 577 + writel(val, dev->io_base + SMI_CR1); 578 578 + 579 579 + memcpy_fromio(buf, (u8 *)src, len); 580 580 + 581 581 + /* restore ctrl reg1 */ 582 582 + writel(ctrlreg1, dev->io_base + SMI_CR1); 583 583 + mutex_unlock(&dev->lock); 584 584 + 585 585 + *retlen = len; 586 586 + mutex_unlock(&flash->lock); 587 587 + 588 588 + return 0; 589 589 + } 590 590 + 591 591 + static inline int spear_smi_cpy_toio(struct spear_smi *dev, u32 bank, 592 592 + void *dest, const void *src, size_t len) 593 593 + { 594 594 + int ret; 595 595 + u32 ctrlreg1; 596 596 + 597 597 + /* wait until finished previous write command. */ 598 598 + ret = spear_smi_wait_till_ready(dev, bank, SMI_MAX_TIME_OUT); 599 599 + if (ret) 600 600 + return ret; 601 601 + 602 602 + /* put smi in write enable */ 603 603 + ret = spear_smi_write_enable(dev, bank); 604 604 + if (ret) 605 605 + return ret; 606 606 + 607 607 + /* put smi in hw, write burst mode */ 608 608 + mutex_lock(&dev->lock); 609 609 + 610 610 + ctrlreg1 = readl(dev->io_base + SMI_CR1); 611 611 + writel((ctrlreg1 | WB_MODE) & ~SW_MODE, dev->io_base + SMI_CR1); 612 612 + 613 613 + memcpy_toio(dest, src, len); 614 614 + 615 615 + writel(ctrlreg1, dev->io_base + SMI_CR1); 616 616 + 617 617 + mutex_unlock(&dev->lock); 618 618 + return 0; 619 619 + } 620 620 + 621 621 + /** 622 622 + * spear_mtd_write - performs write operation as requested by the user. 623 623 + * @mtd: MTD information of the memory bank. 624 624 + * @to: Address to write. 625 625 + * @len: Number of bytes to be written. 626 626 + * @retlen: Number of bytes actually wrote. 627 627 + * @buf: Buffer from which the data to be taken. 628 628 + * 629 629 + * Write an address range to the flash chip. Data must be written in 630 630 + * flash_page_size chunks. The address range may be any size provided 631 631 + * it is within the physical boundaries. 632 632 + * Returns 0 on success, non zero otherwise 633 633 + */ 634 634 + static int spear_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, 635 635 + size_t *retlen, const u8 *buf) 636 636 + { 637 637 + struct spear_snor_flash *flash = get_flash_data(mtd); 638 638 + struct spear_smi *dev = mtd->priv; 639 639 + void *dest; 640 640 + u32 page_offset, page_size; 641 641 + int ret; 642 642 + 643 643 + if (!flash || !dev) 644 644 + return -ENODEV; 645 645 + 646 646 + if (flash->bank > dev->num_flashes - 1) { 647 647 + dev_err(&dev->pdev->dev, "Invalid Bank Num"); 648 648 + return -EINVAL; 649 649 + } 650 650 + 651 651 + /* select address as per bank number */ 652 652 + dest = flash->base_addr + to; 653 653 + mutex_lock(&flash->lock); 654 654 + 655 655 + page_offset = (u32)to % flash->page_size; 656 656 + 657 657 + /* do if all the bytes fit onto one page */ 658 658 + if (page_offset + len <= flash->page_size) { 659 659 + ret = spear_smi_cpy_toio(dev, flash->bank, dest, buf, len); 660 660 + if (!ret) 661 661 + *retlen += len; 662 662 + } else { 663 663 + u32 i; 664 664 + 665 665 + /* the size of data remaining on the first page */ 666 666 + page_size = flash->page_size - page_offset; 667 667 + 668 668 + ret = spear_smi_cpy_toio(dev, flash->bank, dest, buf, 669 669 + page_size); 670 670 + if (ret) 671 671 + goto err_write; 672 672 + else 673 673 + *retlen += page_size; 674 674 + 675 675 + /* write everything in pagesize chunks */ 676 676 + for (i = page_size; i < len; i += page_size) { 677 677 + page_size = len - i; 678 678 + if (page_size > flash->page_size) 679 679 + page_size = flash->page_size; 680 680 + 681 681 + ret = spear_smi_cpy_toio(dev, flash->bank, dest + i, 682 682 + buf + i, page_size); 683 683 + if (ret) 684 684 + break; 685 685 + else 686 686 + *retlen += page_size; 687 687 + } 688 688 + } 689 689 + 690 690 + err_write: 691 691 + mutex_unlock(&flash->lock); 692 692 + 693 693 + return ret; 694 694 + } 695 695 + 696 696 + /** 697 697 + * spear_smi_probe_flash - Detects the NOR Flash chip. 698 698 + * @dev: structure of SMI information. 699 699 + * @bank: bank on which flash must be probed 700 700 + * 701 701 + * This routine will check whether there exists a flash chip on a given memory 702 702 + * bank ID. 703 703 + * Return index of the probed flash in flash devices structure 704 704 + */ 705 705 + static int spear_smi_probe_flash(struct spear_smi *dev, u32 bank) 706 706 + { 707 707 + int ret; 708 708 + u32 val = 0; 709 709 + 710 710 + ret = spear_smi_wait_till_ready(dev, bank, SMI_PROBE_TIMEOUT); 711 711 + if (ret) 712 712 + return ret; 713 713 + 714 714 + mutex_lock(&dev->lock); 715 715 + 716 716 + dev->status = 0; /* Will be set in interrupt handler */ 717 717 + /* put smi in sw mode */ 718 718 + val = readl(dev->io_base + SMI_CR1); 719 719 + writel(val | SW_MODE, dev->io_base + SMI_CR1); 720 720 + 721 721 + /* send readid command in sw mode */ 722 722 + writel(OPCODE_RDID, dev->io_base + SMI_TR); 723 723 + 724 724 + val = (bank << BANK_SHIFT) | SEND | (1 << TX_LEN_SHIFT) | 725 725 + (3 << RX_LEN_SHIFT) | TFIE; 726 726 + writel(val, dev->io_base + SMI_CR2); 727 727 + 728 728 + /* wait for TFF */ 729 729 + ret = wait_event_interruptible_timeout(dev->cmd_complete, 730 730 + dev->status & TFF, SMI_CMD_TIMEOUT); 731 731 + if (ret <= 0) { 732 732 + ret = -ENODEV; 733 733 + goto err_probe; 734 734 + } 735 735 + 736 736 + /* get memory chip id */ 737 737 + val = readl(dev->io_base + SMI_RR); 738 738 + val &= 0x00ffffff; 739 739 + ret = get_flash_index(val); 740 740 + 741 741 + err_probe: 742 742 + /* clear sw mode */ 743 743 + val = readl(dev->io_base + SMI_CR1); 744 744 + writel(val & ~SW_MODE, dev->io_base + SMI_CR1); 745 745 + 746 746 + mutex_unlock(&dev->lock); 747 747 + return ret; 748 748 + } 749 749 + 750 750 + 751 751 + #ifdef CONFIG_OF 752 752 + static int __devinit spear_smi_probe_config_dt(struct platform_device *pdev, 753 753 + struct device_node *np) 754 754 + { 755 755 + struct spear_smi_plat_data *pdata = dev_get_platdata(&pdev->dev); 756 756 + struct device_node *pp = NULL; 757 757 + const __be32 *addr; 758 758 + u32 val; 759 759 + int len; 760 760 + int i = 0; 761 761 + 762 762 + if (!np) 763 763 + return -ENODEV; 764 764 + 765 765 + of_property_read_u32(np, "clock-rate", &val); 766 766 + pdata->clk_rate = val; 767 767 + 768 768 + pdata->board_flash_info = devm_kzalloc(&pdev->dev, 769 769 + sizeof(*pdata->board_flash_info), 770 770 + GFP_KERNEL); 771 771 + 772 772 + /* Fill structs for each subnode (flash device) */ 773 773 + while ((pp = of_get_next_child(np, pp))) { 774 774 + struct spear_smi_flash_info *flash_info; 775 775 + 776 776 + flash_info = &pdata->board_flash_info[i]; 777 777 + pdata->np[i] = pp; 778 778 + 779 779 + /* Read base-addr and size from DT */ 780 780 + addr = of_get_property(pp, "reg", &len); 781 781 + pdata->board_flash_info->mem_base = be32_to_cpup(&addr[0]); 782 782 + pdata->board_flash_info->size = be32_to_cpup(&addr[1]); 783 783 + 784 784 + if (of_get_property(pp, "st,smi-fast-mode", NULL)) 785 785 + pdata->board_flash_info->fast_mode = 1; 786 786 + 787 787 + i++; 788 788 + } 789 789 + 790 790 + pdata->num_flashes = i; 791 791 + 792 792 + return 0; 793 793 + } 794 794 + #else 795 795 + static int __devinit spear_smi_probe_config_dt(struct platform_device *pdev, 796 796 + struct device_node *np) 797 797 + { 798 798 + return -ENOSYS; 799 799 + } 800 800 + #endif 801 801 + 802 802 + static int spear_smi_setup_banks(struct platform_device *pdev, 803 803 + u32 bank, struct device_node *np) 804 804 + { 805 805 + struct spear_smi *dev = platform_get_drvdata(pdev); 806 806 + struct mtd_part_parser_data ppdata = {}; 807 807 + struct spear_smi_flash_info *flash_info; 808 808 + struct spear_smi_plat_data *pdata; 809 809 + struct spear_snor_flash *flash; 810 810 + struct mtd_partition *parts = NULL; 811 811 + int count = 0; 812 812 + int flash_index; 813 813 + int ret = 0; 814 814 + 815 815 + pdata = dev_get_platdata(&pdev->dev); 816 816 + if (bank > pdata->num_flashes - 1) 817 817 + return -EINVAL; 818 818 + 819 819 + flash_info = &pdata->board_flash_info[bank]; 820 820 + if (!flash_info) 821 821 + return -ENODEV; 822 822 + 823 823 + flash = kzalloc(sizeof(*flash), GFP_ATOMIC); 824 824 + if (!flash) 825 825 + return -ENOMEM; 826 826 + flash->bank = bank; 827 827 + flash->fast_mode = flash_info->fast_mode ? 1 : 0; 828 828 + mutex_init(&flash->lock); 829 829 + 830 830 + /* verify whether nor flash is really present on board */ 831 831 + flash_index = spear_smi_probe_flash(dev, bank); 832 832 + if (flash_index < 0) { 833 833 + dev_info(&dev->pdev->dev, "smi-nor%d not found\n", bank); 834 834 + ret = flash_index; 835 835 + goto err_probe; 836 836 + } 837 837 + /* map the memory for nor flash chip */ 838 838 + flash->base_addr = ioremap(flash_info->mem_base, flash_info->size); 839 839 + if (!flash->base_addr) { 840 840 + ret = -EIO; 841 841 + goto err_probe; 842 842 + } 843 843 + 844 844 + dev->flash[bank] = flash; 845 845 + flash->mtd.priv = dev; 846 846 + 847 847 + if (flash_info->name) 848 848 + flash->mtd.name = flash_info->name; 849 849 + else 850 850 + flash->mtd.name = flash_devices[flash_index].name; 851 851 + 852 852 + flash->mtd.type = MTD_NORFLASH; 853 853 + flash->mtd.writesize = 1; 854 854 + flash->mtd.flags = MTD_CAP_NORFLASH; 855 855 + flash->mtd.size = flash_info->size; 856 856 + flash->mtd.erasesize = flash_devices[flash_index].sectorsize; 857 857 + flash->page_size = flash_devices[flash_index].pagesize; 858 858 + flash->mtd.writebufsize = flash->page_size; 859 859 + flash->erase_cmd = flash_devices[flash_index].erase_cmd; 860 860 + flash->mtd._erase = spear_mtd_erase; 861 861 + flash->mtd._read = spear_mtd_read; 862 862 + flash->mtd._write = spear_mtd_write; 863 863 + flash->dev_id = flash_devices[flash_index].device_id; 864 864 + 865 865 + dev_info(&dev->pdev->dev, "mtd .name=%s .size=%llx(%lluM)\n", 866 866 + flash->mtd.name, flash->mtd.size, 867 867 + flash->mtd.size / (1024 * 1024)); 868 868 + 869 869 + dev_info(&dev->pdev->dev, ".erasesize = 0x%x(%uK)\n", 870 870 + flash->mtd.erasesize, flash->mtd.erasesize / 1024); 871 871 + 872 872 + #ifndef CONFIG_OF 873 873 + if (flash_info->partitions) { 874 874 + parts = flash_info->partitions; 875 875 + count = flash_info->nr_partitions; 876 876 + } 877 877 + #endif 878 878 + ppdata.of_node = np; 879 879 + 880 880 + ret = mtd_device_parse_register(&flash->mtd, NULL, &ppdata, parts, 881 881 + count); 882 882 + if (ret) { 883 883 + dev_err(&dev->pdev->dev, "Err MTD partition=%d\n", ret); 884 884 + goto err_map; 885 885 + } 886 886 + 887 887 + return 0; 888 888 + 889 889 + err_map: 890 890 + iounmap(flash->base_addr); 891 891 + 892 892 + err_probe: 893 893 + kfree(flash); 894 894 + return ret; 895 895 + } 896 896 + 897 897 + /** 898 898 + * spear_smi_probe - Entry routine 899 899 + * @pdev: platform device structure 900 900 + * 901 901 + * This is the first routine which gets invoked during booting and does all 902 902 + * initialization/allocation work. The routine looks for available memory banks, 903 903 + * and do proper init for any found one. 904 904 + * Returns 0 on success, non zero otherwise 905 905 + */ 906 906 + static int __devinit spear_smi_probe(struct platform_device *pdev) 907 907 + { 908 908 + struct device_node *np = pdev->dev.of_node; 909 909 + struct spear_smi_plat_data *pdata = NULL; 910 910 + struct spear_smi *dev; 911 911 + struct resource *smi_base; 912 912 + int irq, ret = 0; 913 913 + int i; 914 914 + 915 915 + if (np) { 916 916 + pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 917 917 + if (!pdata) { 918 918 + pr_err("%s: ERROR: no memory", __func__); 919 919 + ret = -ENOMEM; 920 920 + goto err; 921 921 + } 922 922 + pdev->dev.platform_data = pdata; 923 923 + ret = spear_smi_probe_config_dt(pdev, np); 924 924 + if (ret) { 925 925 + ret = -ENODEV; 926 926 + dev_err(&pdev->dev, "no platform data\n"); 927 927 + goto err; 928 928 + } 929 929 + } else { 930 930 + pdata = dev_get_platdata(&pdev->dev); 931 931 + if (pdata < 0) { 932 932 + ret = -ENODEV; 933 933 + dev_err(&pdev->dev, "no platform data\n"); 934 934 + goto err; 935 935 + } 936 936 + } 937 937 + 938 938 + smi_base = platform_get_resource(pdev, IORESOURCE_MEM, 0); 939 939 + if (!smi_base) { 940 940 + ret = -ENODEV; 941 941 + dev_err(&pdev->dev, "invalid smi base address\n"); 942 942 + goto err; 943 943 + } 944 944 + 945 945 + irq = platform_get_irq(pdev, 0); 946 946 + if (irq < 0) { 947 947 + ret = -ENODEV; 948 948 + dev_err(&pdev->dev, "invalid smi irq\n"); 949 949 + goto err; 950 950 + } 951 951 + 952 952 + dev = kzalloc(sizeof(*dev), GFP_ATOMIC); 953 953 + if (!dev) { 954 954 + ret = -ENOMEM; 955 955 + dev_err(&pdev->dev, "mem alloc fail\n"); 956 956 + goto err; 957 957 + } 958 958 + 959 959 + smi_base = request_mem_region(smi_base->start, resource_size(smi_base), 960 960 + pdev->name); 961 961 + if (!smi_base) { 962 962 + ret = -EBUSY; 963 963 + dev_err(&pdev->dev, "request mem region fail\n"); 964 964 + goto err_mem; 965 965 + } 966 966 + 967 967 + dev->io_base = ioremap(smi_base->start, resource_size(smi_base)); 968 968 + if (!dev->io_base) { 969 969 + ret = -EIO; 970 970 + dev_err(&pdev->dev, "ioremap fail\n"); 971 971 + goto err_ioremap; 972 972 + } 973 973 + 974 974 + dev->pdev = pdev; 975 975 + dev->clk_rate = pdata->clk_rate; 976 976 + 977 977 + if (dev->clk_rate < 0 || dev->clk_rate > SMI_MAX_CLOCK_FREQ) 978 978 + dev->clk_rate = SMI_MAX_CLOCK_FREQ; 979 979 + 980 980 + dev->num_flashes = pdata->num_flashes; 981 981 + 982 982 + if (dev->num_flashes > MAX_NUM_FLASH_CHIP) { 983 983 + dev_err(&pdev->dev, "exceeding max number of flashes\n"); 984 984 + dev->num_flashes = MAX_NUM_FLASH_CHIP; 985 985 + } 986 986 + 987 987 + dev->clk = clk_get(&pdev->dev, NULL); 988 988 + if (IS_ERR(dev->clk)) { 989 989 + ret = PTR_ERR(dev->clk); 990 990 + goto err_clk; 991 991 + } 992 992 + 993 993 + ret = clk_enable(dev->clk); 994 994 + if (ret) 995 995 + goto err_clk_enable; 996 996 + 997 997 + ret = request_irq(irq, spear_smi_int_handler, 0, pdev->name, dev); 998 998 + if (ret) { 999 999 + dev_err(&dev->pdev->dev, "SMI IRQ allocation failed\n"); 1000 1000 + goto err_irq; 1001 1001 + } 1002 1002 + 1003 1003 + mutex_init(&dev->lock); 1004 1004 + init_waitqueue_head(&dev->cmd_complete); 1005 1005 + spear_smi_hw_init(dev); 1006 1006 + platform_set_drvdata(pdev, dev); 1007 1007 + 1008 1008 + /* loop for each serial nor-flash which is connected to smi */ 1009 1009 + for (i = 0; i < dev->num_flashes; i++) { 1010 1010 + ret = spear_smi_setup_banks(pdev, i, pdata->np[i]); 1011 1011 + if (ret) { 1012 1012 + dev_err(&dev->pdev->dev, "bank setup failed\n"); 1013 1013 + goto err_bank_setup; 1014 1014 + } 1015 1015 + } 1016 1016 + 1017 1017 + return 0; 1018 1018 + 1019 1019 + err_bank_setup: 1020 1020 + free_irq(irq, dev); 1021 1021 + platform_set_drvdata(pdev, NULL); 1022 1022 + err_irq: 1023 1023 + clk_disable(dev->clk); 1024 1024 + err_clk_enable: 1025 1025 + clk_put(dev->clk); 1026 1026 + err_clk: 1027 1027 + iounmap(dev->io_base); 1028 1028 + err_ioremap: 1029 1029 + release_mem_region(smi_base->start, resource_size(smi_base)); 1030 1030 + err_mem: 1031 1031 + kfree(dev); 1032 1032 + err: 1033 1033 + return ret; 1034 1034 + } 1035 1035 + 1036 1036 + /** 1037 1037 + * spear_smi_remove - Exit routine 1038 1038 + * @pdev: platform device structure 1039 1039 + * 1040 1040 + * free all allocations and delete the partitions. 1041 1041 + */ 1042 1042 + static int __devexit spear_smi_remove(struct platform_device *pdev) 1043 1043 + { 1044 1044 + struct spear_smi *dev; 1045 1045 + struct spear_smi_plat_data *pdata; 1046 1046 + struct spear_snor_flash *flash; 1047 1047 + struct resource *smi_base; 1048 1048 + int ret; 1049 1049 + int i, irq; 1050 1050 + 1051 1051 + dev = platform_get_drvdata(pdev); 1052 1052 + if (!dev) { 1053 1053 + dev_err(&pdev->dev, "dev is null\n"); 1054 1054 + return -ENODEV; 1055 1055 + } 1056 1056 + 1057 1057 + pdata = dev_get_platdata(&pdev->dev); 1058 1058 + 1059 1059 + /* clean up for all nor flash */ 1060 1060 + for (i = 0; i < dev->num_flashes; i++) { 1061 1061 + flash = dev->flash[i]; 1062 1062 + if (!flash) 1063 1063 + continue; 1064 1064 + 1065 1065 + /* clean up mtd stuff */ 1066 1066 + ret = mtd_device_unregister(&flash->mtd); 1067 1067 + if (ret) 1068 1068 + dev_err(&pdev->dev, "error removing mtd\n"); 1069 1069 + 1070 1070 + iounmap(flash->base_addr); 1071 1071 + kfree(flash); 1072 1072 + } 1073 1073 + 1074 1074 + irq = platform_get_irq(pdev, 0); 1075 1075 + free_irq(irq, dev); 1076 1076 + 1077 1077 + clk_disable(dev->clk); 1078 1078 + clk_put(dev->clk); 1079 1079 + iounmap(dev->io_base); 1080 1080 + kfree(dev); 1081 1081 + 1082 1082 + smi_base = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1083 1083 + release_mem_region(smi_base->start, resource_size(smi_base)); 1084 1084 + platform_set_drvdata(pdev, NULL); 1085 1085 + 1086 1086 + return 0; 1087 1087 + } 1088 1088 + 1089 1089 + int spear_smi_suspend(struct platform_device *pdev, pm_message_t state) 1090 1090 + { 1091 1091 + struct spear_smi *dev = platform_get_drvdata(pdev); 1092 1092 + 1093 1093 + if (dev && dev->clk) 1094 1094 + clk_disable(dev->clk); 1095 1095 + 1096 1096 + return 0; 1097 1097 + } 1098 1098 + 1099 1099 + int spear_smi_resume(struct platform_device *pdev) 1100 1100 + { 1101 1101 + struct spear_smi *dev = platform_get_drvdata(pdev); 1102 1102 + int ret = -EPERM; 1103 1103 + 1104 1104 + if (dev && dev->clk) 1105 1105 + ret = clk_enable(dev->clk); 1106 1106 + 1107 1107 + if (!ret) 1108 1108 + spear_smi_hw_init(dev); 1109 1109 + return ret; 1110 1110 + } 1111 1111 + 1112 1112 + #ifdef CONFIG_OF 1113 1113 + static const struct of_device_id spear_smi_id_table[] = { 1114 1114 + { .compatible = "st,spear600-smi" }, 1115 1115 + {} 1116 1116 + }; 1117 1117 + MODULE_DEVICE_TABLE(of, spear_smi_id_table); 1118 1118 + #endif 1119 1119 + 1120 1120 + static struct platform_driver spear_smi_driver = { 1121 1121 + .driver = { 1122 1122 + .name = "smi", 1123 1123 + .bus = &platform_bus_type, 1124 1124 + .owner = THIS_MODULE, 1125 1125 + .of_match_table = of_match_ptr(spear_smi_id_table), 1126 1126 + }, 1127 1127 + .probe = spear_smi_probe, 1128 1128 + .remove = __devexit_p(spear_smi_remove), 1129 1129 + .suspend = spear_smi_suspend, 1130 1130 + .resume = spear_smi_resume, 1131 1131 + }; 1132 1132 + 1133 1133 + static int spear_smi_init(void) 1134 1134 + { 1135 1135 + return platform_driver_register(&spear_smi_driver); 1136 1136 + } 1137 1137 + module_init(spear_smi_init); 1138 1138 + 1139 1139 + static void spear_smi_exit(void) 1140 1140 + { 1141 1141 + platform_driver_unregister(&spear_smi_driver); 1142 1142 + } 1143 1143 + module_exit(spear_smi_exit); 1144 1144 + 1145 1145 + MODULE_LICENSE("GPL"); 1146 1146 + MODULE_AUTHOR("Ashish Priyadarshi, Shiraz Hashim <shiraz.hashim@st.com>"); 1147 1147 + MODULE_DESCRIPTION("MTD SMI driver for serial nor flash chips");

+8 -38

drivers/mtd/devices/sst25l.c

reviewed

··· 175 175 int err; 176 176 177 177 /* Sanity checks */ 178 178 - if (instr->addr + instr->len > flash->mtd.size) 179 179 - return -EINVAL; 180 180 - 181 178 if ((uint32_t)instr->len % mtd->erasesize) 182 179 return -EINVAL; 183 180 ··· 220 223 unsigned char command[4]; 221 224 int ret; 222 225 223 223 - /* Sanity checking */ 224 224 - if (len == 0) 225 225 - return 0; 226 226 - 227 227 - if (from + len > flash->mtd.size) 228 228 - return -EINVAL; 229 229 - 230 230 - if (retlen) 231 231 - *retlen = 0; 232 232 - 233 226 spi_message_init(&message); 234 227 memset(&transfer, 0, sizeof(transfer)); 235 228 ··· 260 273 struct sst25l_flash *flash = to_sst25l_flash(mtd); 261 274 int i, j, ret, bytes, copied = 0; 262 275 unsigned char command[5]; 263 263 - 264 264 - /* Sanity checks */ 265 265 - if (!len) 266 266 - return 0; 267 267 - 268 268 - if (to + len > flash->mtd.size) 269 269 - return -EINVAL; 270 276 271 277 if ((uint32_t)to % mtd->writesize) 272 278 return -EINVAL; ··· 382 402 flash->mtd.flags = MTD_CAP_NORFLASH; 383 403 flash->mtd.erasesize = flash_info->erase_size; 384 404 flash->mtd.writesize = flash_info->page_size; 405 405 + flash->mtd.writebufsize = flash_info->page_size; 385 406 flash->mtd.size = flash_info->page_size * flash_info->nr_pages; 386 386 - flash->mtd.erase = sst25l_erase; 387 387 - flash->mtd.read = sst25l_read; 388 388 - flash->mtd.write = sst25l_write; 407 407 + flash->mtd._erase = sst25l_erase; 408 408 + flash->mtd._read = sst25l_read; 409 409 + flash->mtd._write = sst25l_write; 389 410 390 411 dev_info(&spi->dev, "%s (%lld KiB)\n", flash_info->name, 391 412 (long long)flash->mtd.size >> 10); ··· 399 418 flash->mtd.numeraseregions); 400 419 401 420 402 402 - ret = mtd_device_parse_register(&flash->mtd, NULL, 0, 403 403 - data ? data->parts : NULL, 404 404 - data ? data->nr_parts : 0); 421 421 + ret = mtd_device_parse_register(&flash->mtd, NULL, NULL, 422 422 + data ? data->parts : NULL, 423 423 + data ? data->nr_parts : 0); 405 424 if (ret) { 406 425 kfree(flash); 407 426 dev_set_drvdata(&spi->dev, NULL); ··· 431 450 .remove = __devexit_p(sst25l_remove), 432 451 }; 433 452 434 434 - static int __init sst25l_init(void) 435 435 - { 436 436 - return spi_register_driver(&sst25l_driver); 437 437 - } 438 438 - 439 439 - static void __exit sst25l_exit(void) 440 440 - { 441 441 - spi_unregister_driver(&sst25l_driver); 442 442 - } 443 443 - 444 444 - module_init(sst25l_init); 445 445 - module_exit(sst25l_exit); 453 453 + module_spi_driver(sst25l_driver); 446 454 447 455 MODULE_DESCRIPTION("MTD SPI driver for SST25L Flash chips"); 448 456 MODULE_AUTHOR("Andre Renaud <andre@bluewatersys.com>, "

+1 -1

drivers/mtd/inftlcore.c

reviewed

··· 56 56 if (memcmp(mtd->name, "DiskOnChip", 10)) 57 57 return; 58 58 59 59 - if (!mtd->block_isbad) { 59 59 + if (!mtd->_block_isbad) { 60 60 printk(KERN_ERR 61 61 "INFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n" 62 62 "Please use the new diskonchip driver under the NAND subsystem.\n");

+17 -20

drivers/mtd/lpddr/lpddr_cmds.c

reviewed

··· 40 40 static int lpddr_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len); 41 41 static int lpddr_point(struct mtd_info *mtd, loff_t adr, size_t len, 42 42 size_t *retlen, void **mtdbuf, resource_size_t *phys); 43 43 - static void lpddr_unpoint(struct mtd_info *mtd, loff_t adr, size_t len); 43 43 + static int lpddr_unpoint(struct mtd_info *mtd, loff_t adr, size_t len); 44 44 static int get_chip(struct map_info *map, struct flchip *chip, int mode); 45 45 static int chip_ready(struct map_info *map, struct flchip *chip, int mode); 46 46 static void put_chip(struct map_info *map, struct flchip *chip); ··· 63 63 mtd->type = MTD_NORFLASH; 64 64 65 65 /* Fill in the default mtd operations */ 66 66 - mtd->read = lpddr_read; 66 66 + mtd->_read = lpddr_read; 67 67 mtd->type = MTD_NORFLASH; 68 68 mtd->flags = MTD_CAP_NORFLASH; 69 69 mtd->flags &= ~MTD_BIT_WRITEABLE; 70 70 - mtd->erase = lpddr_erase; 71 71 - mtd->write = lpddr_write_buffers; 72 72 - mtd->writev = lpddr_writev; 73 73 - mtd->lock = lpddr_lock; 74 74 - mtd->unlock = lpddr_unlock; 70 70 + mtd->_erase = lpddr_erase; 71 71 + mtd->_write = lpddr_write_buffers; 72 72 + mtd->_writev = lpddr_writev; 73 73 + mtd->_lock = lpddr_lock; 74 74 + mtd->_unlock = lpddr_unlock; 75 75 if (map_is_linear(map)) { 76 76 - mtd->point = lpddr_point; 77 77 - mtd->unpoint = lpddr_unpoint; 76 76 + mtd->_point = lpddr_point; 77 77 + mtd->_unpoint = lpddr_unpoint; 78 78 } 79 79 mtd->size = 1 << lpddr->qinfo->DevSizeShift; 80 80 mtd->erasesize = 1 << lpddr->qinfo->UniformBlockSizeShift; ··· 530 530 struct flchip *chip = &lpddr->chips[chipnum]; 531 531 int ret = 0; 532 532 533 533 - if (!map->virt || (adr + len > mtd->size)) 533 533 + if (!map->virt) 534 534 return -EINVAL; 535 535 536 536 /* ofs: offset within the first chip that the first read should start */ 537 537 ofs = adr - (chipnum << lpddr->chipshift); 538 538 - 539 538 *mtdbuf = (void *)map->virt + chip->start + ofs; 540 540 - *retlen = 0; 541 539 542 540 while (len) { 543 541 unsigned long thislen; ··· 573 575 return 0; 574 576 } 575 577 576 576 - static void lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len) 578 578 + static int lpddr_unpoint (struct mtd_info *mtd, loff_t adr, size_t len) 577 579 { 578 580 struct map_info *map = mtd->priv; 579 581 struct lpddr_private *lpddr = map->fldrv_priv; 580 580 - int chipnum = adr >> lpddr->chipshift; 582 582 + int chipnum = adr >> lpddr->chipshift, err = 0; 581 583 unsigned long ofs; 582 584 583 585 /* ofs: offset within the first chip that the first read should start */ ··· 601 603 chip->ref_point_counter--; 602 604 if (chip->ref_point_counter == 0) 603 605 chip->state = FL_READY; 604 604 - } else 606 606 + } else { 605 607 printk(KERN_WARNING "%s: Warning: unpoint called on non" 606 608 "pointed region\n", map->name); 609 609 + err = -EINVAL; 610 610 + } 607 611 608 612 put_chip(map, chip); 609 613 mutex_unlock(&chip->mutex); ··· 614 614 ofs = 0; 615 615 chipnum++; 616 616 } 617 617 + 618 618 + return err; 617 619 } 618 620 619 621 static int lpddr_write_buffers(struct mtd_info *mtd, loff_t to, size_t len, ··· 639 637 int chipnum; 640 638 unsigned long ofs, vec_seek, i; 641 639 int wbufsize = 1 << lpddr->qinfo->BufSizeShift; 642 642 - 643 640 size_t len = 0; 644 641 645 642 for (i = 0; i < count; i++) 646 643 len += vecs[i].iov_len; 647 644 648 648 - *retlen = 0; 649 645 if (!len) 650 646 return 0; 651 647 ··· 687 687 688 688 ofs = instr->addr; 689 689 len = instr->len; 690 690 - 691 691 - if (ofs > mtd->size || (len + ofs) > mtd->size) 692 692 - return -EINVAL; 693 690 694 691 while (len > 0) { 695 692 ret = do_erase_oneblock(mtd, ofs);

+2 -2

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

reviewed

··· 164 164 return -ENXIO; 165 165 } 166 166 167 167 - mtd_device_parse_register(state->mtd, part_probe_types, 0, 168 168 - pdata->parts, pdata->nr_parts); 167 167 + mtd_device_parse_register(state->mtd, part_probe_types, NULL, 168 168 + pdata->parts, pdata->nr_parts); 169 169 170 170 platform_set_drvdata(pdev, state); 171 171

+1 -1

drivers/mtd/maps/dc21285.c

reviewed

··· 196 196 197 197 dc21285_mtd->owner = THIS_MODULE; 198 198 199 199 - mtd_device_parse_register(dc21285_mtd, probes, 0, NULL, 0); 199 199 + mtd_device_parse_register(dc21285_mtd, probes, NULL, NULL, 0); 200 200 201 201 if(machine_is_ebsa285()) { 202 202 /*

+2 -2

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

reviewed

··· 252 252 } 253 253 254 254 255 255 - mtd_device_parse_register(state->mtd, part_probe_types, 0, 256 256 - pdata->parts, pdata->nr_parts); 255 255 + mtd_device_parse_register(state->mtd, part_probe_types, NULL, 256 256 + pdata->parts, pdata->nr_parts); 257 257 258 258 return 0; 259 259 }

+2 -2

drivers/mtd/maps/h720x-flash.c

reviewed

··· 85 85 if (mymtd) { 86 86 mymtd->owner = THIS_MODULE; 87 87 88 88 - mtd_device_parse_register(mymtd, NULL, 0, 89 89 - h720x_partitions, NUM_PARTITIONS); 88 88 + mtd_device_parse_register(mymtd, NULL, NULL, 89 89 + h720x_partitions, NUM_PARTITIONS); 90 90 return 0; 91 91 } 92 92

+1 -1

drivers/mtd/maps/impa7.c

reviewed

··· 91 91 if (impa7_mtd[i]) { 92 92 impa7_mtd[i]->owner = THIS_MODULE; 93 93 devicesfound++; 94 94 - mtd_device_parse_register(impa7_mtd[i], NULL, 0, 94 94 + mtd_device_parse_register(impa7_mtd[i], NULL, NULL, 95 95 partitions, 96 96 ARRAY_SIZE(partitions)); 97 97 }

+1 -1

drivers/mtd/maps/intel_vr_nor.c

reviewed

··· 72 72 { 73 73 /* register the flash bank */ 74 74 /* partition the flash bank */ 75 75 - return mtd_device_parse_register(p->info, NULL, 0, NULL, 0); 75 75 + return mtd_device_parse_register(p->info, NULL, NULL, NULL, 0); 76 76 } 77 77 78 78 static void __devexit vr_nor_destroy_mtd_setup(struct vr_nor_mtd *p)

+1 -1

drivers/mtd/maps/ixp2000.c

reviewed

··· 226 226 } 227 227 info->mtd->owner = THIS_MODULE; 228 228 229 229 - err = mtd_device_parse_register(info->mtd, probes, 0, NULL, 0); 229 229 + err = mtd_device_parse_register(info->mtd, probes, NULL, NULL, 0); 230 230 if (err) 231 231 goto Error; 232 232

+4 -1

drivers/mtd/maps/ixp4xx.c

reviewed

··· 182 182 { 183 183 struct flash_platform_data *plat = dev->dev.platform_data; 184 184 struct ixp4xx_flash_info *info; 185 185 + struct mtd_part_parser_data ppdata = { 186 186 + .origin = dev->resource->start, 187 187 + }; 185 188 int err = -1; 186 189 187 190 if (!plat) ··· 250 247 /* Use the fast version */ 251 248 info->map.write = ixp4xx_write16; 252 249 253 253 - err = mtd_device_parse_register(info->mtd, probes, dev->resource->start, 250 250 + err = mtd_device_parse_register(info->mtd, probes, &ppdata, 254 251 plat->parts, plat->nr_parts); 255 252 if (err) { 256 253 printk(KERN_ERR "Could not parse partitions\n");

+9 -5

drivers/mtd/maps/l440gx.c

reviewed

··· 27 27 28 28 29 29 /* Is this really the vpp port? */ 30 30 + static DEFINE_SPINLOCK(l440gx_vpp_lock); 31 31 + static int l440gx_vpp_refcnt; 30 32 static void l440gx_set_vpp(struct map_info *map, int vpp) 31 33 { 32 32 - unsigned long l; 34 34 + unsigned long flags; 33 35 34 34 - l = inl(VPP_PORT); 36 36 + spin_lock_irqsave(&l440gx_vpp_lock, flags); 35 37 if (vpp) { 36 36 - l |= 1; 38 38 + if (++l440gx_vpp_refcnt == 1) /* first nested 'on' */ 39 39 + outl(inl(VPP_PORT) | 1, VPP_PORT); 37 40 } else { 38 38 - l &= ~1; 41 41 + if (--l440gx_vpp_refcnt == 0) /* last nested 'off' */ 42 42 + outl(inl(VPP_PORT) & ~1, VPP_PORT); 39 43 } 40 40 - outl(l, VPP_PORT); 44 44 + spin_unlock_irqrestore(&l440gx_vpp_lock, flags); 41 45 } 42 46 43 47 static struct map_info l440gx_map = {

+4 -2

drivers/mtd/maps/lantiq-flash.c

reviewed

··· 45 45 }; 46 46 47 47 static char ltq_map_name[] = "ltq_nor"; 48 48 + static const char *ltq_probe_types[] __devinitconst = { "cmdlinepart", NULL }; 48 49 49 50 static map_word 50 51 ltq_read16(struct map_info *map, unsigned long adr) ··· 169 168 cfi->addr_unlock1 ^= 1; 170 169 cfi->addr_unlock2 ^= 1; 171 170 172 172 - err = mtd_device_parse_register(ltq_mtd->mtd, NULL, 0, 173 173 - ltq_mtd_data->parts, ltq_mtd_data->nr_parts); 171 171 + err = mtd_device_parse_register(ltq_mtd->mtd, ltq_probe_types, NULL, 172 172 + ltq_mtd_data->parts, 173 173 + ltq_mtd_data->nr_parts); 174 174 if (err) { 175 175 dev_err(&pdev->dev, "failed to add partitions\n"); 176 176 goto err_destroy;

+3 -2

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

reviewed

··· 199 199 } 200 200 info->mtd->owner = THIS_MODULE; 201 201 202 202 - mtd_device_parse_register(info->mtd, NULL, 0, 203 203 - latch_addr_data->parts, latch_addr_data->nr_parts); 202 202 + mtd_device_parse_register(info->mtd, NULL, NULL, 203 203 + latch_addr_data->parts, 204 204 + latch_addr_data->nr_parts); 204 205 return 0; 205 206 206 207 iounmap:

+12 -1

drivers/mtd/maps/pcmciamtd.c

reviewed

··· 294 294 } 295 295 296 296 297 297 + static DEFINE_SPINLOCK(pcmcia_vpp_lock); 298 298 + static int pcmcia_vpp_refcnt; 297 299 static void pcmciamtd_set_vpp(struct map_info *map, int on) 298 300 { 299 301 struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1; 300 302 struct pcmcia_device *link = dev->p_dev; 303 303 + unsigned long flags; 301 304 302 305 pr_debug("dev = %p on = %d vpp = %d\n\n", dev, on, dev->vpp); 303 303 - pcmcia_fixup_vpp(link, on ? dev->vpp : 0); 306 306 + spin_lock_irqsave(&pcmcia_vpp_lock, flags); 307 307 + if (on) { 308 308 + if (++pcmcia_vpp_refcnt == 1) /* first nested 'on' */ 309 309 + pcmcia_fixup_vpp(link, dev->vpp); 310 310 + } else { 311 311 + if (--pcmcia_vpp_refcnt == 0) /* last nested 'off' */ 312 312 + pcmcia_fixup_vpp(link, 0); 313 313 + } 314 314 + spin_unlock_irqrestore(&pcmcia_vpp_lock, flags); 304 315 } 305 316 306 317

+21 -3

drivers/mtd/maps/physmap.c

reviewed

··· 27 27 struct mtd_info *mtd[MAX_RESOURCES]; 28 28 struct mtd_info *cmtd; 29 29 struct map_info map[MAX_RESOURCES]; 30 30 + spinlock_t vpp_lock; 31 31 + int vpp_refcnt; 30 32 }; 31 33 32 34 static int physmap_flash_remove(struct platform_device *dev) ··· 65 63 { 66 64 struct platform_device *pdev; 67 65 struct physmap_flash_data *physmap_data; 66 66 + struct physmap_flash_info *info; 67 67 + unsigned long flags; 68 68 69 69 pdev = (struct platform_device *)map->map_priv_1; 70 70 physmap_data = pdev->dev.platform_data; 71 71 72 72 - if (physmap_data->set_vpp) 73 73 - physmap_data->set_vpp(pdev, state); 72 72 + if (!physmap_data->set_vpp) 73 73 + return; 74 74 + 75 75 + info = platform_get_drvdata(pdev); 76 76 + 77 77 + spin_lock_irqsave(&info->vpp_lock, flags); 78 78 + if (state) { 79 79 + if (++info->vpp_refcnt == 1) /* first nested 'on' */ 80 80 + physmap_data->set_vpp(pdev, 1); 81 81 + } else { 82 82 + if (--info->vpp_refcnt == 0) /* last nested 'off' */ 83 83 + physmap_data->set_vpp(pdev, 0); 84 84 + } 85 85 + spin_unlock_irqrestore(&info->vpp_lock, flags); 74 86 } 75 87 76 88 static const char *rom_probe_types[] = { ··· 188 172 if (err) 189 173 goto err_out; 190 174 175 175 + spin_lock_init(&info->vpp_lock); 176 176 + 191 177 part_types = physmap_data->part_probe_types ? : part_probe_types; 192 178 193 193 - mtd_device_parse_register(info->cmtd, part_types, 0, 179 179 + mtd_device_parse_register(info->cmtd, part_types, NULL, 194 180 physmap_data->parts, physmap_data->nr_parts); 195 181 return 0; 196 182

+3 -2

drivers/mtd/maps/plat-ram.c

reviewed

··· 222 222 /* check to see if there are any available partitions, or wether 223 223 * to add this device whole */ 224 224 225 225 - err = mtd_device_parse_register(info->mtd, pdata->probes, 0, 226 226 - pdata->partitions, pdata->nr_partitions); 225 225 + err = mtd_device_parse_register(info->mtd, pdata->probes, NULL, 226 226 + pdata->partitions, 227 227 + pdata->nr_partitions); 227 228 if (!err) 228 229 dev_info(&pdev->dev, "registered mtd device\n"); 229 230

+2 -1

drivers/mtd/maps/pxa2xx-flash.c

reviewed

··· 98 98 } 99 99 info->mtd->owner = THIS_MODULE; 100 100 101 101 - mtd_device_parse_register(info->mtd, probes, 0, flash->parts, flash->nr_parts); 101 101 + mtd_device_parse_register(info->mtd, probes, NULL, flash->parts, 102 102 + flash->nr_parts); 102 103 103 104 platform_set_drvdata(pdev, info); 104 105 return 0;

+2 -2

drivers/mtd/maps/rbtx4939-flash.c

reviewed

··· 102 102 info->mtd->owner = THIS_MODULE; 103 103 if (err) 104 104 goto err_out; 105 105 - err = mtd_device_parse_register(info->mtd, NULL, 0, 106 106 - pdata->parts, pdata->nr_parts); 105 105 + err = mtd_device_parse_register(info->mtd, NULL, NULL, pdata->parts, 106 106 + pdata->nr_parts); 107 107 108 108 if (err) 109 109 goto err_out;

+15 -3

drivers/mtd/maps/sa1100-flash.c

reviewed

··· 36 36 struct sa_subdev_info subdev[0]; 37 37 }; 38 38 39 39 + static DEFINE_SPINLOCK(sa1100_vpp_lock); 40 40 + static int sa1100_vpp_refcnt; 39 41 static void sa1100_set_vpp(struct map_info *map, int on) 40 42 { 41 43 struct sa_subdev_info *subdev = container_of(map, struct sa_subdev_info, map); 42 42 - subdev->plat->set_vpp(on); 44 44 + unsigned long flags; 45 45 + 46 46 + spin_lock_irqsave(&sa1100_vpp_lock, flags); 47 47 + if (on) { 48 48 + if (++sa1100_vpp_refcnt == 1) /* first nested 'on' */ 49 49 + subdev->plat->set_vpp(1); 50 50 + } else { 51 51 + if (--sa1100_vpp_refcnt == 0) /* last nested 'off' */ 52 52 + subdev->plat->set_vpp(0); 53 53 + } 54 54 + spin_unlock_irqrestore(&sa1100_vpp_lock, flags); 43 55 } 44 56 45 57 static void sa1100_destroy_subdev(struct sa_subdev_info *subdev) ··· 264 252 /* 265 253 * Partition selection stuff. 266 254 */ 267 267 - mtd_device_parse_register(info->mtd, part_probes, 0, 268 268 - plat->parts, plat->nr_parts); 255 255 + mtd_device_parse_register(info->mtd, part_probes, NULL, plat->parts, 256 256 + plat->nr_parts); 269 257 270 258 platform_set_drvdata(pdev, info); 271 259 err = 0;

+2 -2

drivers/mtd/maps/solutionengine.c

reviewed

··· 92 92 mtd_device_register(eprom_mtd, NULL, 0); 93 93 } 94 94 95 95 - mtd_device_parse_register(flash_mtd, probes, 0, 96 96 - superh_se_partitions, NUM_PARTITIONS); 95 95 + mtd_device_parse_register(flash_mtd, probes, NULL, 96 96 + superh_se_partitions, NUM_PARTITIONS); 97 97 98 98 return 0; 99 99 }

+1 -1

drivers/mtd/maps/uclinux.c

reviewed

··· 85 85 } 86 86 87 87 mtd->owner = THIS_MODULE; 88 88 - mtd->point = uclinux_point; 88 88 + mtd->_point = uclinux_point; 89 89 mtd->priv = mapp; 90 90 91 91 uclinux_ram_mtdinfo = mtd;

+3 -11

drivers/mtd/maps/vmu-flash.c

reviewed

··· 360 360 int index = 0, retval, partition, leftover, numblocks; 361 361 unsigned char cx; 362 362 363 363 - if (len < 1) 364 364 - return -EIO; 365 365 - 366 363 mpart = mtd->priv; 367 364 mdev = mpart->mdev; 368 365 partition = mpart->partition; ··· 431 434 partition = mpart->partition; 432 435 card = maple_get_drvdata(mdev); 433 436 434 434 - /* simple sanity checks */ 435 435 - if (len < 1) { 436 436 - error = -EIO; 437 437 - goto failed; 438 438 - } 439 437 numblocks = card->parts[partition].numblocks; 440 438 if (to + len > numblocks * card->blocklen) 441 439 len = numblocks * card->blocklen - to; ··· 536 544 mtd_cur->flags = MTD_WRITEABLE|MTD_NO_ERASE; 537 545 mtd_cur->size = part_cur->numblocks * card->blocklen; 538 546 mtd_cur->erasesize = card->blocklen; 539 539 - mtd_cur->write = vmu_flash_write; 540 540 - mtd_cur->read = vmu_flash_read; 541 541 - mtd_cur->sync = vmu_flash_sync; 547 547 + mtd_cur->_write = vmu_flash_write; 548 548 + mtd_cur->_read = vmu_flash_read; 549 549 + mtd_cur->_sync = vmu_flash_sync; 542 550 mtd_cur->writesize = card->blocklen; 543 551 544 552 mpart = kmalloc(sizeof(struct mdev_part), GFP_KERNEL);

+1 -1

drivers/mtd/maps/wr_sbc82xx_flash.c

reviewed

··· 142 142 nr_parts = ARRAY_SIZE(smallflash_parts); 143 143 } 144 144 145 145 - mtd_device_parse_register(sbcmtd[i], part_probes, 0, 145 145 + mtd_device_parse_register(sbcmtd[i], part_probes, NULL, 146 146 defparts, nr_parts); 147 147 } 148 148 return 0;

+1

drivers/mtd/mtd_blkdevs.c

reviewed

··· 233 233 ret = __get_mtd_device(dev->mtd); 234 234 if (ret) 235 235 goto error_release; 236 236 + dev->file_mode = mode; 236 237 237 238 unlock: 238 239 dev->open++;

+6 -2

drivers/mtd/mtdblock.c

reviewed

··· 321 321 mutex_unlock(&mtdblk->cache_mutex); 322 322 323 323 if (!--mtdblk->count) { 324 324 - /* It was the last usage. Free the cache */ 325 325 - mtd_sync(mbd->mtd); 324 324 + /* 325 325 + * It was the last usage. Free the cache, but only sync if 326 326 + * opened for writing. 327 327 + */ 328 328 + if (mbd->file_mode & FMODE_WRITE) 329 329 + mtd_sync(mbd->mtd); 326 330 vfree(mtdblk->cache_data); 327 331 } 328 332

+2 -2

drivers/mtd/mtdchar.c

reviewed

··· 405 405 if (length > 4096) 406 406 return -EINVAL; 407 407 408 408 - if (!mtd->write_oob) 408 408 + if (!mtd->_write_oob) 409 409 ret = -EOPNOTSUPP; 410 410 else 411 411 ret = access_ok(VERIFY_READ, ptr, length) ? 0 : -EFAULT; ··· 576 576 !access_ok(VERIFY_READ, req.usr_data, req.len) || 577 577 !access_ok(VERIFY_READ, req.usr_oob, req.ooblen)) 578 578 return -EFAULT; 579 579 - if (!mtd->write_oob) 579 579 + if (!mtd->_write_oob) 580 580 return -EOPNOTSUPP; 581 581 582 582 ops.mode = req.mode;

+24 -82

drivers/mtd/mtdconcat.c

reviewed

··· 72 72 int ret = 0, err; 73 73 int i; 74 74 75 75 - *retlen = 0; 76 76 - 77 75 for (i = 0; i < concat->num_subdev; i++) { 78 76 struct mtd_info *subdev = concat->subdev[i]; 79 77 size_t size, retsize; ··· 124 126 int err = -EINVAL; 125 127 int i; 126 128 127 127 - if (!(mtd->flags & MTD_WRITEABLE)) 128 128 - return -EROFS; 129 129 - 130 130 - *retlen = 0; 131 131 - 132 129 for (i = 0; i < concat->num_subdev; i++) { 133 130 struct mtd_info *subdev = concat->subdev[i]; 134 131 size_t size, retsize; ··· 138 145 else 139 146 size = len; 140 147 141 141 - if (!(subdev->flags & MTD_WRITEABLE)) 142 142 - err = -EROFS; 143 143 - else 144 144 - err = mtd_write(subdev, to, size, &retsize, buf); 145 145 - 148 148 + err = mtd_write(subdev, to, size, &retsize, buf); 146 149 if (err) 147 150 break; 148 151 ··· 165 176 int i; 166 177 int err = -EINVAL; 167 178 168 168 - if (!(mtd->flags & MTD_WRITEABLE)) 169 169 - return -EROFS; 170 170 - 171 171 - *retlen = 0; 172 172 - 173 179 /* Calculate total length of data */ 174 180 for (i = 0; i < count; i++) 175 181 total_len += vecs[i].iov_len; 176 176 - 177 177 - /* Do not allow write past end of device */ 178 178 - if ((to + total_len) > mtd->size) 179 179 - return -EINVAL; 180 182 181 183 /* Check alignment */ 182 184 if (mtd->writesize > 1) { ··· 204 224 old_iov_len = vecs_copy[entry_high].iov_len; 205 225 vecs_copy[entry_high].iov_len = size; 206 226 207 207 - if (!(subdev->flags & MTD_WRITEABLE)) 208 208 - err = -EROFS; 209 209 - else 210 210 - err = mtd_writev(subdev, &vecs_copy[entry_low], 211 211 - entry_high - entry_low + 1, to, 212 212 - &retsize); 227 227 + err = mtd_writev(subdev, &vecs_copy[entry_low], 228 228 + entry_high - entry_low + 1, to, &retsize); 213 229 214 230 vecs_copy[entry_high].iov_len = old_iov_len - size; 215 231 vecs_copy[entry_high].iov_base += size; ··· 379 403 uint64_t length, offset = 0; 380 404 struct erase_info *erase; 381 405 382 382 - if (!(mtd->flags & MTD_WRITEABLE)) 383 383 - return -EROFS; 384 384 - 385 385 - if (instr->addr > concat->mtd.size) 386 386 - return -EINVAL; 387 387 - 388 388 - if (instr->len + instr->addr > concat->mtd.size) 389 389 - return -EINVAL; 390 390 - 391 406 /* 392 407 * Check for proper erase block alignment of the to-be-erased area. 393 408 * It is easier to do this based on the super device's erase ··· 426 459 return -EINVAL; 427 460 } 428 461 429 429 - instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 430 430 - 431 462 /* make a local copy of instr to avoid modifying the caller's struct */ 432 463 erase = kmalloc(sizeof (struct erase_info), GFP_KERNEL); 433 464 ··· 464 499 else 465 500 erase->len = length; 466 501 467 467 - if (!(subdev->flags & MTD_WRITEABLE)) { 468 468 - err = -EROFS; 469 469 - break; 470 470 - } 471 502 length -= erase->len; 472 503 if ((err = concat_dev_erase(subdev, erase))) { 473 504 /* sanity check: should never happen since ··· 499 538 struct mtd_concat *concat = CONCAT(mtd); 500 539 int i, err = -EINVAL; 501 540 502 502 - if ((len + ofs) > mtd->size) 503 503 - return -EINVAL; 504 504 - 505 541 for (i = 0; i < concat->num_subdev; i++) { 506 542 struct mtd_info *subdev = concat->subdev[i]; 507 543 uint64_t size; ··· 532 574 { 533 575 struct mtd_concat *concat = CONCAT(mtd); 534 576 int i, err = 0; 535 535 - 536 536 - if ((len + ofs) > mtd->size) 537 537 - return -EINVAL; 538 577 539 578 for (i = 0; i < concat->num_subdev; i++) { 540 579 struct mtd_info *subdev = concat->subdev[i]; ··· 605 650 if (!mtd_can_have_bb(concat->subdev[0])) 606 651 return res; 607 652 608 608 - if (ofs > mtd->size) 609 609 - return -EINVAL; 610 610 - 611 653 for (i = 0; i < concat->num_subdev; i++) { 612 654 struct mtd_info *subdev = concat->subdev[i]; 613 655 ··· 624 672 { 625 673 struct mtd_concat *concat = CONCAT(mtd); 626 674 int i, err = -EINVAL; 627 627 - 628 628 - if (!mtd_can_have_bb(concat->subdev[0])) 629 629 - return 0; 630 630 - 631 631 - if (ofs > mtd->size) 632 632 - return -EINVAL; 633 675 634 676 for (i = 0; i < concat->num_subdev; i++) { 635 677 struct mtd_info *subdev = concat->subdev[i]; ··· 661 715 offset -= subdev->size; 662 716 continue; 663 717 } 664 664 - 665 665 - /* we've found the subdev over which the mapping will reside */ 666 666 - if (offset + len > subdev->size) 667 667 - return (unsigned long) -EINVAL; 668 718 669 719 return mtd_get_unmapped_area(subdev, len, offset, flags); 670 720 } ··· 719 777 concat->mtd.subpage_sft = subdev[0]->subpage_sft; 720 778 concat->mtd.oobsize = subdev[0]->oobsize; 721 779 concat->mtd.oobavail = subdev[0]->oobavail; 722 722 - if (subdev[0]->writev) 723 723 - concat->mtd.writev = concat_writev; 724 724 - if (subdev[0]->read_oob) 725 725 - concat->mtd.read_oob = concat_read_oob; 726 726 - if (subdev[0]->write_oob) 727 727 - concat->mtd.write_oob = concat_write_oob; 728 728 - if (subdev[0]->block_isbad) 729 729 - concat->mtd.block_isbad = concat_block_isbad; 730 730 - if (subdev[0]->block_markbad) 731 731 - concat->mtd.block_markbad = concat_block_markbad; 780 780 + if (subdev[0]->_writev) 781 781 + concat->mtd._writev = concat_writev; 782 782 + if (subdev[0]->_read_oob) 783 783 + concat->mtd._read_oob = concat_read_oob; 784 784 + if (subdev[0]->_write_oob) 785 785 + concat->mtd._write_oob = concat_write_oob; 786 786 + if (subdev[0]->_block_isbad) 787 787 + concat->mtd._block_isbad = concat_block_isbad; 788 788 + if (subdev[0]->_block_markbad) 789 789 + concat->mtd._block_markbad = concat_block_markbad; 732 790 733 791 concat->mtd.ecc_stats.badblocks = subdev[0]->ecc_stats.badblocks; 734 792 ··· 775 833 if (concat->mtd.writesize != subdev[i]->writesize || 776 834 concat->mtd.subpage_sft != subdev[i]->subpage_sft || 777 835 concat->mtd.oobsize != subdev[i]->oobsize || 778 778 - !concat->mtd.read_oob != !subdev[i]->read_oob || 779 779 - !concat->mtd.write_oob != !subdev[i]->write_oob) { 836 836 + !concat->mtd._read_oob != !subdev[i]->_read_oob || 837 837 + !concat->mtd._write_oob != !subdev[i]->_write_oob) { 780 838 kfree(concat); 781 839 printk("Incompatible OOB or ECC data on \"%s\"\n", 782 840 subdev[i]->name); ··· 791 849 concat->num_subdev = num_devs; 792 850 concat->mtd.name = name; 793 851 794 794 - concat->mtd.erase = concat_erase; 795 795 - concat->mtd.read = concat_read; 796 796 - concat->mtd.write = concat_write; 797 797 - concat->mtd.sync = concat_sync; 798 798 - concat->mtd.lock = concat_lock; 799 799 - concat->mtd.unlock = concat_unlock; 800 800 - concat->mtd.suspend = concat_suspend; 801 801 - concat->mtd.resume = concat_resume; 802 802 - concat->mtd.get_unmapped_area = concat_get_unmapped_area; 852 852 + concat->mtd._erase = concat_erase; 853 853 + concat->mtd._read = concat_read; 854 854 + concat->mtd._write = concat_write; 855 855 + concat->mtd._sync = concat_sync; 856 856 + concat->mtd._lock = concat_lock; 857 857 + concat->mtd._unlock = concat_unlock; 858 858 + concat->mtd._suspend = concat_suspend; 859 859 + concat->mtd._resume = concat_resume; 860 860 + concat->mtd._get_unmapped_area = concat_get_unmapped_area; 803 861 804 862 /* 805 863 * Combine the erase block size info of the subdevices:

+263 -8

drivers/mtd/mtdcore.c

reviewed

··· 107 107 */ 108 108 static void mtd_release(struct device *dev) 109 109 { 110 110 - struct mtd_info *mtd = dev_get_drvdata(dev); 110 110 + struct mtd_info __maybe_unused *mtd = dev_get_drvdata(dev); 111 111 dev_t index = MTD_DEVT(mtd->index); 112 112 113 113 /* remove /dev/mtdXro node if needed */ ··· 126 126 { 127 127 struct mtd_info *mtd = dev_get_drvdata(dev); 128 128 129 129 - if (mtd && mtd->resume) 129 129 + if (mtd) 130 130 mtd_resume(mtd); 131 131 return 0; 132 132 } ··· 610 610 if (!try_module_get(mtd->owner)) 611 611 return -ENODEV; 612 612 613 613 - if (mtd->get_device) { 614 614 - err = mtd->get_device(mtd); 613 613 + if (mtd->_get_device) { 614 614 + err = mtd->_get_device(mtd); 615 615 616 616 if (err) { 617 617 module_put(mtd->owner); ··· 675 675 --mtd->usecount; 676 676 BUG_ON(mtd->usecount < 0); 677 677 678 678 - if (mtd->put_device) 679 679 - mtd->put_device(mtd); 678 678 + if (mtd->_put_device) 679 679 + mtd->_put_device(mtd); 680 680 681 681 module_put(mtd->owner); 682 682 } 683 683 EXPORT_SYMBOL_GPL(__put_mtd_device); 684 684 + 685 685 + /* 686 686 + * Erase is an asynchronous operation. Device drivers are supposed 687 687 + * to call instr->callback() whenever the operation completes, even 688 688 + * if it completes with a failure. 689 689 + * Callers are supposed to pass a callback function and wait for it 690 690 + * to be called before writing to the block. 691 691 + */ 692 692 + int mtd_erase(struct mtd_info *mtd, struct erase_info *instr) 693 693 + { 694 694 + if (instr->addr > mtd->size || instr->len > mtd->size - instr->addr) 695 695 + return -EINVAL; 696 696 + if (!(mtd->flags & MTD_WRITEABLE)) 697 697 + return -EROFS; 698 698 + instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 699 699 + if (!instr->len) { 700 700 + instr->state = MTD_ERASE_DONE; 701 701 + mtd_erase_callback(instr); 702 702 + return 0; 703 703 + } 704 704 + return mtd->_erase(mtd, instr); 705 705 + } 706 706 + EXPORT_SYMBOL_GPL(mtd_erase); 707 707 + 708 708 + /* 709 709 + * This stuff for eXecute-In-Place. phys is optional and may be set to NULL. 710 710 + */ 711 711 + int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 712 712 + void **virt, resource_size_t *phys) 713 713 + { 714 714 + *retlen = 0; 715 715 + *virt = NULL; 716 716 + if (phys) 717 717 + *phys = 0; 718 718 + if (!mtd->_point) 719 719 + return -EOPNOTSUPP; 720 720 + if (from < 0 || from > mtd->size || len > mtd->size - from) 721 721 + return -EINVAL; 722 722 + if (!len) 723 723 + return 0; 724 724 + return mtd->_point(mtd, from, len, retlen, virt, phys); 725 725 + } 726 726 + EXPORT_SYMBOL_GPL(mtd_point); 727 727 + 728 728 + /* We probably shouldn't allow XIP if the unpoint isn't a NULL */ 729 729 + int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 730 730 + { 731 731 + if (!mtd->_point) 732 732 + return -EOPNOTSUPP; 733 733 + if (from < 0 || from > mtd->size || len > mtd->size - from) 734 734 + return -EINVAL; 735 735 + if (!len) 736 736 + return 0; 737 737 + return mtd->_unpoint(mtd, from, len); 738 738 + } 739 739 + EXPORT_SYMBOL_GPL(mtd_unpoint); 740 740 + 741 741 + /* 742 742 + * Allow NOMMU mmap() to directly map the device (if not NULL) 743 743 + * - return the address to which the offset maps 744 744 + * - return -ENOSYS to indicate refusal to do the mapping 745 745 + */ 746 746 + unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len, 747 747 + unsigned long offset, unsigned long flags) 748 748 + { 749 749 + if (!mtd->_get_unmapped_area) 750 750 + return -EOPNOTSUPP; 751 751 + if (offset > mtd->size || len > mtd->size - offset) 752 752 + return -EINVAL; 753 753 + return mtd->_get_unmapped_area(mtd, len, offset, flags); 754 754 + } 755 755 + EXPORT_SYMBOL_GPL(mtd_get_unmapped_area); 756 756 + 757 757 + int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 758 758 + u_char *buf) 759 759 + { 760 760 + *retlen = 0; 761 761 + if (from < 0 || from > mtd->size || len > mtd->size - from) 762 762 + return -EINVAL; 763 763 + if (!len) 764 764 + return 0; 765 765 + return mtd->_read(mtd, from, len, retlen, buf); 766 766 + } 767 767 + EXPORT_SYMBOL_GPL(mtd_read); 768 768 + 769 769 + int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 770 770 + const u_char *buf) 771 771 + { 772 772 + *retlen = 0; 773 773 + if (to < 0 || to > mtd->size || len > mtd->size - to) 774 774 + return -EINVAL; 775 775 + if (!mtd->_write || !(mtd->flags & MTD_WRITEABLE)) 776 776 + return -EROFS; 777 777 + if (!len) 778 778 + return 0; 779 779 + return mtd->_write(mtd, to, len, retlen, buf); 780 780 + } 781 781 + EXPORT_SYMBOL_GPL(mtd_write); 782 782 + 783 783 + /* 784 784 + * In blackbox flight recorder like scenarios we want to make successful writes 785 785 + * in interrupt context. panic_write() is only intended to be called when its 786 786 + * known the kernel is about to panic and we need the write to succeed. Since 787 787 + * the kernel is not going to be running for much longer, this function can 788 788 + * break locks and delay to ensure the write succeeds (but not sleep). 789 789 + */ 790 790 + int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 791 791 + const u_char *buf) 792 792 + { 793 793 + *retlen = 0; 794 794 + if (!mtd->_panic_write) 795 795 + return -EOPNOTSUPP; 796 796 + if (to < 0 || to > mtd->size || len > mtd->size - to) 797 797 + return -EINVAL; 798 798 + if (!(mtd->flags & MTD_WRITEABLE)) 799 799 + return -EROFS; 800 800 + if (!len) 801 801 + return 0; 802 802 + return mtd->_panic_write(mtd, to, len, retlen, buf); 803 803 + } 804 804 + EXPORT_SYMBOL_GPL(mtd_panic_write); 805 805 + 806 806 + /* 807 807 + * Method to access the protection register area, present in some flash 808 808 + * devices. The user data is one time programmable but the factory data is read 809 809 + * only. 810 810 + */ 811 811 + int mtd_get_fact_prot_info(struct mtd_info *mtd, struct otp_info *buf, 812 812 + size_t len) 813 813 + { 814 814 + if (!mtd->_get_fact_prot_info) 815 815 + return -EOPNOTSUPP; 816 816 + if (!len) 817 817 + return 0; 818 818 + return mtd->_get_fact_prot_info(mtd, buf, len); 819 819 + } 820 820 + EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info); 821 821 + 822 822 + int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 823 823 + size_t *retlen, u_char *buf) 824 824 + { 825 825 + *retlen = 0; 826 826 + if (!mtd->_read_fact_prot_reg) 827 827 + return -EOPNOTSUPP; 828 828 + if (!len) 829 829 + return 0; 830 830 + return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf); 831 831 + } 832 832 + EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg); 833 833 + 834 834 + int mtd_get_user_prot_info(struct mtd_info *mtd, struct otp_info *buf, 835 835 + size_t len) 836 836 + { 837 837 + if (!mtd->_get_user_prot_info) 838 838 + return -EOPNOTSUPP; 839 839 + if (!len) 840 840 + return 0; 841 841 + return mtd->_get_user_prot_info(mtd, buf, len); 842 842 + } 843 843 + EXPORT_SYMBOL_GPL(mtd_get_user_prot_info); 844 844 + 845 845 + int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 846 846 + size_t *retlen, u_char *buf) 847 847 + { 848 848 + *retlen = 0; 849 849 + if (!mtd->_read_user_prot_reg) 850 850 + return -EOPNOTSUPP; 851 851 + if (!len) 852 852 + return 0; 853 853 + return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf); 854 854 + } 855 855 + EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg); 856 856 + 857 857 + int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len, 858 858 + size_t *retlen, u_char *buf) 859 859 + { 860 860 + *retlen = 0; 861 861 + if (!mtd->_write_user_prot_reg) 862 862 + return -EOPNOTSUPP; 863 863 + if (!len) 864 864 + return 0; 865 865 + return mtd->_write_user_prot_reg(mtd, to, len, retlen, buf); 866 866 + } 867 867 + EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg); 868 868 + 869 869 + int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len) 870 870 + { 871 871 + if (!mtd->_lock_user_prot_reg) 872 872 + return -EOPNOTSUPP; 873 873 + if (!len) 874 874 + return 0; 875 875 + return mtd->_lock_user_prot_reg(mtd, from, len); 876 876 + } 877 877 + EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg); 878 878 + 879 879 + /* Chip-supported device locking */ 880 880 + int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 881 881 + { 882 882 + if (!mtd->_lock) 883 883 + return -EOPNOTSUPP; 884 884 + if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 885 885 + return -EINVAL; 886 886 + if (!len) 887 887 + return 0; 888 888 + return mtd->_lock(mtd, ofs, len); 889 889 + } 890 890 + EXPORT_SYMBOL_GPL(mtd_lock); 891 891 + 892 892 + int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 893 893 + { 894 894 + if (!mtd->_unlock) 895 895 + return -EOPNOTSUPP; 896 896 + if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 897 897 + return -EINVAL; 898 898 + if (!len) 899 899 + return 0; 900 900 + return mtd->_unlock(mtd, ofs, len); 901 901 + } 902 902 + EXPORT_SYMBOL_GPL(mtd_unlock); 903 903 + 904 904 + int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) 905 905 + { 906 906 + if (!mtd->_is_locked) 907 907 + return -EOPNOTSUPP; 908 908 + if (ofs < 0 || ofs > mtd->size || len > mtd->size - ofs) 909 909 + return -EINVAL; 910 910 + if (!len) 911 911 + return 0; 912 912 + return mtd->_is_locked(mtd, ofs, len); 913 913 + } 914 914 + EXPORT_SYMBOL_GPL(mtd_is_locked); 915 915 + 916 916 + int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs) 917 917 + { 918 918 + if (!mtd->_block_isbad) 919 919 + return 0; 920 920 + if (ofs < 0 || ofs > mtd->size) 921 921 + return -EINVAL; 922 922 + return mtd->_block_isbad(mtd, ofs); 923 923 + } 924 924 + EXPORT_SYMBOL_GPL(mtd_block_isbad); 925 925 + 926 926 + int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs) 927 927 + { 928 928 + if (!mtd->_block_markbad) 929 929 + return -EOPNOTSUPP; 930 930 + if (ofs < 0 || ofs > mtd->size) 931 931 + return -EINVAL; 932 932 + if (!(mtd->flags & MTD_WRITEABLE)) 933 933 + return -EROFS; 934 934 + return mtd->_block_markbad(mtd, ofs); 935 935 + } 936 936 + EXPORT_SYMBOL_GPL(mtd_block_markbad); 684 937 685 938 /* 686 939 * default_mtd_writev - the default writev method ··· 982 729 unsigned long count, loff_t to, size_t *retlen) 983 730 { 984 731 *retlen = 0; 985 985 - if (!mtd->writev) 732 732 + if (!(mtd->flags & MTD_WRITEABLE)) 733 733 + return -EROFS; 734 734 + if (!mtd->_writev) 986 735 return default_mtd_writev(mtd, vecs, count, to, retlen); 987 987 - return mtd->writev(mtd, vecs, count, to, retlen); 736 736 + return mtd->_writev(mtd, vecs, count, to, retlen); 988 737 } 989 738 EXPORT_SYMBOL_GPL(mtd_writev); 990 739

+4 -5

drivers/mtd/mtdoops.c

reviewed

··· 169 169 cxt->nextpage = 0; 170 170 } 171 171 172 172 - while (mtd_can_have_bb(mtd)) { 172 172 + while (1) { 173 173 ret = mtd_block_isbad(mtd, cxt->nextpage * record_size); 174 174 if (!ret) 175 175 break; ··· 199 199 return; 200 200 } 201 201 202 202 - if (mtd_can_have_bb(mtd) && ret == -EIO) { 202 202 + if (ret == -EIO) { 203 203 ret = mtd_block_markbad(mtd, cxt->nextpage * record_size); 204 204 - if (ret < 0) { 204 204 + if (ret < 0 && ret != -EOPNOTSUPP) { 205 205 printk(KERN_ERR "mtdoops: block_markbad failed, aborting\n"); 206 206 return; 207 207 } ··· 257 257 size_t retlen; 258 258 259 259 for (page = 0; page < cxt->oops_pages; page++) { 260 260 - if (mtd_can_have_bb(mtd) && 261 261 - mtd_block_isbad(mtd, page * record_size)) 260 260 + if (mtd_block_isbad(mtd, page * record_size)) 262 261 continue; 263 262 /* Assume the page is used */ 264 263 mark_page_used(cxt, page);

+84 -116

drivers/mtd/mtdpart.c

reviewed

··· 65 65 int res; 66 66 67 67 stats = part->master->ecc_stats; 68 68 - 69 69 - if (from >= mtd->size) 70 70 - len = 0; 71 71 - else if (from + len > mtd->size) 72 72 - len = mtd->size - from; 73 73 - res = mtd_read(part->master, from + part->offset, len, retlen, buf); 68 68 + res = part->master->_read(part->master, from + part->offset, len, 69 69 + retlen, buf); 74 70 if (unlikely(res)) { 75 71 if (mtd_is_bitflip(res)) 76 72 mtd->ecc_stats.corrected += part->master->ecc_stats.corrected - stats.corrected; ··· 80 84 size_t *retlen, void **virt, resource_size_t *phys) 81 85 { 82 86 struct mtd_part *part = PART(mtd); 83 83 - if (from >= mtd->size) 84 84 - len = 0; 85 85 - else if (from + len > mtd->size) 86 86 - len = mtd->size - from; 87 87 - return mtd_point(part->master, from + part->offset, len, retlen, 88 88 - virt, phys); 87 87 + 88 88 + return part->master->_point(part->master, from + part->offset, len, 89 89 + retlen, virt, phys); 89 90 } 90 91 91 91 - static void part_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 92 92 + static int part_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 92 93 { 93 94 struct mtd_part *part = PART(mtd); 94 95 95 95 - mtd_unpoint(part->master, from + part->offset, len); 96 96 + return part->master->_unpoint(part->master, from + part->offset, len); 96 97 } 97 98 98 99 static unsigned long part_get_unmapped_area(struct mtd_info *mtd, ··· 100 107 struct mtd_part *part = PART(mtd); 101 108 102 109 offset += part->offset; 103 103 - return mtd_get_unmapped_area(part->master, len, offset, flags); 110 110 + return part->master->_get_unmapped_area(part->master, len, offset, 111 111 + flags); 104 112 } 105 113 106 114 static int part_read_oob(struct mtd_info *mtd, loff_t from, ··· 132 138 return -EINVAL; 133 139 } 134 140 135 135 - res = mtd_read_oob(part->master, from + part->offset, ops); 141 141 + res = part->master->_read_oob(part->master, from + part->offset, ops); 136 142 if (unlikely(res)) { 137 143 if (mtd_is_bitflip(res)) 138 144 mtd->ecc_stats.corrected++; ··· 146 152 size_t len, size_t *retlen, u_char *buf) 147 153 { 148 154 struct mtd_part *part = PART(mtd); 149 149 - return mtd_read_user_prot_reg(part->master, from, len, retlen, buf); 155 155 + return part->master->_read_user_prot_reg(part->master, from, len, 156 156 + retlen, buf); 150 157 } 151 158 152 159 static int part_get_user_prot_info(struct mtd_info *mtd, 153 160 struct otp_info *buf, size_t len) 154 161 { 155 162 struct mtd_part *part = PART(mtd); 156 156 - return mtd_get_user_prot_info(part->master, buf, len); 163 163 + return part->master->_get_user_prot_info(part->master, buf, len); 157 164 } 158 165 159 166 static int part_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, 160 167 size_t len, size_t *retlen, u_char *buf) 161 168 { 162 169 struct mtd_part *part = PART(mtd); 163 163 - return mtd_read_fact_prot_reg(part->master, from, len, retlen, buf); 170 170 + return part->master->_read_fact_prot_reg(part->master, from, len, 171 171 + retlen, buf); 164 172 } 165 173 166 174 static int part_get_fact_prot_info(struct mtd_info *mtd, struct otp_info *buf, 167 175 size_t len) 168 176 { 169 177 struct mtd_part *part = PART(mtd); 170 170 - return mtd_get_fact_prot_info(part->master, buf, len); 178 178 + return part->master->_get_fact_prot_info(part->master, buf, len); 171 179 } 172 180 173 181 static int part_write(struct mtd_info *mtd, loff_t to, size_t len, 174 182 size_t *retlen, const u_char *buf) 175 183 { 176 184 struct mtd_part *part = PART(mtd); 177 177 - if (!(mtd->flags & MTD_WRITEABLE)) 178 178 - return -EROFS; 179 179 - if (to >= mtd->size) 180 180 - len = 0; 181 181 - else if (to + len > mtd->size) 182 182 - len = mtd->size - to; 183 183 - return mtd_write(part->master, to + part->offset, len, retlen, buf); 185 185 + return part->master->_write(part->master, to + part->offset, len, 186 186 + retlen, buf); 184 187 } 185 188 186 189 static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len, 187 190 size_t *retlen, const u_char *buf) 188 191 { 189 192 struct mtd_part *part = PART(mtd); 190 190 - if (!(mtd->flags & MTD_WRITEABLE)) 191 191 - return -EROFS; 192 192 - if (to >= mtd->size) 193 193 - len = 0; 194 194 - else if (to + len > mtd->size) 195 195 - len = mtd->size - to; 196 196 - return mtd_panic_write(part->master, to + part->offset, len, retlen, 197 197 - buf); 193 193 + return part->master->_panic_write(part->master, to + part->offset, len, 194 194 + retlen, buf); 198 195 } 199 196 200 197 static int part_write_oob(struct mtd_info *mtd, loff_t to, ··· 193 208 { 194 209 struct mtd_part *part = PART(mtd); 195 210 196 196 - if (!(mtd->flags & MTD_WRITEABLE)) 197 197 - return -EROFS; 198 198 - 199 211 if (to >= mtd->size) 200 212 return -EINVAL; 201 213 if (ops->datbuf && to + ops->len > mtd->size) 202 214 return -EINVAL; 203 203 - return mtd_write_oob(part->master, to + part->offset, ops); 215 215 + return part->master->_write_oob(part->master, to + part->offset, ops); 204 216 } 205 217 206 218 static int part_write_user_prot_reg(struct mtd_info *mtd, loff_t from, 207 219 size_t len, size_t *retlen, u_char *buf) 208 220 { 209 221 struct mtd_part *part = PART(mtd); 210 210 - return mtd_write_user_prot_reg(part->master, from, len, retlen, buf); 222 222 + return part->master->_write_user_prot_reg(part->master, from, len, 223 223 + retlen, buf); 211 224 } 212 225 213 226 static int part_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, 214 227 size_t len) 215 228 { 216 229 struct mtd_part *part = PART(mtd); 217 217 - return mtd_lock_user_prot_reg(part->master, from, len); 230 230 + return part->master->_lock_user_prot_reg(part->master, from, len); 218 231 } 219 232 220 233 static int part_writev(struct mtd_info *mtd, const struct kvec *vecs, 221 234 unsigned long count, loff_t to, size_t *retlen) 222 235 { 223 236 struct mtd_part *part = PART(mtd); 224 224 - if (!(mtd->flags & MTD_WRITEABLE)) 225 225 - return -EROFS; 226 226 - return mtd_writev(part->master, vecs, count, to + part->offset, 227 227 - retlen); 237 237 + return part->master->_writev(part->master, vecs, count, 238 238 + to + part->offset, retlen); 228 239 } 229 240 230 241 static int part_erase(struct mtd_info *mtd, struct erase_info *instr) 231 242 { 232 243 struct mtd_part *part = PART(mtd); 233 244 int ret; 234 234 - if (!(mtd->flags & MTD_WRITEABLE)) 235 235 - return -EROFS; 236 236 - if (instr->addr >= mtd->size) 237 237 - return -EINVAL; 245 245 + 238 246 instr->addr += part->offset; 239 239 - ret = mtd_erase(part->master, instr); 247 247 + ret = part->master->_erase(part->master, instr); 240 248 if (ret) { 241 249 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN) 242 250 instr->fail_addr -= part->offset; ··· 240 262 241 263 void mtd_erase_callback(struct erase_info *instr) 242 264 { 243 243 - if (instr->mtd->erase == part_erase) { 265 265 + if (instr->mtd->_erase == part_erase) { 244 266 struct mtd_part *part = PART(instr->mtd); 245 267 246 268 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN) ··· 255 277 static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 256 278 { 257 279 struct mtd_part *part = PART(mtd); 258 258 - if ((len + ofs) > mtd->size) 259 259 - return -EINVAL; 260 260 - return mtd_lock(part->master, ofs + part->offset, len); 280 280 + return part->master->_lock(part->master, ofs + part->offset, len); 261 281 } 262 282 263 283 static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 264 284 { 265 285 struct mtd_part *part = PART(mtd); 266 266 - if ((len + ofs) > mtd->size) 267 267 - return -EINVAL; 268 268 - return mtd_unlock(part->master, ofs + part->offset, len); 286 286 + return part->master->_unlock(part->master, ofs + part->offset, len); 269 287 } 270 288 271 289 static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) 272 290 { 273 291 struct mtd_part *part = PART(mtd); 274 274 - if ((len + ofs) > mtd->size) 275 275 - return -EINVAL; 276 276 - return mtd_is_locked(part->master, ofs + part->offset, len); 292 292 + return part->master->_is_locked(part->master, ofs + part->offset, len); 277 293 } 278 294 279 295 static void part_sync(struct mtd_info *mtd) 280 296 { 281 297 struct mtd_part *part = PART(mtd); 282 282 - mtd_sync(part->master); 298 298 + part->master->_sync(part->master); 283 299 } 284 300 285 301 static int part_suspend(struct mtd_info *mtd) 286 302 { 287 303 struct mtd_part *part = PART(mtd); 288 288 - return mtd_suspend(part->master); 304 304 + return part->master->_suspend(part->master); 289 305 } 290 306 291 307 static void part_resume(struct mtd_info *mtd) 292 308 { 293 309 struct mtd_part *part = PART(mtd); 294 294 - mtd_resume(part->master); 310 310 + part->master->_resume(part->master); 295 311 } 296 312 297 313 static int part_block_isbad(struct mtd_info *mtd, loff_t ofs) 298 314 { 299 315 struct mtd_part *part = PART(mtd); 300 300 - if (ofs >= mtd->size) 301 301 - return -EINVAL; 302 316 ofs += part->offset; 303 303 - return mtd_block_isbad(part->master, ofs); 317 317 + return part->master->_block_isbad(part->master, ofs); 304 318 } 305 319 306 320 static int part_block_markbad(struct mtd_info *mtd, loff_t ofs) ··· 300 330 struct mtd_part *part = PART(mtd); 301 331 int res; 302 332 303 303 - if (!(mtd->flags & MTD_WRITEABLE)) 304 304 - return -EROFS; 305 305 - if (ofs >= mtd->size) 306 306 - return -EINVAL; 307 333 ofs += part->offset; 308 308 - res = mtd_block_markbad(part->master, ofs); 334 334 + res = part->master->_block_markbad(part->master, ofs); 309 335 if (!res) 310 336 mtd->ecc_stats.badblocks++; 311 337 return res; ··· 376 410 */ 377 411 slave->mtd.dev.parent = master->dev.parent; 378 412 379 379 - slave->mtd.read = part_read; 380 380 - slave->mtd.write = part_write; 413 413 + slave->mtd._read = part_read; 414 414 + slave->mtd._write = part_write; 381 415 382 382 - if (master->panic_write) 383 383 - slave->mtd.panic_write = part_panic_write; 416 416 + if (master->_panic_write) 417 417 + slave->mtd._panic_write = part_panic_write; 384 418 385 385 - if (master->point && master->unpoint) { 386 386 - slave->mtd.point = part_point; 387 387 - slave->mtd.unpoint = part_unpoint; 419 419 + if (master->_point && master->_unpoint) { 420 420 + slave->mtd._point = part_point; 421 421 + slave->mtd._unpoint = part_unpoint; 388 422 } 389 423 390 390 - if (master->get_unmapped_area) 391 391 - slave->mtd.get_unmapped_area = part_get_unmapped_area; 392 392 - if (master->read_oob) 393 393 - slave->mtd.read_oob = part_read_oob; 394 394 - if (master->write_oob) 395 395 - slave->mtd.write_oob = part_write_oob; 396 396 - if (master->read_user_prot_reg) 397 397 - slave->mtd.read_user_prot_reg = part_read_user_prot_reg; 398 398 - if (master->read_fact_prot_reg) 399 399 - slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg; 400 400 - if (master->write_user_prot_reg) 401 401 - slave->mtd.write_user_prot_reg = part_write_user_prot_reg; 402 402 - if (master->lock_user_prot_reg) 403 403 - slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg; 404 404 - if (master->get_user_prot_info) 405 405 - slave->mtd.get_user_prot_info = part_get_user_prot_info; 406 406 - if (master->get_fact_prot_info) 407 407 - slave->mtd.get_fact_prot_info = part_get_fact_prot_info; 408 408 - if (master->sync) 409 409 - slave->mtd.sync = part_sync; 410 410 - if (!partno && !master->dev.class && master->suspend && master->resume) { 411 411 - slave->mtd.suspend = part_suspend; 412 412 - slave->mtd.resume = part_resume; 424 424 + if (master->_get_unmapped_area) 425 425 + slave->mtd._get_unmapped_area = part_get_unmapped_area; 426 426 + if (master->_read_oob) 427 427 + slave->mtd._read_oob = part_read_oob; 428 428 + if (master->_write_oob) 429 429 + slave->mtd._write_oob = part_write_oob; 430 430 + if (master->_read_user_prot_reg) 431 431 + slave->mtd._read_user_prot_reg = part_read_user_prot_reg; 432 432 + if (master->_read_fact_prot_reg) 433 433 + slave->mtd._read_fact_prot_reg = part_read_fact_prot_reg; 434 434 + if (master->_write_user_prot_reg) 435 435 + slave->mtd._write_user_prot_reg = part_write_user_prot_reg; 436 436 + if (master->_lock_user_prot_reg) 437 437 + slave->mtd._lock_user_prot_reg = part_lock_user_prot_reg; 438 438 + if (master->_get_user_prot_info) 439 439 + slave->mtd._get_user_prot_info = part_get_user_prot_info; 440 440 + if (master->_get_fact_prot_info) 441 441 + slave->mtd._get_fact_prot_info = part_get_fact_prot_info; 442 442 + if (master->_sync) 443 443 + slave->mtd._sync = part_sync; 444 444 + if (!partno && !master->dev.class && master->_suspend && 445 445 + master->_resume) { 446 446 + slave->mtd._suspend = part_suspend; 447 447 + slave->mtd._resume = part_resume; 413 448 } 414 414 - if (master->writev) 415 415 - slave->mtd.writev = part_writev; 416 416 - if (master->lock) 417 417 - slave->mtd.lock = part_lock; 418 418 - if (master->unlock) 419 419 - slave->mtd.unlock = part_unlock; 420 420 - if (master->is_locked) 421 421 - slave->mtd.is_locked = part_is_locked; 422 422 - if (master->block_isbad) 423 423 - slave->mtd.block_isbad = part_block_isbad; 424 424 - if (master->block_markbad) 425 425 - slave->mtd.block_markbad = part_block_markbad; 426 426 - slave->mtd.erase = part_erase; 449 449 + if (master->_writev) 450 450 + slave->mtd._writev = part_writev; 451 451 + if (master->_lock) 452 452 + slave->mtd._lock = part_lock; 453 453 + if (master->_unlock) 454 454 + slave->mtd._unlock = part_unlock; 455 455 + if (master->_is_locked) 456 456 + slave->mtd._is_locked = part_is_locked; 457 457 + if (master->_block_isbad) 458 458 + slave->mtd._block_isbad = part_block_isbad; 459 459 + if (master->_block_markbad) 460 460 + slave->mtd._block_markbad = part_block_markbad; 461 461 + slave->mtd._erase = part_erase; 427 462 slave->master = master; 428 463 slave->offset = part->offset; 429 464 ··· 516 549 } 517 550 518 551 slave->mtd.ecclayout = master->ecclayout; 519 519 - if (master->block_isbad) { 552 552 + slave->mtd.ecc_strength = master->ecc_strength; 553 553 + if (master->_block_isbad) { 520 554 uint64_t offs = 0; 521 555 522 556 while (offs < slave->mtd.size) { ··· 729 761 for ( ; ret <= 0 && *types; types++) { 730 762 parser = get_partition_parser(*types); 731 763 if (!parser && !request_module("%s", *types)) 732 732 - parser = get_partition_parser(*types); 764 764 + parser = get_partition_parser(*types); 733 765 if (!parser) 734 766 continue; 735 767 ret = (*parser->parse_fn)(master, pparts, data);

+20 -1

drivers/mtd/nand/Kconfig

reviewed

··· 314 314 load time (assuming you build diskonchip as a module) with the module 315 315 parameter "inftl_bbt_write=1". 316 316 317 317 + config MTD_NAND_DOCG4 318 318 + tristate "Support for DiskOnChip G4 (EXPERIMENTAL)" 319 319 + depends on EXPERIMENTAL 320 320 + select BCH 321 321 + select BITREVERSE 322 322 + help 323 323 + Support for diskonchip G4 nand flash, found in various smartphones and 324 324 + PDAs, among them the Palm Treo680, HTC Prophet and Wizard, Toshiba 325 325 + Portege G900, Asus P526, and O2 XDA Zinc. 326 326 + 327 327 + With this driver you will be able to use UBI and create a ubifs on the 328 328 + device, so you may wish to consider enabling UBI and UBIFS as well. 329 329 + 330 330 + These devices ship with the Mys/Sandisk SAFTL formatting, for which 331 331 + there is currently no mtd parser, so you may want to use command line 332 332 + partitioning to segregate write-protected blocks. On the Treo680, the 333 333 + first five erase blocks (256KiB each) are write-protected, followed 334 334 + by the block containing the saftl partition table. This is probably 335 335 + typical. 336 336 + 317 337 config MTD_NAND_SHARPSL 318 338 tristate "Support for NAND Flash on Sharp SL Series (C7xx + others)" 319 339 depends on ARCH_PXA ··· 441 421 config MTD_NAND_GPMI_NAND 442 422 bool "GPMI NAND Flash Controller driver" 443 423 depends on MTD_NAND && (SOC_IMX23 || SOC_IMX28) 444 444 - select MTD_CMDLINE_PARTS 445 424 help 446 425 Enables NAND Flash support for IMX23 or IMX28. 447 426 The GPMI controller is very powerful, with the help of BCH

+1

drivers/mtd/nand/Makefile

reviewed

··· 19 19 obj-$(CONFIG_MTD_NAND_S3C2410) += s3c2410.o 20 20 obj-$(CONFIG_MTD_NAND_DAVINCI) += davinci_nand.o 21 21 obj-$(CONFIG_MTD_NAND_DISKONCHIP) += diskonchip.o 22 22 + obj-$(CONFIG_MTD_NAND_DOCG4) += docg4.o 22 23 obj-$(CONFIG_MTD_NAND_FSMC) += fsmc_nand.o 23 24 obj-$(CONFIG_MTD_NAND_H1900) += h1910.o 24 25 obj-$(CONFIG_MTD_NAND_RTC_FROM4) += rtc_from4.o

+5 -4

drivers/mtd/nand/alauda.c

reviewed

··· 585 585 mtd->writesize = 1<<card->pageshift; 586 586 mtd->type = MTD_NANDFLASH; 587 587 mtd->flags = MTD_CAP_NANDFLASH; 588 588 - mtd->read = alauda_read; 589 589 - mtd->write = alauda_write; 590 590 - mtd->erase = alauda_erase; 591 591 - mtd->block_isbad = alauda_isbad; 588 588 + mtd->_read = alauda_read; 589 589 + mtd->_write = alauda_write; 590 590 + mtd->_erase = alauda_erase; 591 591 + mtd->_block_isbad = alauda_isbad; 592 592 mtd->priv = al; 593 593 mtd->owner = THIS_MODULE; 594 594 + mtd->ecc_strength = 1; 594 595 595 596 err = mtd_device_register(mtd, NULL, 0); 596 597 if (err) {

+1

drivers/mtd/nand/atmel_nand.c

reviewed

··· 603 603 nand_chip->ecc.hwctl = atmel_nand_hwctl; 604 604 nand_chip->ecc.read_page = atmel_nand_read_page; 605 605 nand_chip->ecc.bytes = 4; 606 606 + nand_chip->ecc.strength = 1; 606 607 } 607 608 608 609 nand_chip->chip_delay = 20; /* 20us command delay time */

+9 -1

drivers/mtd/nand/bcm_umi_nand.c

reviewed

··· 475 475 largepage_bbt.options = NAND_BBT_SCAN2NDPAGE; 476 476 this->badblock_pattern = &largepage_bbt; 477 477 } 478 478 + 479 479 + /* 480 480 + * FIXME: ecc strength value of 6 bits per 512 bytes of data is a 481 481 + * conservative guess, given 13 ecc bytes and using bch alg. 482 482 + * (Assume Galois field order m=15 to allow a margin of error.) 483 483 + */ 484 484 + this->ecc.strength = 6; 485 485 + 478 486 #endif 479 487 480 488 /* Now finish off the scan, now that ecc.layout has been initialized. */ ··· 495 487 496 488 /* Register the partitions */ 497 489 board_mtd->name = "bcm_umi-nand"; 498 498 - mtd_device_parse_register(board_mtd, NULL, 0, NULL, 0); 490 490 + mtd_device_parse_register(board_mtd, NULL, NULL, NULL, 0); 499 491 500 492 /* Return happy */ 501 493 return 0;

+2

drivers/mtd/nand/bf5xx_nand.c

reviewed

··· 702 702 if (likely(mtd->writesize >= 512)) { 703 703 chip->ecc.size = 512; 704 704 chip->ecc.bytes = 6; 705 705 + chip->ecc.strength = 2; 705 706 } else { 706 707 chip->ecc.size = 256; 707 708 chip->ecc.bytes = 3; 709 709 + chip->ecc.strength = 1; 708 710 bfin_write_NFC_CTL(bfin_read_NFC_CTL() & ~(1 << NFC_PG_SIZE_OFFSET)); 709 711 SSYNC(); 710 712 }

+2 -1

drivers/mtd/nand/cafe_nand.c

reviewed

··· 783 783 cafe->nand.ecc.mode = NAND_ECC_HW_SYNDROME; 784 784 cafe->nand.ecc.size = mtd->writesize; 785 785 cafe->nand.ecc.bytes = 14; 786 786 + cafe->nand.ecc.strength = 4; 786 787 cafe->nand.ecc.hwctl = (void *)cafe_nand_bug; 787 788 cafe->nand.ecc.calculate = (void *)cafe_nand_bug; 788 789 cafe->nand.ecc.correct = (void *)cafe_nand_bug; ··· 800 799 pci_set_drvdata(pdev, mtd); 801 800 802 801 mtd->name = "cafe_nand"; 803 803 - mtd_device_parse_register(mtd, part_probes, 0, NULL, 0); 802 802 + mtd_device_parse_register(mtd, part_probes, NULL, NULL, 0); 804 803 805 804 goto out; 806 805

+1 -1

drivers/mtd/nand/cmx270_nand.c

reviewed

··· 219 219 } 220 220 221 221 /* Register the partitions */ 222 222 - ret = mtd_device_parse_register(cmx270_nand_mtd, NULL, 0, 222 222 + ret = mtd_device_parse_register(cmx270_nand_mtd, NULL, NULL, 223 223 partition_info, NUM_PARTITIONS); 224 224 if (ret) 225 225 goto err_scan;

+3 -1

drivers/mtd/nand/cs553x_nand.c

reviewed

··· 248 248 goto out_ior; 249 249 } 250 250 251 251 + this->ecc.strength = 1; 252 252 + 251 253 new_mtd->name = kasprintf(GFP_KERNEL, "cs553x_nand_cs%d", cs); 252 254 253 255 cs553x_mtd[cs] = new_mtd; ··· 315 313 for (i = 0; i < NR_CS553X_CONTROLLERS; i++) { 316 314 if (cs553x_mtd[i]) { 317 315 /* If any devices registered, return success. Else the last error. */ 318 318 - mtd_device_parse_register(cs553x_mtd[i], NULL, 0, 316 316 + mtd_device_parse_register(cs553x_mtd[i], NULL, NULL, 319 317 NULL, 0); 320 318 err = 0; 321 319 }

+3 -2

drivers/mtd/nand/davinci_nand.c

reviewed

··· 641 641 info->chip.ecc.bytes = 3; 642 642 } 643 643 info->chip.ecc.size = 512; 644 644 + info->chip.ecc.strength = pdata->ecc_bits; 644 645 break; 645 646 default: 646 647 ret = -EINVAL; ··· 753 752 if (ret < 0) 754 753 goto err_scan; 755 754 756 756 - ret = mtd_device_parse_register(&info->mtd, NULL, 0, 757 757 - pdata->parts, pdata->nr_parts); 755 755 + ret = mtd_device_parse_register(&info->mtd, NULL, NULL, pdata->parts, 756 756 + pdata->nr_parts); 758 757 759 758 if (ret < 0) 760 759 goto err_scan;

+3

drivers/mtd/nand/denali.c

reviewed

··· 1590 1590 ECC_15BITS * (denali->mtd.writesize / 1591 1591 ECC_SECTOR_SIZE)))) { 1592 1592 /* if MLC OOB size is large enough, use 15bit ECC*/ 1593 1593 + denali->nand.ecc.strength = 15; 1593 1594 denali->nand.ecc.layout = &nand_15bit_oob; 1594 1595 denali->nand.ecc.bytes = ECC_15BITS; 1595 1596 iowrite32(15, denali->flash_reg + ECC_CORRECTION); ··· 1601 1600 " contain 8bit ECC correction codes"); 1602 1601 goto failed_req_irq; 1603 1602 } else { 1603 1603 + denali->nand.ecc.strength = 8; 1604 1604 denali->nand.ecc.layout = &nand_8bit_oob; 1605 1605 denali->nand.ecc.bytes = ECC_8BITS; 1606 1606 iowrite32(8, denali->flash_reg + ECC_CORRECTION); 1607 1607 } 1608 1608 1609 1609 denali->nand.ecc.bytes *= denali->devnum; 1610 1610 + denali->nand.ecc.strength *= denali->devnum; 1610 1611 denali->nand.ecc.layout->eccbytes *= 1611 1612 denali->mtd.writesize / ECC_SECTOR_SIZE; 1612 1613 denali->nand.ecc.layout->oobfree[0].offset =

+1

drivers/mtd/nand/diskonchip.c

reviewed

··· 1653 1653 nand->ecc.mode = NAND_ECC_HW_SYNDROME; 1654 1654 nand->ecc.size = 512; 1655 1655 nand->ecc.bytes = 6; 1656 1656 + nand->ecc.strength = 2; 1656 1657 nand->bbt_options = NAND_BBT_USE_FLASH; 1657 1658 1658 1659 doc->physadr = physadr;

+1377

drivers/mtd/nand/docg4.c

reviewed

··· 1 1 + /* 2 2 + * Copyright © 2012 Mike Dunn <mikedunn@newsguy.com> 3 3 + * 4 4 + * mtd nand driver for M-Systems DiskOnChip G4 5 5 + * 6 6 + * This program is free software; you can redistribute it and/or modify 7 7 + * it under the terms of the GNU General Public License as published by 8 8 + * the Free Software Foundation; either version 2 of the License, or 9 9 + * (at your option) any later version. 10 10 + * 11 11 + * Tested on the Palm Treo 680. The G4 is also present on Toshiba Portege, Asus 12 12 + * P526, some HTC smartphones (Wizard, Prophet, ...), O2 XDA Zinc, maybe others. 13 13 + * Should work on these as well. Let me know! 14 14 + * 15 15 + * TODO: 16 16 + * 17 17 + * Mechanism for management of password-protected areas 18 18 + * 19 19 + * Hamming ecc when reading oob only 20 20 + * 21 21 + * According to the M-Sys documentation, this device is also available in a 22 22 + * "dual-die" configuration having a 256MB capacity, but no mechanism for 23 23 + * detecting this variant is documented. Currently this driver assumes 128MB 24 24 + * capacity. 25 25 + * 26 26 + * Support for multiple cascaded devices ("floors"). Not sure which gadgets 27 27 + * contain multiple G4s in a cascaded configuration, if any. 28 28 + * 29 29 + */ 30 30 + 31 31 + #include <linux/kernel.h> 32 32 + #include <linux/slab.h> 33 33 + #include <linux/init.h> 34 34 + #include <linux/string.h> 35 35 + #include <linux/sched.h> 36 36 + #include <linux/delay.h> 37 37 + #include <linux/module.h> 38 38 + #include <linux/export.h> 39 39 + #include <linux/platform_device.h> 40 40 + #include <linux/io.h> 41 41 + #include <linux/bitops.h> 42 42 + #include <linux/mtd/partitions.h> 43 43 + #include <linux/mtd/mtd.h> 44 44 + #include <linux/mtd/nand.h> 45 45 + #include <linux/bch.h> 46 46 + #include <linux/bitrev.h> 47 47 + 48 48 + /* 49 49 + * You'll want to ignore badblocks if you're reading a partition that contains 50 50 + * data written by the TrueFFS library (i.e., by PalmOS, Windows, etc), since 51 51 + * it does not use mtd nand's method for marking bad blocks (using oob area). 52 52 + * This will also skip the check of the "page written" flag. 53 53 + */ 54 54 + static bool ignore_badblocks; 55 55 + module_param(ignore_badblocks, bool, 0); 56 56 + MODULE_PARM_DESC(ignore_badblocks, "no badblock checking performed"); 57 57 + 58 58 + struct docg4_priv { 59 59 + struct mtd_info *mtd; 60 60 + struct device *dev; 61 61 + void __iomem *virtadr; 62 62 + int status; 63 63 + struct { 64 64 + unsigned int command; 65 65 + int column; 66 66 + int page; 67 67 + } last_command; 68 68 + uint8_t oob_buf[16]; 69 69 + uint8_t ecc_buf[7]; 70 70 + int oob_page; 71 71 + struct bch_control *bch; 72 72 + }; 73 73 + 74 74 + /* 75 75 + * Defines prefixed with DOCG4 are unique to the diskonchip G4. All others are 76 76 + * shared with other diskonchip devices (P3, G3 at least). 77 77 + * 78 78 + * Functions with names prefixed with docg4_ are mtd / nand interface functions 79 79 + * (though they may also be called internally). All others are internal. 80 80 + */ 81 81 + 82 82 + #define DOC_IOSPACE_DATA 0x0800 83 83 + 84 84 + /* register offsets */ 85 85 + #define DOC_CHIPID 0x1000 86 86 + #define DOC_DEVICESELECT 0x100a 87 87 + #define DOC_ASICMODE 0x100c 88 88 + #define DOC_DATAEND 0x101e 89 89 + #define DOC_NOP 0x103e 90 90 + 91 91 + #define DOC_FLASHSEQUENCE 0x1032 92 92 + #define DOC_FLASHCOMMAND 0x1034 93 93 + #define DOC_FLASHADDRESS 0x1036 94 94 + #define DOC_FLASHCONTROL 0x1038 95 95 + #define DOC_ECCCONF0 0x1040 96 96 + #define DOC_ECCCONF1 0x1042 97 97 + #define DOC_HAMMINGPARITY 0x1046 98 98 + #define DOC_BCH_SYNDROM(idx) (0x1048 + idx) 99 99 + 100 100 + #define DOC_ASICMODECONFIRM 0x1072 101 101 + #define DOC_CHIPID_INV 0x1074 102 102 + #define DOC_POWERMODE 0x107c 103 103 + 104 104 + #define DOCG4_MYSTERY_REG 0x1050 105 105 + 106 106 + /* apparently used only to write oob bytes 6 and 7 */ 107 107 + #define DOCG4_OOB_6_7 0x1052 108 108 + 109 109 + /* DOC_FLASHSEQUENCE register commands */ 110 110 + #define DOC_SEQ_RESET 0x00 111 111 + #define DOCG4_SEQ_PAGE_READ 0x03 112 112 + #define DOCG4_SEQ_FLUSH 0x29 113 113 + #define DOCG4_SEQ_PAGEWRITE 0x16 114 114 + #define DOCG4_SEQ_PAGEPROG 0x1e 115 115 + #define DOCG4_SEQ_BLOCKERASE 0x24 116 116 + 117 117 + /* DOC_FLASHCOMMAND register commands */ 118 118 + #define DOCG4_CMD_PAGE_READ 0x00 119 119 + #define DOC_CMD_ERASECYCLE2 0xd0 120 120 + #define DOCG4_CMD_FLUSH 0x70 121 121 + #define DOCG4_CMD_READ2 0x30 122 122 + #define DOC_CMD_PROG_BLOCK_ADDR 0x60 123 123 + #define DOCG4_CMD_PAGEWRITE 0x80 124 124 + #define DOC_CMD_PROG_CYCLE2 0x10 125 125 + #define DOC_CMD_RESET 0xff 126 126 + 127 127 + /* DOC_POWERMODE register bits */ 128 128 + #define DOC_POWERDOWN_READY 0x80 129 129 + 130 130 + /* DOC_FLASHCONTROL register bits */ 131 131 + #define DOC_CTRL_CE 0x10 132 132 + #define DOC_CTRL_UNKNOWN 0x40 133 133 + #define DOC_CTRL_FLASHREADY 0x01 134 134 + 135 135 + /* DOC_ECCCONF0 register bits */ 136 136 + #define DOC_ECCCONF0_READ_MODE 0x8000 137 137 + #define DOC_ECCCONF0_UNKNOWN 0x2000 138 138 + #define DOC_ECCCONF0_ECC_ENABLE 0x1000 139 139 + #define DOC_ECCCONF0_DATA_BYTES_MASK 0x07ff 140 140 + 141 141 + /* DOC_ECCCONF1 register bits */ 142 142 + #define DOC_ECCCONF1_BCH_SYNDROM_ERR 0x80 143 143 + #define DOC_ECCCONF1_ECC_ENABLE 0x07 144 144 + #define DOC_ECCCONF1_PAGE_IS_WRITTEN 0x20 145 145 + 146 146 + /* DOC_ASICMODE register bits */ 147 147 + #define DOC_ASICMODE_RESET 0x00 148 148 + #define DOC_ASICMODE_NORMAL 0x01 149 149 + #define DOC_ASICMODE_POWERDOWN 0x02 150 150 + #define DOC_ASICMODE_MDWREN 0x04 151 151 + #define DOC_ASICMODE_BDETCT_RESET 0x08 152 152 + #define DOC_ASICMODE_RSTIN_RESET 0x10 153 153 + #define DOC_ASICMODE_RAM_WE 0x20 154 154 + 155 155 + /* good status values read after read/write/erase operations */ 156 156 + #define DOCG4_PROGSTATUS_GOOD 0x51 157 157 + #define DOCG4_PROGSTATUS_GOOD_2 0xe0 158 158 + 159 159 + /* 160 160 + * On read operations (page and oob-only), the first byte read from I/O reg is a 161 161 + * status. On error, it reads 0x73; otherwise, it reads either 0x71 (first read 162 162 + * after reset only) or 0x51, so bit 1 is presumed to be an error indicator. 163 163 + */ 164 164 + #define DOCG4_READ_ERROR 0x02 /* bit 1 indicates read error */ 165 165 + 166 166 + /* anatomy of the device */ 167 167 + #define DOCG4_CHIP_SIZE 0x8000000 168 168 + #define DOCG4_PAGE_SIZE 0x200 169 169 + #define DOCG4_PAGES_PER_BLOCK 0x200 170 170 + #define DOCG4_BLOCK_SIZE (DOCG4_PAGES_PER_BLOCK * DOCG4_PAGE_SIZE) 171 171 + #define DOCG4_NUMBLOCKS (DOCG4_CHIP_SIZE / DOCG4_BLOCK_SIZE) 172 172 + #define DOCG4_OOB_SIZE 0x10 173 173 + #define DOCG4_CHIP_SHIFT 27 /* log_2(DOCG4_CHIP_SIZE) */ 174 174 + #define DOCG4_PAGE_SHIFT 9 /* log_2(DOCG4_PAGE_SIZE) */ 175 175 + #define DOCG4_ERASE_SHIFT 18 /* log_2(DOCG4_BLOCK_SIZE) */ 176 176 + 177 177 + /* all but the last byte is included in ecc calculation */ 178 178 + #define DOCG4_BCH_SIZE (DOCG4_PAGE_SIZE + DOCG4_OOB_SIZE - 1) 179 179 + 180 180 + #define DOCG4_USERDATA_LEN 520 /* 512 byte page plus 8 oob avail to user */ 181 181 + 182 182 + /* expected values from the ID registers */ 183 183 + #define DOCG4_IDREG1_VALUE 0x0400 184 184 + #define DOCG4_IDREG2_VALUE 0xfbff 185 185 + 186 186 + /* primitive polynomial used to build the Galois field used by hw ecc gen */ 187 187 + #define DOCG4_PRIMITIVE_POLY 0x4443 188 188 + 189 189 + #define DOCG4_M 14 /* Galois field is of order 2^14 */ 190 190 + #define DOCG4_T 4 /* BCH alg corrects up to 4 bit errors */ 191 191 + 192 192 + #define DOCG4_FACTORY_BBT_PAGE 16 /* page where read-only factory bbt lives */ 193 193 + 194 194 + /* 195 195 + * Oob bytes 0 - 6 are available to the user. 196 196 + * Byte 7 is hamming ecc for first 7 bytes. Bytes 8 - 14 are hw-generated ecc. 197 197 + * Byte 15 (the last) is used by the driver as a "page written" flag. 198 198 + */ 199 199 + static struct nand_ecclayout docg4_oobinfo = { 200 200 + .eccbytes = 9, 201 201 + .eccpos = {7, 8, 9, 10, 11, 12, 13, 14, 15}, 202 202 + .oobavail = 7, 203 203 + .oobfree = { {0, 7} } 204 204 + }; 205 205 + 206 206 + /* 207 207 + * The device has a nop register which M-Sys claims is for the purpose of 208 208 + * inserting precise delays. But beware; at least some operations fail if the 209 209 + * nop writes are replaced with a generic delay! 210 210 + */ 211 211 + static inline void write_nop(void __iomem *docptr) 212 212 + { 213 213 + writew(0, docptr + DOC_NOP); 214 214 + } 215 215 + 216 216 + static void docg4_read_buf(struct mtd_info *mtd, uint8_t *buf, int len) 217 217 + { 218 218 + int i; 219 219 + struct nand_chip *nand = mtd->priv; 220 220 + uint16_t *p = (uint16_t *) buf; 221 221 + len >>= 1; 222 222 + 223 223 + for (i = 0; i < len; i++) 224 224 + p[i] = readw(nand->IO_ADDR_R); 225 225 + } 226 226 + 227 227 + static void docg4_write_buf16(struct mtd_info *mtd, const uint8_t *buf, int len) 228 228 + { 229 229 + int i; 230 230 + struct nand_chip *nand = mtd->priv; 231 231 + uint16_t *p = (uint16_t *) buf; 232 232 + len >>= 1; 233 233 + 234 234 + for (i = 0; i < len; i++) 235 235 + writew(p[i], nand->IO_ADDR_W); 236 236 + } 237 237 + 238 238 + static int poll_status(struct docg4_priv *doc) 239 239 + { 240 240 + /* 241 241 + * Busy-wait for the FLASHREADY bit to be set in the FLASHCONTROL 242 242 + * register. Operations known to take a long time (e.g., block erase) 243 243 + * should sleep for a while before calling this. 244 244 + */ 245 245 + 246 246 + uint16_t flash_status; 247 247 + unsigned int timeo; 248 248 + void __iomem *docptr = doc->virtadr; 249 249 + 250 250 + dev_dbg(doc->dev, "%s...\n", __func__); 251 251 + 252 252 + /* hardware quirk requires reading twice initially */ 253 253 + flash_status = readw(docptr + DOC_FLASHCONTROL); 254 254 + 255 255 + timeo = 1000; 256 256 + do { 257 257 + cpu_relax(); 258 258 + flash_status = readb(docptr + DOC_FLASHCONTROL); 259 259 + } while (!(flash_status & DOC_CTRL_FLASHREADY) && --timeo); 260 260 + 261 261 + 262 262 + if (!timeo) { 263 263 + dev_err(doc->dev, "%s: timed out!\n", __func__); 264 264 + return NAND_STATUS_FAIL; 265 265 + } 266 266 + 267 267 + if (unlikely(timeo < 50)) 268 268 + dev_warn(doc->dev, "%s: nearly timed out; %d remaining\n", 269 269 + __func__, timeo); 270 270 + 271 271 + return 0; 272 272 + } 273 273 + 274 274 + 275 275 + static int docg4_wait(struct mtd_info *mtd, struct nand_chip *nand) 276 276 + { 277 277 + 278 278 + struct docg4_priv *doc = nand->priv; 279 279 + int status = NAND_STATUS_WP; /* inverse logic?? */ 280 280 + dev_dbg(doc->dev, "%s...\n", __func__); 281 281 + 282 282 + /* report any previously unreported error */ 283 283 + if (doc->status) { 284 284 + status |= doc->status; 285 285 + doc->status = 0; 286 286 + return status; 287 287 + } 288 288 + 289 289 + status |= poll_status(doc); 290 290 + return status; 291 291 + } 292 292 + 293 293 + static void docg4_select_chip(struct mtd_info *mtd, int chip) 294 294 + { 295 295 + /* 296 296 + * Select among multiple cascaded chips ("floors"). Multiple floors are 297 297 + * not yet supported, so the only valid non-negative value is 0. 298 298 + */ 299 299 + struct nand_chip *nand = mtd->priv; 300 300 + struct docg4_priv *doc = nand->priv; 301 301 + void __iomem *docptr = doc->virtadr; 302 302 + 303 303 + dev_dbg(doc->dev, "%s: chip %d\n", __func__, chip); 304 304 + 305 305 + if (chip < 0) 306 306 + return; /* deselected */ 307 307 + 308 308 + if (chip > 0) 309 309 + dev_warn(doc->dev, "multiple floors currently unsupported\n"); 310 310 + 311 311 + writew(0, docptr + DOC_DEVICESELECT); 312 312 + } 313 313 + 314 314 + static void reset(struct mtd_info *mtd) 315 315 + { 316 316 + /* full device reset */ 317 317 + 318 318 + struct nand_chip *nand = mtd->priv; 319 319 + struct docg4_priv *doc = nand->priv; 320 320 + void __iomem *docptr = doc->virtadr; 321 321 + 322 322 + writew(DOC_ASICMODE_RESET | DOC_ASICMODE_MDWREN, 323 323 + docptr + DOC_ASICMODE); 324 324 + writew(~(DOC_ASICMODE_RESET | DOC_ASICMODE_MDWREN), 325 325 + docptr + DOC_ASICMODECONFIRM); 326 326 + write_nop(docptr); 327 327 + 328 328 + writew(DOC_ASICMODE_NORMAL | DOC_ASICMODE_MDWREN, 329 329 + docptr + DOC_ASICMODE); 330 330 + writew(~(DOC_ASICMODE_NORMAL | DOC_ASICMODE_MDWREN), 331 331 + docptr + DOC_ASICMODECONFIRM); 332 332 + 333 333 + writew(DOC_ECCCONF1_ECC_ENABLE, docptr + DOC_ECCCONF1); 334 334 + 335 335 + poll_status(doc); 336 336 + } 337 337 + 338 338 + static void read_hw_ecc(void __iomem *docptr, uint8_t *ecc_buf) 339 339 + { 340 340 + /* read the 7 hw-generated ecc bytes */ 341 341 + 342 342 + int i; 343 343 + for (i = 0; i < 7; i++) { /* hw quirk; read twice */ 344 344 + ecc_buf[i] = readb(docptr + DOC_BCH_SYNDROM(i)); 345 345 + ecc_buf[i] = readb(docptr + DOC_BCH_SYNDROM(i)); 346 346 + } 347 347 + } 348 348 + 349 349 + static int correct_data(struct mtd_info *mtd, uint8_t *buf, int page) 350 350 + { 351 351 + /* 352 352 + * Called after a page read when hardware reports bitflips. 353 353 + * Up to four bitflips can be corrected. 354 354 + */ 355 355 + 356 356 + struct nand_chip *nand = mtd->priv; 357 357 + struct docg4_priv *doc = nand->priv; 358 358 + void __iomem *docptr = doc->virtadr; 359 359 + int i, numerrs, errpos[4]; 360 360 + const uint8_t blank_read_hwecc[8] = { 361 361 + 0xcf, 0x72, 0xfc, 0x1b, 0xa9, 0xc7, 0xb9, 0 }; 362 362 + 363 363 + read_hw_ecc(docptr, doc->ecc_buf); /* read 7 hw-generated ecc bytes */ 364 364 + 365 365 + /* check if read error is due to a blank page */ 366 366 + if (!memcmp(doc->ecc_buf, blank_read_hwecc, 7)) 367 367 + return 0; /* yes */ 368 368 + 369 369 + /* skip additional check of "written flag" if ignore_badblocks */ 370 370 + if (ignore_badblocks == false) { 371 371 + 372 372 + /* 373 373 + * If the hw ecc bytes are not those of a blank page, there's 374 374 + * still a chance that the page is blank, but was read with 375 375 + * errors. Check the "written flag" in last oob byte, which 376 376 + * is set to zero when a page is written. If more than half 377 377 + * the bits are set, assume a blank page. Unfortunately, the 378 378 + * bit flips(s) are not reported in stats. 379 379 + */ 380 380 + 381 381 + if (doc->oob_buf[15]) { 382 382 + int bit, numsetbits = 0; 383 383 + unsigned long written_flag = doc->oob_buf[15]; 384 384 + for_each_set_bit(bit, &written_flag, 8) 385 385 + numsetbits++; 386 386 + if (numsetbits > 4) { /* assume blank */ 387 387 + dev_warn(doc->dev, 388 388 + "error(s) in blank page " 389 389 + "at offset %08x\n", 390 390 + page * DOCG4_PAGE_SIZE); 391 391 + return 0; 392 392 + } 393 393 + } 394 394 + } 395 395 + 396 396 + /* 397 397 + * The hardware ecc unit produces oob_ecc ^ calc_ecc. The kernel's bch 398 398 + * algorithm is used to decode this. However the hw operates on page 399 399 + * data in a bit order that is the reverse of that of the bch alg, 400 400 + * requiring that the bits be reversed on the result. Thanks to Ivan 401 401 + * Djelic for his analysis! 402 402 + */ 403 403 + for (i = 0; i < 7; i++) 404 404 + doc->ecc_buf[i] = bitrev8(doc->ecc_buf[i]); 405 405 + 406 406 + numerrs = decode_bch(doc->bch, NULL, DOCG4_USERDATA_LEN, NULL, 407 407 + doc->ecc_buf, NULL, errpos); 408 408 + 409 409 + if (numerrs == -EBADMSG) { 410 410 + dev_warn(doc->dev, "uncorrectable errors at offset %08x\n", 411 411 + page * DOCG4_PAGE_SIZE); 412 412 + return -EBADMSG; 413 413 + } 414 414 + 415 415 + BUG_ON(numerrs < 0); /* -EINVAL, or anything other than -EBADMSG */ 416 416 + 417 417 + /* undo last step in BCH alg (modulo mirroring not needed) */ 418 418 + for (i = 0; i < numerrs; i++) 419 419 + errpos[i] = (errpos[i] & ~7)|(7-(errpos[i] & 7)); 420 420 + 421 421 + /* fix the errors */ 422 422 + for (i = 0; i < numerrs; i++) { 423 423 + 424 424 + /* ignore if error within oob ecc bytes */ 425 425 + if (errpos[i] > DOCG4_USERDATA_LEN * 8) 426 426 + continue; 427 427 + 428 428 + /* if error within oob area preceeding ecc bytes... */ 429 429 + if (errpos[i] > DOCG4_PAGE_SIZE * 8) 430 430 + change_bit(errpos[i] - DOCG4_PAGE_SIZE * 8, 431 431 + (unsigned long *)doc->oob_buf); 432 432 + 433 433 + else /* error in page data */ 434 434 + change_bit(errpos[i], (unsigned long *)buf); 435 435 + } 436 436 + 437 437 + dev_notice(doc->dev, "%d error(s) corrected at offset %08x\n", 438 438 + numerrs, page * DOCG4_PAGE_SIZE); 439 439 + 440 440 + return numerrs; 441 441 + } 442 442 + 443 443 + static uint8_t docg4_read_byte(struct mtd_info *mtd) 444 444 + { 445 445 + struct nand_chip *nand = mtd->priv; 446 446 + struct docg4_priv *doc = nand->priv; 447 447 + 448 448 + dev_dbg(doc->dev, "%s\n", __func__); 449 449 + 450 450 + if (doc->last_command.command == NAND_CMD_STATUS) { 451 451 + int status; 452 452 + 453 453 + /* 454 454 + * Previous nand command was status request, so nand 455 455 + * infrastructure code expects to read the status here. If an 456 456 + * error occurred in a previous operation, report it. 457 457 + */ 458 458 + doc->last_command.command = 0; 459 459 + 460 460 + if (doc->status) { 461 461 + status = doc->status; 462 462 + doc->status = 0; 463 463 + } 464 464 + 465 465 + /* why is NAND_STATUS_WP inverse logic?? */ 466 466 + else 467 467 + status = NAND_STATUS_WP | NAND_STATUS_READY; 468 468 + 469 469 + return status; 470 470 + } 471 471 + 472 472 + dev_warn(doc->dev, "unexpectd call to read_byte()\n"); 473 473 + 474 474 + return 0; 475 475 + } 476 476 + 477 477 + static void write_addr(struct docg4_priv *doc, uint32_t docg4_addr) 478 478 + { 479 479 + /* write the four address bytes packed in docg4_addr to the device */ 480 480 + 481 481 + void __iomem *docptr = doc->virtadr; 482 482 + writeb(docg4_addr & 0xff, docptr + DOC_FLASHADDRESS); 483 483 + docg4_addr >>= 8; 484 484 + writeb(docg4_addr & 0xff, docptr + DOC_FLASHADDRESS); 485 485 + docg4_addr >>= 8; 486 486 + writeb(docg4_addr & 0xff, docptr + DOC_FLASHADDRESS); 487 487 + docg4_addr >>= 8; 488 488 + writeb(docg4_addr & 0xff, docptr + DOC_FLASHADDRESS); 489 489 + } 490 490 + 491 491 + static int read_progstatus(struct docg4_priv *doc) 492 492 + { 493 493 + /* 494 494 + * This apparently checks the status of programming. Done after an 495 495 + * erasure, and after page data is written. On error, the status is 496 496 + * saved, to be later retrieved by the nand infrastructure code. 497 497 + */ 498 498 + void __iomem *docptr = doc->virtadr; 499 499 + 500 500 + /* status is read from the I/O reg */ 501 501 + uint16_t status1 = readw(docptr + DOC_IOSPACE_DATA); 502 502 + uint16_t status2 = readw(docptr + DOC_IOSPACE_DATA); 503 503 + uint16_t status3 = readw(docptr + DOCG4_MYSTERY_REG); 504 504 + 505 505 + dev_dbg(doc->dev, "docg4: %s: %02x %02x %02x\n", 506 506 + __func__, status1, status2, status3); 507 507 + 508 508 + if (status1 != DOCG4_PROGSTATUS_GOOD 509 509 + || status2 != DOCG4_PROGSTATUS_GOOD_2 510 510 + || status3 != DOCG4_PROGSTATUS_GOOD_2) { 511 511 + doc->status = NAND_STATUS_FAIL; 512 512 + dev_warn(doc->dev, "read_progstatus failed: " 513 513 + "%02x, %02x, %02x\n", status1, status2, status3); 514 514 + return -EIO; 515 515 + } 516 516 + return 0; 517 517 + } 518 518 + 519 519 + static int pageprog(struct mtd_info *mtd) 520 520 + { 521 521 + /* 522 522 + * Final step in writing a page. Writes the contents of its 523 523 + * internal buffer out to the flash array, or some such. 524 524 + */ 525 525 + 526 526 + struct nand_chip *nand = mtd->priv; 527 527 + struct docg4_priv *doc = nand->priv; 528 528 + void __iomem *docptr = doc->virtadr; 529 529 + int retval = 0; 530 530 + 531 531 + dev_dbg(doc->dev, "docg4: %s\n", __func__); 532 532 + 533 533 + writew(DOCG4_SEQ_PAGEPROG, docptr + DOC_FLASHSEQUENCE); 534 534 + writew(DOC_CMD_PROG_CYCLE2, docptr + DOC_FLASHCOMMAND); 535 535 + write_nop(docptr); 536 536 + write_nop(docptr); 537 537 + 538 538 + /* Just busy-wait; usleep_range() slows things down noticeably. */ 539 539 + poll_status(doc); 540 540 + 541 541 + writew(DOCG4_SEQ_FLUSH, docptr + DOC_FLASHSEQUENCE); 542 542 + writew(DOCG4_CMD_FLUSH, docptr + DOC_FLASHCOMMAND); 543 543 + writew(DOC_ECCCONF0_READ_MODE | 4, docptr + DOC_ECCCONF0); 544 544 + write_nop(docptr); 545 545 + write_nop(docptr); 546 546 + write_nop(docptr); 547 547 + write_nop(docptr); 548 548 + write_nop(docptr); 549 549 + 550 550 + retval = read_progstatus(doc); 551 551 + writew(0, docptr + DOC_DATAEND); 552 552 + write_nop(docptr); 553 553 + poll_status(doc); 554 554 + write_nop(docptr); 555 555 + 556 556 + return retval; 557 557 + } 558 558 + 559 559 + static void sequence_reset(struct mtd_info *mtd) 560 560 + { 561 561 + /* common starting sequence for all operations */ 562 562 + 563 563 + struct nand_chip *nand = mtd->priv; 564 564 + struct docg4_priv *doc = nand->priv; 565 565 + void __iomem *docptr = doc->virtadr; 566 566 + 567 567 + writew(DOC_CTRL_UNKNOWN | DOC_CTRL_CE, docptr + DOC_FLASHCONTROL); 568 568 + writew(DOC_SEQ_RESET, docptr + DOC_FLASHSEQUENCE); 569 569 + writew(DOC_CMD_RESET, docptr + DOC_FLASHCOMMAND); 570 570 + write_nop(docptr); 571 571 + write_nop(docptr); 572 572 + poll_status(doc); 573 573 + write_nop(docptr); 574 574 + } 575 575 + 576 576 + static void read_page_prologue(struct mtd_info *mtd, uint32_t docg4_addr) 577 577 + { 578 578 + /* first step in reading a page */ 579 579 + 580 580 + struct nand_chip *nand = mtd->priv; 581 581 + struct docg4_priv *doc = nand->priv; 582 582 + void __iomem *docptr = doc->virtadr; 583 583 + 584 584 + dev_dbg(doc->dev, 585 585 + "docg4: %s: g4 page %08x\n", __func__, docg4_addr); 586 586 + 587 587 + sequence_reset(mtd); 588 588 + 589 589 + writew(DOCG4_SEQ_PAGE_READ, docptr + DOC_FLASHSEQUENCE); 590 590 + writew(DOCG4_CMD_PAGE_READ, docptr + DOC_FLASHCOMMAND); 591 591 + write_nop(docptr); 592 592 + 593 593 + write_addr(doc, docg4_addr); 594 594 + 595 595 + write_nop(docptr); 596 596 + writew(DOCG4_CMD_READ2, docptr + DOC_FLASHCOMMAND); 597 597 + write_nop(docptr); 598 598 + write_nop(docptr); 599 599 + 600 600 + poll_status(doc); 601 601 + } 602 602 + 603 603 + static void write_page_prologue(struct mtd_info *mtd, uint32_t docg4_addr) 604 604 + { 605 605 + /* first step in writing a page */ 606 606 + 607 607 + struct nand_chip *nand = mtd->priv; 608 608 + struct docg4_priv *doc = nand->priv; 609 609 + void __iomem *docptr = doc->virtadr; 610 610 + 611 611 + dev_dbg(doc->dev, 612 612 + "docg4: %s: g4 addr: %x\n", __func__, docg4_addr); 613 613 + sequence_reset(mtd); 614 614 + writew(DOCG4_SEQ_PAGEWRITE, docptr + DOC_FLASHSEQUENCE); 615 615 + writew(DOCG4_CMD_PAGEWRITE, docptr + DOC_FLASHCOMMAND); 616 616 + write_nop(docptr); 617 617 + write_addr(doc, docg4_addr); 618 618 + write_nop(docptr); 619 619 + write_nop(docptr); 620 620 + poll_status(doc); 621 621 + } 622 622 + 623 623 + static uint32_t mtd_to_docg4_address(int page, int column) 624 624 + { 625 625 + /* 626 626 + * Convert mtd address to format used by the device, 32 bit packed. 627 627 + * 628 628 + * Some notes on G4 addressing... The M-Sys documentation on this device 629 629 + * claims that pages are 2K in length, and indeed, the format of the 630 630 + * address used by the device reflects that. But within each page are 631 631 + * four 512 byte "sub-pages", each with its own oob data that is 632 632 + * read/written immediately after the 512 bytes of page data. This oob 633 633 + * data contains the ecc bytes for the preceeding 512 bytes. 634 634 + * 635 635 + * Rather than tell the mtd nand infrastructure that page size is 2k, 636 636 + * with four sub-pages each, we engage in a little subterfuge and tell 637 637 + * the infrastructure code that pages are 512 bytes in size. This is 638 638 + * done because during the course of reverse-engineering the device, I 639 639 + * never observed an instance where an entire 2K "page" was read or 640 640 + * written as a unit. Each "sub-page" is always addressed individually, 641 641 + * its data read/written, and ecc handled before the next "sub-page" is 642 642 + * addressed. 643 643 + * 644 644 + * This requires us to convert addresses passed by the mtd nand 645 645 + * infrastructure code to those used by the device. 646 646 + * 647 647 + * The address that is written to the device consists of four bytes: the 648 648 + * first two are the 2k page number, and the second is the index into 649 649 + * the page. The index is in terms of 16-bit half-words and includes 650 650 + * the preceeding oob data, so e.g., the index into the second 651 651 + * "sub-page" is 0x108, and the full device address of the start of mtd 652 652 + * page 0x201 is 0x00800108. 653 653 + */ 654 654 + int g4_page = page / 4; /* device's 2K page */ 655 655 + int g4_index = (page % 4) * 0x108 + column/2; /* offset into page */ 656 656 + return (g4_page << 16) | g4_index; /* pack */ 657 657 + } 658 658 + 659 659 + static void docg4_command(struct mtd_info *mtd, unsigned command, int column, 660 660 + int page_addr) 661 661 + { 662 662 + /* handle standard nand commands */ 663 663 + 664 664 + struct nand_chip *nand = mtd->priv; 665 665 + struct docg4_priv *doc = nand->priv; 666 666 + uint32_t g4_addr = mtd_to_docg4_address(page_addr, column); 667 667 + 668 668 + dev_dbg(doc->dev, "%s %x, page_addr=%x, column=%x\n", 669 669 + __func__, command, page_addr, column); 670 670 + 671 671 + /* 672 672 + * Save the command and its arguments. This enables emulation of 673 673 + * standard flash devices, and also some optimizations. 674 674 + */ 675 675 + doc->last_command.command = command; 676 676 + doc->last_command.column = column; 677 677 + doc->last_command.page = page_addr; 678 678 + 679 679 + switch (command) { 680 680 + 681 681 + case NAND_CMD_RESET: 682 682 + reset(mtd); 683 683 + break; 684 684 + 685 685 + case NAND_CMD_READ0: 686 686 + read_page_prologue(mtd, g4_addr); 687 687 + break; 688 688 + 689 689 + case NAND_CMD_STATUS: 690 690 + /* next call to read_byte() will expect a status */ 691 691 + break; 692 692 + 693 693 + case NAND_CMD_SEQIN: 694 694 + write_page_prologue(mtd, g4_addr); 695 695 + 696 696 + /* hack for deferred write of oob bytes */ 697 697 + if (doc->oob_page == page_addr) 698 698 + memcpy(nand->oob_poi, doc->oob_buf, 16); 699 699 + break; 700 700 + 701 701 + case NAND_CMD_PAGEPROG: 702 702 + pageprog(mtd); 703 703 + break; 704 704 + 705 705 + /* we don't expect these, based on review of nand_base.c */ 706 706 + case NAND_CMD_READOOB: 707 707 + case NAND_CMD_READID: 708 708 + case NAND_CMD_ERASE1: 709 709 + case NAND_CMD_ERASE2: 710 710 + dev_warn(doc->dev, "docg4_command: " 711 711 + "unexpected nand command 0x%x\n", command); 712 712 + break; 713 713 + 714 714 + } 715 715 + } 716 716 + 717 717 + static int read_page(struct mtd_info *mtd, struct nand_chip *nand, 718 718 + uint8_t *buf, int page, bool use_ecc) 719 719 + { 720 720 + struct docg4_priv *doc = nand->priv; 721 721 + void __iomem *docptr = doc->virtadr; 722 722 + uint16_t status, edc_err, *buf16; 723 723 + 724 724 + dev_dbg(doc->dev, "%s: page %08x\n", __func__, page); 725 725 + 726 726 + writew(DOC_ECCCONF0_READ_MODE | 727 727 + DOC_ECCCONF0_ECC_ENABLE | 728 728 + DOC_ECCCONF0_UNKNOWN | 729 729 + DOCG4_BCH_SIZE, 730 730 + docptr + DOC_ECCCONF0); 731 731 + write_nop(docptr); 732 732 + write_nop(docptr); 733 733 + write_nop(docptr); 734 734 + write_nop(docptr); 735 735 + write_nop(docptr); 736 736 + 737 737 + /* the 1st byte from the I/O reg is a status; the rest is page data */ 738 738 + status = readw(docptr + DOC_IOSPACE_DATA); 739 739 + if (status & DOCG4_READ_ERROR) { 740 740 + dev_err(doc->dev, 741 741 + "docg4_read_page: bad status: 0x%02x\n", status); 742 742 + writew(0, docptr + DOC_DATAEND); 743 743 + return -EIO; 744 744 + } 745 745 + 746 746 + dev_dbg(doc->dev, "%s: status = 0x%x\n", __func__, status); 747 747 + 748 748 + docg4_read_buf(mtd, buf, DOCG4_PAGE_SIZE); /* read the page data */ 749 749 + 750 750 + /* 751 751 + * Diskonchips read oob immediately after a page read. Mtd 752 752 + * infrastructure issues a separate command for reading oob after the 753 753 + * page is read. So we save the oob bytes in a local buffer and just 754 754 + * copy it if the next command reads oob from the same page. 755 755 + */ 756 756 + 757 757 + /* first 14 oob bytes read from I/O reg */ 758 758 + docg4_read_buf(mtd, doc->oob_buf, 14); 759 759 + 760 760 + /* last 2 read from another reg */ 761 761 + buf16 = (uint16_t *)(doc->oob_buf + 14); 762 762 + *buf16 = readw(docptr + DOCG4_MYSTERY_REG); 763 763 + 764 764 + write_nop(docptr); 765 765 + 766 766 + if (likely(use_ecc == true)) { 767 767 + 768 768 + /* read the register that tells us if bitflip(s) detected */ 769 769 + edc_err = readw(docptr + DOC_ECCCONF1); 770 770 + edc_err = readw(docptr + DOC_ECCCONF1); 771 771 + dev_dbg(doc->dev, "%s: edc_err = 0x%02x\n", __func__, edc_err); 772 772 + 773 773 + /* If bitflips are reported, attempt to correct with ecc */ 774 774 + if (edc_err & DOC_ECCCONF1_BCH_SYNDROM_ERR) { 775 775 + int bits_corrected = correct_data(mtd, buf, page); 776 776 + if (bits_corrected == -EBADMSG) 777 777 + mtd->ecc_stats.failed++; 778 778 + else 779 779 + mtd->ecc_stats.corrected += bits_corrected; 780 780 + } 781 781 + } 782 782 + 783 783 + writew(0, docptr + DOC_DATAEND); 784 784 + return 0; 785 785 + } 786 786 + 787 787 + 788 788 + static int docg4_read_page_raw(struct mtd_info *mtd, struct nand_chip *nand, 789 789 + uint8_t *buf, int page) 790 790 + { 791 791 + return read_page(mtd, nand, buf, page, false); 792 792 + } 793 793 + 794 794 + static int docg4_read_page(struct mtd_info *mtd, struct nand_chip *nand, 795 795 + uint8_t *buf, int page) 796 796 + { 797 797 + return read_page(mtd, nand, buf, page, true); 798 798 + } 799 799 + 800 800 + static int docg4_read_oob(struct mtd_info *mtd, struct nand_chip *nand, 801 801 + int page, int sndcmd) 802 802 + { 803 803 + struct docg4_priv *doc = nand->priv; 804 804 + void __iomem *docptr = doc->virtadr; 805 805 + uint16_t status; 806 806 + 807 807 + dev_dbg(doc->dev, "%s: page %x\n", __func__, page); 808 808 + 809 809 + /* 810 810 + * Oob bytes are read as part of a normal page read. If the previous 811 811 + * nand command was a read of the page whose oob is now being read, just 812 812 + * copy the oob bytes that we saved in a local buffer and avoid a 813 813 + * separate oob read. 814 814 + */ 815 815 + if (doc->last_command.command == NAND_CMD_READ0 && 816 816 + doc->last_command.page == page) { 817 817 + memcpy(nand->oob_poi, doc->oob_buf, 16); 818 818 + return 0; 819 819 + } 820 820 + 821 821 + /* 822 822 + * Separate read of oob data only. 823 823 + */ 824 824 + docg4_command(mtd, NAND_CMD_READ0, nand->ecc.size, page); 825 825 + 826 826 + writew(DOC_ECCCONF0_READ_MODE | DOCG4_OOB_SIZE, docptr + DOC_ECCCONF0); 827 827 + write_nop(docptr); 828 828 + write_nop(docptr); 829 829 + write_nop(docptr); 830 830 + write_nop(docptr); 831 831 + write_nop(docptr); 832 832 + 833 833 + /* the 1st byte from the I/O reg is a status; the rest is oob data */ 834 834 + status = readw(docptr + DOC_IOSPACE_DATA); 835 835 + if (status & DOCG4_READ_ERROR) { 836 836 + dev_warn(doc->dev, 837 837 + "docg4_read_oob failed: status = 0x%02x\n", status); 838 838 + return -EIO; 839 839 + } 840 840 + 841 841 + dev_dbg(doc->dev, "%s: status = 0x%x\n", __func__, status); 842 842 + 843 843 + docg4_read_buf(mtd, nand->oob_poi, 16); 844 844 + 845 845 + write_nop(docptr); 846 846 + write_nop(docptr); 847 847 + write_nop(docptr); 848 848 + writew(0, docptr + DOC_DATAEND); 849 849 + write_nop(docptr); 850 850 + 851 851 + return 0; 852 852 + } 853 853 + 854 854 + static void docg4_erase_block(struct mtd_info *mtd, int page) 855 855 + { 856 856 + struct nand_chip *nand = mtd->priv; 857 857 + struct docg4_priv *doc = nand->priv; 858 858 + void __iomem *docptr = doc->virtadr; 859 859 + uint16_t g4_page; 860 860 + 861 861 + dev_dbg(doc->dev, "%s: page %04x\n", __func__, page); 862 862 + 863 863 + sequence_reset(mtd); 864 864 + 865 865 + writew(DOCG4_SEQ_BLOCKERASE, docptr + DOC_FLASHSEQUENCE); 866 866 + writew(DOC_CMD_PROG_BLOCK_ADDR, docptr + DOC_FLASHCOMMAND); 867 867 + write_nop(docptr); 868 868 + 869 869 + /* only 2 bytes of address are written to specify erase block */ 870 870 + g4_page = (uint16_t)(page / 4); /* to g4's 2k page addressing */ 871 871 + writeb(g4_page & 0xff, docptr + DOC_FLASHADDRESS); 872 872 + g4_page >>= 8; 873 873 + writeb(g4_page & 0xff, docptr + DOC_FLASHADDRESS); 874 874 + write_nop(docptr); 875 875 + 876 876 + /* start the erasure */ 877 877 + writew(DOC_CMD_ERASECYCLE2, docptr + DOC_FLASHCOMMAND); 878 878 + write_nop(docptr); 879 879 + write_nop(docptr); 880 880 + 881 881 + usleep_range(500, 1000); /* erasure is long; take a snooze */ 882 882 + poll_status(doc); 883 883 + writew(DOCG4_SEQ_FLUSH, docptr + DOC_FLASHSEQUENCE); 884 884 + writew(DOCG4_CMD_FLUSH, docptr + DOC_FLASHCOMMAND); 885 885 + writew(DOC_ECCCONF0_READ_MODE | 4, docptr + DOC_ECCCONF0); 886 886 + write_nop(docptr); 887 887 + write_nop(docptr); 888 888 + write_nop(docptr); 889 889 + write_nop(docptr); 890 890 + write_nop(docptr); 891 891 + 892 892 + read_progstatus(doc); 893 893 + 894 894 + writew(0, docptr + DOC_DATAEND); 895 895 + write_nop(docptr); 896 896 + poll_status(doc); 897 897 + write_nop(docptr); 898 898 + } 899 899 + 900 900 + static void write_page(struct mtd_info *mtd, struct nand_chip *nand, 901 901 + const uint8_t *buf, bool use_ecc) 902 902 + { 903 903 + struct docg4_priv *doc = nand->priv; 904 904 + void __iomem *docptr = doc->virtadr; 905 905 + uint8_t ecc_buf[8]; 906 906 + 907 907 + dev_dbg(doc->dev, "%s...\n", __func__); 908 908 + 909 909 + writew(DOC_ECCCONF0_ECC_ENABLE | 910 910 + DOC_ECCCONF0_UNKNOWN | 911 911 + DOCG4_BCH_SIZE, 912 912 + docptr + DOC_ECCCONF0); 913 913 + write_nop(docptr); 914 914 + 915 915 + /* write the page data */ 916 916 + docg4_write_buf16(mtd, buf, DOCG4_PAGE_SIZE); 917 917 + 918 918 + /* oob bytes 0 through 5 are written to I/O reg */ 919 919 + docg4_write_buf16(mtd, nand->oob_poi, 6); 920 920 + 921 921 + /* oob byte 6 written to a separate reg */ 922 922 + writew(nand->oob_poi[6], docptr + DOCG4_OOB_6_7); 923 923 + 924 924 + write_nop(docptr); 925 925 + write_nop(docptr); 926 926 + 927 927 + /* write hw-generated ecc bytes to oob */ 928 928 + if (likely(use_ecc == true)) { 929 929 + /* oob byte 7 is hamming code */ 930 930 + uint8_t hamming = readb(docptr + DOC_HAMMINGPARITY); 931 931 + hamming = readb(docptr + DOC_HAMMINGPARITY); /* 2nd read */ 932 932 + writew(hamming, docptr + DOCG4_OOB_6_7); 933 933 + write_nop(docptr); 934 934 + 935 935 + /* read the 7 bch bytes from ecc regs */ 936 936 + read_hw_ecc(docptr, ecc_buf); 937 937 + ecc_buf[7] = 0; /* clear the "page written" flag */ 938 938 + } 939 939 + 940 940 + /* write user-supplied bytes to oob */ 941 941 + else { 942 942 + writew(nand->oob_poi[7], docptr + DOCG4_OOB_6_7); 943 943 + write_nop(docptr); 944 944 + memcpy(ecc_buf, &nand->oob_poi[8], 8); 945 945 + } 946 946 + 947 947 + docg4_write_buf16(mtd, ecc_buf, 8); 948 948 + write_nop(docptr); 949 949 + write_nop(docptr); 950 950 + writew(0, docptr + DOC_DATAEND); 951 951 + write_nop(docptr); 952 952 + } 953 953 + 954 954 + static void docg4_write_page_raw(struct mtd_info *mtd, struct nand_chip *nand, 955 955 + const uint8_t *buf) 956 956 + { 957 957 + return write_page(mtd, nand, buf, false); 958 958 + } 959 959 + 960 960 + static void docg4_write_page(struct mtd_info *mtd, struct nand_chip *nand, 961 961 + const uint8_t *buf) 962 962 + { 963 963 + return write_page(mtd, nand, buf, true); 964 964 + } 965 965 + 966 966 + static int docg4_write_oob(struct mtd_info *mtd, struct nand_chip *nand, 967 967 + int page) 968 968 + { 969 969 + /* 970 970 + * Writing oob-only is not really supported, because MLC nand must write 971 971 + * oob bytes at the same time as page data. Nonetheless, we save the 972 972 + * oob buffer contents here, and then write it along with the page data 973 973 + * if the same page is subsequently written. This allows user space 974 974 + * utilities that write the oob data prior to the page data to work 975 975 + * (e.g., nandwrite). The disdvantage is that, if the intention was to 976 976 + * write oob only, the operation is quietly ignored. Also, oob can get 977 977 + * corrupted if two concurrent processes are running nandwrite. 978 978 + */ 979 979 + 980 980 + /* note that bytes 7..14 are hw generated hamming/ecc and overwritten */ 981 981 + struct docg4_priv *doc = nand->priv; 982 982 + doc->oob_page = page; 983 983 + memcpy(doc->oob_buf, nand->oob_poi, 16); 984 984 + return 0; 985 985 + } 986 986 + 987 987 + static int __init read_factory_bbt(struct mtd_info *mtd) 988 988 + { 989 989 + /* 990 990 + * The device contains a read-only factory bad block table. Read it and 991 991 + * update the memory-based bbt accordingly. 992 992 + */ 993 993 + 994 994 + struct nand_chip *nand = mtd->priv; 995 995 + struct docg4_priv *doc = nand->priv; 996 996 + uint32_t g4_addr = mtd_to_docg4_address(DOCG4_FACTORY_BBT_PAGE, 0); 997 997 + uint8_t *buf; 998 998 + int i, block, status; 999 999 + 1000 1000 + buf = kzalloc(DOCG4_PAGE_SIZE, GFP_KERNEL); 1001 1001 + if (buf == NULL) 1002 1002 + return -ENOMEM; 1003 1003 + 1004 1004 + read_page_prologue(mtd, g4_addr); 1005 1005 + status = docg4_read_page(mtd, nand, buf, DOCG4_FACTORY_BBT_PAGE); 1006 1006 + if (status) 1007 1007 + goto exit; 1008 1008 + 1009 1009 + /* 1010 1010 + * If no memory-based bbt was created, exit. This will happen if module 1011 1011 + * parameter ignore_badblocks is set. Then why even call this function? 1012 1012 + * For an unknown reason, block erase always fails if it's the first 1013 1013 + * operation after device power-up. The above read ensures it never is. 1014 1014 + * Ugly, I know. 1015 1015 + */ 1016 1016 + if (nand->bbt == NULL) /* no memory-based bbt */ 1017 1017 + goto exit; 1018 1018 + 1019 1019 + /* 1020 1020 + * Parse factory bbt and update memory-based bbt. Factory bbt format is 1021 1021 + * simple: one bit per block, block numbers increase left to right (msb 1022 1022 + * to lsb). Bit clear means bad block. 1023 1023 + */ 1024 1024 + for (i = block = 0; block < DOCG4_NUMBLOCKS; block += 8, i++) { 1025 1025 + int bitnum; 1026 1026 + unsigned long bits = ~buf[i]; 1027 1027 + for_each_set_bit(bitnum, &bits, 8) { 1028 1028 + int badblock = block + 7 - bitnum; 1029 1029 + nand->bbt[badblock / 4] |= 1030 1030 + 0x03 << ((badblock % 4) * 2); 1031 1031 + mtd->ecc_stats.badblocks++; 1032 1032 + dev_notice(doc->dev, "factory-marked bad block: %d\n", 1033 1033 + badblock); 1034 1034 + } 1035 1035 + } 1036 1036 + exit: 1037 1037 + kfree(buf); 1038 1038 + return status; 1039 1039 + } 1040 1040 + 1041 1041 + static int docg4_block_markbad(struct mtd_info *mtd, loff_t ofs) 1042 1042 + { 1043 1043 + /* 1044 1044 + * Mark a block as bad. Bad blocks are marked in the oob area of the 1045 1045 + * first page of the block. The default scan_bbt() in the nand 1046 1046 + * infrastructure code works fine for building the memory-based bbt 1047 1047 + * during initialization, as does the nand infrastructure function that 1048 1048 + * checks if a block is bad by reading the bbt. This function replaces 1049 1049 + * the nand default because writes to oob-only are not supported. 1050 1050 + */ 1051 1051 + 1052 1052 + int ret, i; 1053 1053 + uint8_t *buf; 1054 1054 + struct nand_chip *nand = mtd->priv; 1055 1055 + struct docg4_priv *doc = nand->priv; 1056 1056 + struct nand_bbt_descr *bbtd = nand->badblock_pattern; 1057 1057 + int block = (int)(ofs >> nand->bbt_erase_shift); 1058 1058 + int page = (int)(ofs >> nand->page_shift); 1059 1059 + uint32_t g4_addr = mtd_to_docg4_address(page, 0); 1060 1060 + 1061 1061 + dev_dbg(doc->dev, "%s: %08llx\n", __func__, ofs); 1062 1062 + 1063 1063 + if (unlikely(ofs & (DOCG4_BLOCK_SIZE - 1))) 1064 1064 + dev_warn(doc->dev, "%s: ofs %llx not start of block!\n", 1065 1065 + __func__, ofs); 1066 1066 + 1067 1067 + /* allocate blank buffer for page data */ 1068 1068 + buf = kzalloc(DOCG4_PAGE_SIZE, GFP_KERNEL); 1069 1069 + if (buf == NULL) 1070 1070 + return -ENOMEM; 1071 1071 + 1072 1072 + /* update bbt in memory */ 1073 1073 + nand->bbt[block / 4] |= 0x01 << ((block & 0x03) * 2); 1074 1074 + 1075 1075 + /* write bit-wise negation of pattern to oob buffer */ 1076 1076 + memset(nand->oob_poi, 0xff, mtd->oobsize); 1077 1077 + for (i = 0; i < bbtd->len; i++) 1078 1078 + nand->oob_poi[bbtd->offs + i] = ~bbtd->pattern[i]; 1079 1079 + 1080 1080 + /* write first page of block */ 1081 1081 + write_page_prologue(mtd, g4_addr); 1082 1082 + docg4_write_page(mtd, nand, buf); 1083 1083 + ret = pageprog(mtd); 1084 1084 + if (!ret) 1085 1085 + mtd->ecc_stats.badblocks++; 1086 1086 + 1087 1087 + kfree(buf); 1088 1088 + 1089 1089 + return ret; 1090 1090 + } 1091 1091 + 1092 1092 + static int docg4_block_neverbad(struct mtd_info *mtd, loff_t ofs, int getchip) 1093 1093 + { 1094 1094 + /* only called when module_param ignore_badblocks is set */ 1095 1095 + return 0; 1096 1096 + } 1097 1097 + 1098 1098 + static int docg4_suspend(struct platform_device *pdev, pm_message_t state) 1099 1099 + { 1100 1100 + /* 1101 1101 + * Put the device into "deep power-down" mode. Note that CE# must be 1102 1102 + * deasserted for this to take effect. The xscale, e.g., can be 1103 1103 + * configured to float this signal when the processor enters power-down, 1104 1104 + * and a suitable pull-up ensures its deassertion. 1105 1105 + */ 1106 1106 + 1107 1107 + int i; 1108 1108 + uint8_t pwr_down; 1109 1109 + struct docg4_priv *doc = platform_get_drvdata(pdev); 1110 1110 + void __iomem *docptr = doc->virtadr; 1111 1111 + 1112 1112 + dev_dbg(doc->dev, "%s...\n", __func__); 1113 1113 + 1114 1114 + /* poll the register that tells us we're ready to go to sleep */ 1115 1115 + for (i = 0; i < 10; i++) { 1116 1116 + pwr_down = readb(docptr + DOC_POWERMODE); 1117 1117 + if (pwr_down & DOC_POWERDOWN_READY) 1118 1118 + break; 1119 1119 + usleep_range(1000, 4000); 1120 1120 + } 1121 1121 + 1122 1122 + if (pwr_down & DOC_POWERDOWN_READY) { 1123 1123 + dev_err(doc->dev, "suspend failed; " 1124 1124 + "timeout polling DOC_POWERDOWN_READY\n"); 1125 1125 + return -EIO; 1126 1126 + } 1127 1127 + 1128 1128 + writew(DOC_ASICMODE_POWERDOWN | DOC_ASICMODE_MDWREN, 1129 1129 + docptr + DOC_ASICMODE); 1130 1130 + writew(~(DOC_ASICMODE_POWERDOWN | DOC_ASICMODE_MDWREN), 1131 1131 + docptr + DOC_ASICMODECONFIRM); 1132 1132 + 1133 1133 + write_nop(docptr); 1134 1134 + 1135 1135 + return 0; 1136 1136 + } 1137 1137 + 1138 1138 + static int docg4_resume(struct platform_device *pdev) 1139 1139 + { 1140 1140 + 1141 1141 + /* 1142 1142 + * Exit power-down. Twelve consecutive reads of the address below 1143 1143 + * accomplishes this, assuming CE# has been asserted. 1144 1144 + */ 1145 1145 + 1146 1146 + struct docg4_priv *doc = platform_get_drvdata(pdev); 1147 1147 + void __iomem *docptr = doc->virtadr; 1148 1148 + int i; 1149 1149 + 1150 1150 + dev_dbg(doc->dev, "%s...\n", __func__); 1151 1151 + 1152 1152 + for (i = 0; i < 12; i++) 1153 1153 + readb(docptr + 0x1fff); 1154 1154 + 1155 1155 + return 0; 1156 1156 + } 1157 1157 + 1158 1158 + static void __init init_mtd_structs(struct mtd_info *mtd) 1159 1159 + { 1160 1160 + /* initialize mtd and nand data structures */ 1161 1161 + 1162 1162 + /* 1163 1163 + * Note that some of the following initializations are not usually 1164 1164 + * required within a nand driver because they are performed by the nand 1165 1165 + * infrastructure code as part of nand_scan(). In this case they need 1166 1166 + * to be initialized here because we skip call to nand_scan_ident() (the 1167 1167 + * first half of nand_scan()). The call to nand_scan_ident() is skipped 1168 1168 + * because for this device the chip id is not read in the manner of a 1169 1169 + * standard nand device. Unfortunately, nand_scan_ident() does other 1170 1170 + * things as well, such as call nand_set_defaults(). 1171 1171 + */ 1172 1172 + 1173 1173 + struct nand_chip *nand = mtd->priv; 1174 1174 + struct docg4_priv *doc = nand->priv; 1175 1175 + 1176 1176 + mtd->size = DOCG4_CHIP_SIZE; 1177 1177 + mtd->name = "Msys_Diskonchip_G4"; 1178 1178 + mtd->writesize = DOCG4_PAGE_SIZE; 1179 1179 + mtd->erasesize = DOCG4_BLOCK_SIZE; 1180 1180 + mtd->oobsize = DOCG4_OOB_SIZE; 1181 1181 + nand->chipsize = DOCG4_CHIP_SIZE; 1182 1182 + nand->chip_shift = DOCG4_CHIP_SHIFT; 1183 1183 + nand->bbt_erase_shift = nand->phys_erase_shift = DOCG4_ERASE_SHIFT; 1184 1184 + nand->chip_delay = 20; 1185 1185 + nand->page_shift = DOCG4_PAGE_SHIFT; 1186 1186 + nand->pagemask = 0x3ffff; 1187 1187 + nand->badblockpos = NAND_LARGE_BADBLOCK_POS; 1188 1188 + nand->badblockbits = 8; 1189 1189 + nand->ecc.layout = &docg4_oobinfo; 1190 1190 + nand->ecc.mode = NAND_ECC_HW_SYNDROME; 1191 1191 + nand->ecc.size = DOCG4_PAGE_SIZE; 1192 1192 + nand->ecc.prepad = 8; 1193 1193 + nand->ecc.bytes = 8; 1194 1194 + nand->ecc.strength = DOCG4_T; 1195 1195 + nand->options = 1196 1196 + NAND_BUSWIDTH_16 | NAND_NO_SUBPAGE_WRITE | NAND_NO_AUTOINCR; 1197 1197 + nand->IO_ADDR_R = nand->IO_ADDR_W = doc->virtadr + DOC_IOSPACE_DATA; 1198 1198 + nand->controller = &nand->hwcontrol; 1199 1199 + spin_lock_init(&nand->controller->lock); 1200 1200 + init_waitqueue_head(&nand->controller->wq); 1201 1201 + 1202 1202 + /* methods */ 1203 1203 + nand->cmdfunc = docg4_command; 1204 1204 + nand->waitfunc = docg4_wait; 1205 1205 + nand->select_chip = docg4_select_chip; 1206 1206 + nand->read_byte = docg4_read_byte; 1207 1207 + nand->block_markbad = docg4_block_markbad; 1208 1208 + nand->read_buf = docg4_read_buf; 1209 1209 + nand->write_buf = docg4_write_buf16; 1210 1210 + nand->scan_bbt = nand_default_bbt; 1211 1211 + nand->erase_cmd = docg4_erase_block; 1212 1212 + nand->ecc.read_page = docg4_read_page; 1213 1213 + nand->ecc.write_page = docg4_write_page; 1214 1214 + nand->ecc.read_page_raw = docg4_read_page_raw; 1215 1215 + nand->ecc.write_page_raw = docg4_write_page_raw; 1216 1216 + nand->ecc.read_oob = docg4_read_oob; 1217 1217 + nand->ecc.write_oob = docg4_write_oob; 1218 1218 + 1219 1219 + /* 1220 1220 + * The way the nand infrastructure code is written, a memory-based bbt 1221 1221 + * is not created if NAND_SKIP_BBTSCAN is set. With no memory bbt, 1222 1222 + * nand->block_bad() is used. So when ignoring bad blocks, we skip the 1223 1223 + * scan and define a dummy block_bad() which always returns 0. 1224 1224 + */ 1225 1225 + if (ignore_badblocks) { 1226 1226 + nand->options |= NAND_SKIP_BBTSCAN; 1227 1227 + nand->block_bad = docg4_block_neverbad; 1228 1228 + } 1229 1229 + 1230 1230 + } 1231 1231 + 1232 1232 + static int __init read_id_reg(struct mtd_info *mtd) 1233 1233 + { 1234 1234 + struct nand_chip *nand = mtd->priv; 1235 1235 + struct docg4_priv *doc = nand->priv; 1236 1236 + void __iomem *docptr = doc->virtadr; 1237 1237 + uint16_t id1, id2; 1238 1238 + 1239 1239 + /* check for presence of g4 chip by reading id registers */ 1240 1240 + id1 = readw(docptr + DOC_CHIPID); 1241 1241 + id1 = readw(docptr + DOCG4_MYSTERY_REG); 1242 1242 + id2 = readw(docptr + DOC_CHIPID_INV); 1243 1243 + id2 = readw(docptr + DOCG4_MYSTERY_REG); 1244 1244 + 1245 1245 + if (id1 == DOCG4_IDREG1_VALUE && id2 == DOCG4_IDREG2_VALUE) { 1246 1246 + dev_info(doc->dev, 1247 1247 + "NAND device: 128MiB Diskonchip G4 detected\n"); 1248 1248 + return 0; 1249 1249 + } 1250 1250 + 1251 1251 + return -ENODEV; 1252 1252 + } 1253 1253 + 1254 1254 + static char const *part_probes[] = { "cmdlinepart", "saftlpart", NULL }; 1255 1255 + 1256 1256 + static int __init probe_docg4(struct platform_device *pdev) 1257 1257 + { 1258 1258 + struct mtd_info *mtd; 1259 1259 + struct nand_chip *nand; 1260 1260 + void __iomem *virtadr; 1261 1261 + struct docg4_priv *doc; 1262 1262 + int len, retval; 1263 1263 + struct resource *r; 1264 1264 + struct device *dev = &pdev->dev; 1265 1265 + 1266 1266 + r = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1267 1267 + if (r == NULL) { 1268 1268 + dev_err(dev, "no io memory resource defined!\n"); 1269 1269 + return -ENODEV; 1270 1270 + } 1271 1271 + 1272 1272 + virtadr = ioremap(r->start, resource_size(r)); 1273 1273 + if (!virtadr) { 1274 1274 + dev_err(dev, "Diskonchip ioremap failed: %pR\n", r); 1275 1275 + return -EIO; 1276 1276 + } 1277 1277 + 1278 1278 + len = sizeof(struct mtd_info) + sizeof(struct nand_chip) + 1279 1279 + sizeof(struct docg4_priv); 1280 1280 + mtd = kzalloc(len, GFP_KERNEL); 1281 1281 + if (mtd == NULL) { 1282 1282 + retval = -ENOMEM; 1283 1283 + goto fail; 1284 1284 + } 1285 1285 + nand = (struct nand_chip *) (mtd + 1); 1286 1286 + doc = (struct docg4_priv *) (nand + 1); 1287 1287 + mtd->priv = nand; 1288 1288 + nand->priv = doc; 1289 1289 + mtd->owner = THIS_MODULE; 1290 1290 + doc->virtadr = virtadr; 1291 1291 + doc->dev = dev; 1292 1292 + 1293 1293 + init_mtd_structs(mtd); 1294 1294 + 1295 1295 + /* initialize kernel bch algorithm */ 1296 1296 + doc->bch = init_bch(DOCG4_M, DOCG4_T, DOCG4_PRIMITIVE_POLY); 1297 1297 + if (doc->bch == NULL) { 1298 1298 + retval = -EINVAL; 1299 1299 + goto fail; 1300 1300 + } 1301 1301 + 1302 1302 + platform_set_drvdata(pdev, doc); 1303 1303 + 1304 1304 + reset(mtd); 1305 1305 + retval = read_id_reg(mtd); 1306 1306 + if (retval == -ENODEV) { 1307 1307 + dev_warn(dev, "No diskonchip G4 device found.\n"); 1308 1308 + goto fail; 1309 1309 + } 1310 1310 + 1311 1311 + retval = nand_scan_tail(mtd); 1312 1312 + if (retval) 1313 1313 + goto fail; 1314 1314 + 1315 1315 + retval = read_factory_bbt(mtd); 1316 1316 + if (retval) 1317 1317 + goto fail; 1318 1318 + 1319 1319 + retval = mtd_device_parse_register(mtd, part_probes, NULL, NULL, 0); 1320 1320 + if (retval) 1321 1321 + goto fail; 1322 1322 + 1323 1323 + doc->mtd = mtd; 1324 1324 + return 0; 1325 1325 + 1326 1326 + fail: 1327 1327 + iounmap(virtadr); 1328 1328 + if (mtd) { 1329 1329 + /* re-declarations avoid compiler warning */ 1330 1330 + struct nand_chip *nand = mtd->priv; 1331 1331 + struct docg4_priv *doc = nand->priv; 1332 1332 + nand_release(mtd); /* deletes partitions and mtd devices */ 1333 1333 + platform_set_drvdata(pdev, NULL); 1334 1334 + free_bch(doc->bch); 1335 1335 + kfree(mtd); 1336 1336 + } 1337 1337 + 1338 1338 + return retval; 1339 1339 + } 1340 1340 + 1341 1341 + static int __exit cleanup_docg4(struct platform_device *pdev) 1342 1342 + { 1343 1343 + struct docg4_priv *doc = platform_get_drvdata(pdev); 1344 1344 + nand_release(doc->mtd); 1345 1345 + platform_set_drvdata(pdev, NULL); 1346 1346 + free_bch(doc->bch); 1347 1347 + kfree(doc->mtd); 1348 1348 + iounmap(doc->virtadr); 1349 1349 + return 0; 1350 1350 + } 1351 1351 + 1352 1352 + static struct platform_driver docg4_driver = { 1353 1353 + .driver = { 1354 1354 + .name = "docg4", 1355 1355 + .owner = THIS_MODULE, 1356 1356 + }, 1357 1357 + .suspend = docg4_suspend, 1358 1358 + .resume = docg4_resume, 1359 1359 + .remove = __exit_p(cleanup_docg4), 1360 1360 + }; 1361 1361 + 1362 1362 + static int __init docg4_init(void) 1363 1363 + { 1364 1364 + return platform_driver_probe(&docg4_driver, probe_docg4); 1365 1365 + } 1366 1366 + 1367 1367 + static void __exit docg4_exit(void) 1368 1368 + { 1369 1369 + platform_driver_unregister(&docg4_driver); 1370 1370 + } 1371 1371 + 1372 1372 + module_init(docg4_init); 1373 1373 + module_exit(docg4_exit); 1374 1374 + 1375 1375 + MODULE_LICENSE("GPL"); 1376 1376 + MODULE_AUTHOR("Mike Dunn"); 1377 1377 + MODULE_DESCRIPTION("M-Systems DiskOnChip G4 device driver");

+6

drivers/mtd/nand/fsl_elbc_nand.c

reviewed

··· 813 813 &fsl_elbc_oob_sp_eccm1 : &fsl_elbc_oob_sp_eccm0; 814 814 chip->ecc.size = 512; 815 815 chip->ecc.bytes = 3; 816 816 + chip->ecc.strength = 1; 817 817 + /* 818 818 + * FIXME: can hardware ecc correct 4 bitflips if page size is 819 819 + * 2k? Then does hardware report number of corrections for this 820 820 + * case? If so, ecc_stats reporting needs to be fixed as well. 821 821 + */ 816 822 } else { 817 823 /* otherwise fall back to default software ECC */ 818 824 chip->ecc.mode = NAND_ECC_SOFT;

+675 -249

drivers/mtd/nand/fsmc_nand.c

reviewed

··· 17 17 */ 18 18 19 19 #include <linux/clk.h> 20 20 + #include <linux/completion.h> 21 21 + #include <linux/dmaengine.h> 22 22 + #include <linux/dma-direction.h> 23 23 + #include <linux/dma-mapping.h> 20 24 #include <linux/err.h> 21 25 #include <linux/init.h> 22 26 #include <linux/module.h> ··· 31 27 #include <linux/mtd/nand.h> 32 28 #include <linux/mtd/nand_ecc.h> 33 29 #include <linux/platform_device.h> 30 30 + #include <linux/of.h> 34 31 #include <linux/mtd/partitions.h> 35 32 #include <linux/io.h> 36 33 #include <linux/slab.h> ··· 39 34 #include <linux/amba/bus.h> 40 35 #include <mtd/mtd-abi.h> 41 36 42 42 - static struct nand_ecclayout fsmc_ecc1_layout = { 37 37 + static struct nand_ecclayout fsmc_ecc1_128_layout = { 43 38 .eccbytes = 24, 44 39 .eccpos = {2, 3, 4, 18, 19, 20, 34, 35, 36, 50, 51, 52, 45 40 66, 67, 68, 82, 83, 84, 98, 99, 100, 114, 115, 116}, ··· 55 50 } 56 51 }; 57 52 58 58 - static struct nand_ecclayout fsmc_ecc4_lp_layout = { 53 53 + static struct nand_ecclayout fsmc_ecc1_64_layout = { 54 54 + .eccbytes = 12, 55 55 + .eccpos = {2, 3, 4, 18, 19, 20, 34, 35, 36, 50, 51, 52}, 56 56 + .oobfree = { 57 57 + {.offset = 8, .length = 8}, 58 58 + {.offset = 24, .length = 8}, 59 59 + {.offset = 40, .length = 8}, 60 60 + {.offset = 56, .length = 8}, 61 61 + } 62 62 + }; 63 63 + 64 64 + static struct nand_ecclayout fsmc_ecc1_16_layout = { 65 65 + .eccbytes = 3, 66 66 + .eccpos = {2, 3, 4}, 67 67 + .oobfree = { 68 68 + {.offset = 8, .length = 8}, 69 69 + } 70 70 + }; 71 71 + 72 72 + /* 73 73 + * ECC4 layout for NAND of pagesize 8192 bytes & OOBsize 256 bytes. 13*16 bytes 74 74 + * of OB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block and 46 75 75 + * bytes are free for use. 76 76 + */ 77 77 + static struct nand_ecclayout fsmc_ecc4_256_layout = { 78 78 + .eccbytes = 208, 79 79 + .eccpos = { 2, 3, 4, 5, 6, 7, 8, 80 80 + 9, 10, 11, 12, 13, 14, 81 81 + 18, 19, 20, 21, 22, 23, 24, 82 82 + 25, 26, 27, 28, 29, 30, 83 83 + 34, 35, 36, 37, 38, 39, 40, 84 84 + 41, 42, 43, 44, 45, 46, 85 85 + 50, 51, 52, 53, 54, 55, 56, 86 86 + 57, 58, 59, 60, 61, 62, 87 87 + 66, 67, 68, 69, 70, 71, 72, 88 88 + 73, 74, 75, 76, 77, 78, 89 89 + 82, 83, 84, 85, 86, 87, 88, 90 90 + 89, 90, 91, 92, 93, 94, 91 91 + 98, 99, 100, 101, 102, 103, 104, 92 92 + 105, 106, 107, 108, 109, 110, 93 93 + 114, 115, 116, 117, 118, 119, 120, 94 94 + 121, 122, 123, 124, 125, 126, 95 95 + 130, 131, 132, 133, 134, 135, 136, 96 96 + 137, 138, 139, 140, 141, 142, 97 97 + 146, 147, 148, 149, 150, 151, 152, 98 98 + 153, 154, 155, 156, 157, 158, 99 99 + 162, 163, 164, 165, 166, 167, 168, 100 100 + 169, 170, 171, 172, 173, 174, 101 101 + 178, 179, 180, 181, 182, 183, 184, 102 102 + 185, 186, 187, 188, 189, 190, 103 103 + 194, 195, 196, 197, 198, 199, 200, 104 104 + 201, 202, 203, 204, 205, 206, 105 105 + 210, 211, 212, 213, 214, 215, 216, 106 106 + 217, 218, 219, 220, 221, 222, 107 107 + 226, 227, 228, 229, 230, 231, 232, 108 108 + 233, 234, 235, 236, 237, 238, 109 109 + 242, 243, 244, 245, 246, 247, 248, 110 110 + 249, 250, 251, 252, 253, 254 111 111 + }, 112 112 + .oobfree = { 113 113 + {.offset = 15, .length = 3}, 114 114 + {.offset = 31, .length = 3}, 115 115 + {.offset = 47, .length = 3}, 116 116 + {.offset = 63, .length = 3}, 117 117 + {.offset = 79, .length = 3}, 118 118 + {.offset = 95, .length = 3}, 119 119 + {.offset = 111, .length = 3}, 120 120 + {.offset = 127, .length = 3}, 121 121 + {.offset = 143, .length = 3}, 122 122 + {.offset = 159, .length = 3}, 123 123 + {.offset = 175, .length = 3}, 124 124 + {.offset = 191, .length = 3}, 125 125 + {.offset = 207, .length = 3}, 126 126 + {.offset = 223, .length = 3}, 127 127 + {.offset = 239, .length = 3}, 128 128 + {.offset = 255, .length = 1} 129 129 + } 130 130 + }; 131 131 + 132 132 + /* 133 133 + * ECC4 layout for NAND of pagesize 4096 bytes & OOBsize 224 bytes. 13*8 bytes 134 134 + * of OOB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block & 118 135 135 + * bytes are free for use. 136 136 + */ 137 137 + static struct nand_ecclayout fsmc_ecc4_224_layout = { 138 138 + .eccbytes = 104, 139 139 + .eccpos = { 2, 3, 4, 5, 6, 7, 8, 140 140 + 9, 10, 11, 12, 13, 14, 141 141 + 18, 19, 20, 21, 22, 23, 24, 142 142 + 25, 26, 27, 28, 29, 30, 143 143 + 34, 35, 36, 37, 38, 39, 40, 144 144 + 41, 42, 43, 44, 45, 46, 145 145 + 50, 51, 52, 53, 54, 55, 56, 146 146 + 57, 58, 59, 60, 61, 62, 147 147 + 66, 67, 68, 69, 70, 71, 72, 148 148 + 73, 74, 75, 76, 77, 78, 149 149 + 82, 83, 84, 85, 86, 87, 88, 150 150 + 89, 90, 91, 92, 93, 94, 151 151 + 98, 99, 100, 101, 102, 103, 104, 152 152 + 105, 106, 107, 108, 109, 110, 153 153 + 114, 115, 116, 117, 118, 119, 120, 154 154 + 121, 122, 123, 124, 125, 126 155 155 + }, 156 156 + .oobfree = { 157 157 + {.offset = 15, .length = 3}, 158 158 + {.offset = 31, .length = 3}, 159 159 + {.offset = 47, .length = 3}, 160 160 + {.offset = 63, .length = 3}, 161 161 + {.offset = 79, .length = 3}, 162 162 + {.offset = 95, .length = 3}, 163 163 + {.offset = 111, .length = 3}, 164 164 + {.offset = 127, .length = 97} 165 165 + } 166 166 + }; 167 167 + 168 168 + /* 169 169 + * ECC4 layout for NAND of pagesize 4096 bytes & OOBsize 128 bytes. 13*8 bytes 170 170 + * of OOB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block & 22 171 171 + * bytes are free for use. 172 172 + */ 173 173 + static struct nand_ecclayout fsmc_ecc4_128_layout = { 59 174 .eccbytes = 104, 60 175 .eccpos = { 2, 3, 4, 5, 6, 7, 8, 61 176 9, 10, 11, 12, 13, 14, ··· 207 82 }; 208 83 209 84 /* 85 85 + * ECC4 layout for NAND of pagesize 2048 bytes & OOBsize 64 bytes. 13*4 bytes of 86 86 + * OOB size is reserved for ECC, Byte no. 0 & 1 reserved for bad block and 10 87 87 + * bytes are free for use. 88 88 + */ 89 89 + static struct nand_ecclayout fsmc_ecc4_64_layout = { 90 90 + .eccbytes = 52, 91 91 + .eccpos = { 2, 3, 4, 5, 6, 7, 8, 92 92 + 9, 10, 11, 12, 13, 14, 93 93 + 18, 19, 20, 21, 22, 23, 24, 94 94 + 25, 26, 27, 28, 29, 30, 95 95 + 34, 35, 36, 37, 38, 39, 40, 96 96 + 41, 42, 43, 44, 45, 46, 97 97 + 50, 51, 52, 53, 54, 55, 56, 98 98 + 57, 58, 59, 60, 61, 62, 99 99 + }, 100 100 + .oobfree = { 101 101 + {.offset = 15, .length = 3}, 102 102 + {.offset = 31, .length = 3}, 103 103 + {.offset = 47, .length = 3}, 104 104 + {.offset = 63, .length = 1}, 105 105 + } 106 106 + }; 107 107 + 108 108 + /* 109 109 + * ECC4 layout for NAND of pagesize 512 bytes & OOBsize 16 bytes. 13 bytes of 110 110 + * OOB size is reserved for ECC, Byte no. 4 & 5 reserved for bad block and One 111 111 + * byte is free for use. 112 112 + */ 113 113 + static struct nand_ecclayout fsmc_ecc4_16_layout = { 114 114 + .eccbytes = 13, 115 115 + .eccpos = { 0, 1, 2, 3, 6, 7, 8, 116 116 + 9, 10, 11, 12, 13, 14 117 117 + }, 118 118 + .oobfree = { 119 119 + {.offset = 15, .length = 1}, 120 120 + } 121 121 + }; 122 122 + 123 123 + /* 210 124 * ECC placement definitions in oobfree type format. 211 125 * There are 13 bytes of ecc for every 512 byte block and it has to be read 212 126 * consecutively and immediately after the 512 byte data block for hardware to ··· 267 103 } 268 104 }; 269 105 270 270 - static struct nand_ecclayout fsmc_ecc4_sp_layout = { 271 271 - .eccbytes = 13, 272 272 - .eccpos = { 0, 1, 2, 3, 6, 7, 8, 273 273 - 9, 10, 11, 12, 13, 14 274 274 - }, 275 275 - .oobfree = { 276 276 - {.offset = 15, .length = 1}, 277 277 - } 278 278 - }; 279 279 - 280 106 static struct fsmc_eccplace fsmc_ecc4_sp_place = { 281 107 .eccplace = { 282 108 {.offset = 0, .length = 4}, ··· 274 120 } 275 121 }; 276 122 277 277 - /* 278 278 - * Default partition tables to be used if the partition information not 279 279 - * provided through platform data. 280 280 - * 281 281 - * Default partition layout for small page(= 512 bytes) devices 282 282 - * Size for "Root file system" is updated in driver based on actual device size 283 283 - */ 284 284 - static struct mtd_partition partition_info_16KB_blk[] = { 285 285 - { 286 286 - .name = "X-loader", 287 287 - .offset = 0, 288 288 - .size = 4*0x4000, 289 289 - }, 290 290 - { 291 291 - .name = "U-Boot", 292 292 - .offset = 0x10000, 293 293 - .size = 20*0x4000, 294 294 - }, 295 295 - { 296 296 - .name = "Kernel", 297 297 - .offset = 0x60000, 298 298 - .size = 256*0x4000, 299 299 - }, 300 300 - { 301 301 - .name = "Root File System", 302 302 - .offset = 0x460000, 303 303 - .size = MTDPART_SIZ_FULL, 304 304 - }, 305 305 - }; 306 306 - 307 307 - /* 308 308 - * Default partition layout for large page(> 512 bytes) devices 309 309 - * Size for "Root file system" is updated in driver based on actual device size 310 310 - */ 311 311 - static struct mtd_partition partition_info_128KB_blk[] = { 312 312 - { 313 313 - .name = "X-loader", 314 314 - .offset = 0, 315 315 - .size = 4*0x20000, 316 316 - }, 317 317 - { 318 318 - .name = "U-Boot", 319 319 - .offset = 0x80000, 320 320 - .size = 12*0x20000, 321 321 - }, 322 322 - { 323 323 - .name = "Kernel", 324 324 - .offset = 0x200000, 325 325 - .size = 48*0x20000, 326 326 - }, 327 327 - { 328 328 - .name = "Root File System", 329 329 - .offset = 0x800000, 330 330 - .size = MTDPART_SIZ_FULL, 331 331 - }, 332 332 - }; 333 333 - 334 334 - 335 123 /** 336 124 * struct fsmc_nand_data - structure for FSMC NAND device state 337 125 * 338 126 * @pid: Part ID on the AMBA PrimeCell format 339 127 * @mtd: MTD info for a NAND flash. 340 128 * @nand: Chip related info for a NAND flash. 129 129 + * @partitions: Partition info for a NAND Flash. 130 130 + * @nr_partitions: Total number of partition of a NAND flash. 341 131 * 342 132 * @ecc_place: ECC placing locations in oobfree type format. 343 133 * @bank: Bank number for probed device. 344 134 * @clk: Clock structure for FSMC. 345 135 * 136 136 + * @read_dma_chan: DMA channel for read access 137 137 + * @write_dma_chan: DMA channel for write access to NAND 138 138 + * @dma_access_complete: Completion structure 139 139 + * 140 140 + * @data_pa: NAND Physical port for Data. 346 141 * @data_va: NAND port for Data. 347 142 * @cmd_va: NAND port for Command. 348 143 * @addr_va: NAND port for Address. ··· 301 198 u32 pid; 302 199 struct mtd_info mtd; 303 200 struct nand_chip nand; 201 201 + struct mtd_partition *partitions; 202 202 + unsigned int nr_partitions; 304 203 305 204 struct fsmc_eccplace *ecc_place; 306 205 unsigned int bank; 206 206 + struct device *dev; 207 207 + enum access_mode mode; 307 208 struct clk *clk; 308 209 309 309 - struct resource *resregs; 310 310 - struct resource *rescmd; 311 311 - struct resource *resaddr; 312 312 - struct resource *resdata; 210 210 + /* DMA related objects */ 211 211 + struct dma_chan *read_dma_chan; 212 212 + struct dma_chan *write_dma_chan; 213 213 + struct completion dma_access_complete; 313 214 215 215 + struct fsmc_nand_timings *dev_timings; 216 216 + 217 217 + dma_addr_t data_pa; 314 218 void __iomem *data_va; 315 219 void __iomem *cmd_va; 316 220 void __iomem *addr_va; ··· 361 251 struct nand_chip *this = mtd->priv; 362 252 struct fsmc_nand_data *host = container_of(mtd, 363 253 struct fsmc_nand_data, mtd); 364 364 - struct fsmc_regs *regs = host->regs_va; 254 254 + void *__iomem *regs = host->regs_va; 365 255 unsigned int bank = host->bank; 366 256 367 257 if (ctrl & NAND_CTRL_CHANGE) { 258 258 + u32 pc; 259 259 + 368 260 if (ctrl & NAND_CLE) { 369 369 - this->IO_ADDR_R = (void __iomem *)host->cmd_va; 370 370 - this->IO_ADDR_W = (void __iomem *)host->cmd_va; 261 261 + this->IO_ADDR_R = host->cmd_va; 262 262 + this->IO_ADDR_W = host->cmd_va; 371 263 } else if (ctrl & NAND_ALE) { 372 372 - this->IO_ADDR_R = (void __iomem *)host->addr_va; 373 373 - this->IO_ADDR_W = (void __iomem *)host->addr_va; 264 264 + this->IO_ADDR_R = host->addr_va; 265 265 + this->IO_ADDR_W = host->addr_va; 374 266 } else { 375 375 - this->IO_ADDR_R = (void __iomem *)host->data_va; 376 376 - this->IO_ADDR_W = (void __iomem *)host->data_va; 267 267 + this->IO_ADDR_R = host->data_va; 268 268 + this->IO_ADDR_W = host->data_va; 377 269 } 378 270 379 379 - if (ctrl & NAND_NCE) { 380 380 - writel(readl(&regs->bank_regs[bank].pc) | FSMC_ENABLE, 381 381 - &regs->bank_regs[bank].pc); 382 382 - } else { 383 383 - writel(readl(&regs->bank_regs[bank].pc) & ~FSMC_ENABLE, 384 384 - &regs->bank_regs[bank].pc); 385 385 - } 271 271 + pc = readl(FSMC_NAND_REG(regs, bank, PC)); 272 272 + if (ctrl & NAND_NCE) 273 273 + pc |= FSMC_ENABLE; 274 274 + else 275 275 + pc &= ~FSMC_ENABLE; 276 276 + writel(pc, FSMC_NAND_REG(regs, bank, PC)); 386 277 } 387 278 388 279 mb(); ··· 398 287 * This routine initializes timing parameters related to NAND memory access in 399 288 * FSMC registers 400 289 */ 401 401 - static void __init fsmc_nand_setup(struct fsmc_regs *regs, uint32_t bank, 402 402 - uint32_t busw) 290 290 + static void fsmc_nand_setup(void __iomem *regs, uint32_t bank, 291 291 + uint32_t busw, struct fsmc_nand_timings *timings) 403 292 { 404 293 uint32_t value = FSMC_DEVTYPE_NAND | FSMC_ENABLE | FSMC_WAITON; 294 294 + uint32_t tclr, tar, thiz, thold, twait, tset; 295 295 + struct fsmc_nand_timings *tims; 296 296 + struct fsmc_nand_timings default_timings = { 297 297 + .tclr = FSMC_TCLR_1, 298 298 + .tar = FSMC_TAR_1, 299 299 + .thiz = FSMC_THIZ_1, 300 300 + .thold = FSMC_THOLD_4, 301 301 + .twait = FSMC_TWAIT_6, 302 302 + .tset = FSMC_TSET_0, 303 303 + }; 304 304 + 305 305 + if (timings) 306 306 + tims = timings; 307 307 + else 308 308 + tims = &default_timings; 309 309 + 310 310 + tclr = (tims->tclr & FSMC_TCLR_MASK) << FSMC_TCLR_SHIFT; 311 311 + tar = (tims->tar & FSMC_TAR_MASK) << FSMC_TAR_SHIFT; 312 312 + thiz = (tims->thiz & FSMC_THIZ_MASK) << FSMC_THIZ_SHIFT; 313 313 + thold = (tims->thold & FSMC_THOLD_MASK) << FSMC_THOLD_SHIFT; 314 314 + twait = (tims->twait & FSMC_TWAIT_MASK) << FSMC_TWAIT_SHIFT; 315 315 + tset = (tims->tset & FSMC_TSET_MASK) << FSMC_TSET_SHIFT; 405 316 406 317 if (busw) 407 407 - writel(value | FSMC_DEVWID_16, &regs->bank_regs[bank].pc); 318 318 + writel(value | FSMC_DEVWID_16, FSMC_NAND_REG(regs, bank, PC)); 408 319 else 409 409 - writel(value | FSMC_DEVWID_8, &regs->bank_regs[bank].pc); 320 320 + writel(value | FSMC_DEVWID_8, FSMC_NAND_REG(regs, bank, PC)); 410 321 411 411 - writel(readl(&regs->bank_regs[bank].pc) | FSMC_TCLR_1 | FSMC_TAR_1, 412 412 - &regs->bank_regs[bank].pc); 413 413 - writel(FSMC_THIZ_1 | FSMC_THOLD_4 | FSMC_TWAIT_6 | FSMC_TSET_0, 414 414 - &regs->bank_regs[bank].comm); 415 415 - writel(FSMC_THIZ_1 | FSMC_THOLD_4 | FSMC_TWAIT_6 | FSMC_TSET_0, 416 416 - &regs->bank_regs[bank].attrib); 322 322 + writel(readl(FSMC_NAND_REG(regs, bank, PC)) | tclr | tar, 323 323 + FSMC_NAND_REG(regs, bank, PC)); 324 324 + writel(thiz | thold | twait | tset, FSMC_NAND_REG(regs, bank, COMM)); 325 325 + writel(thiz | thold | twait | tset, FSMC_NAND_REG(regs, bank, ATTRIB)); 417 326 } 418 327 419 328 /* ··· 443 312 { 444 313 struct fsmc_nand_data *host = container_of(mtd, 445 314 struct fsmc_nand_data, mtd); 446 446 - struct fsmc_regs *regs = host->regs_va; 315 315 + void __iomem *regs = host->regs_va; 447 316 uint32_t bank = host->bank; 448 317 449 449 - writel(readl(&regs->bank_regs[bank].pc) & ~FSMC_ECCPLEN_256, 450 450 - &regs->bank_regs[bank].pc); 451 451 - writel(readl(&regs->bank_regs[bank].pc) & ~FSMC_ECCEN, 452 452 - &regs->bank_regs[bank].pc); 453 453 - writel(readl(&regs->bank_regs[bank].pc) | FSMC_ECCEN, 454 454 - &regs->bank_regs[bank].pc); 318 318 + writel(readl(FSMC_NAND_REG(regs, bank, PC)) & ~FSMC_ECCPLEN_256, 319 319 + FSMC_NAND_REG(regs, bank, PC)); 320 320 + writel(readl(FSMC_NAND_REG(regs, bank, PC)) & ~FSMC_ECCEN, 321 321 + FSMC_NAND_REG(regs, bank, PC)); 322 322 + writel(readl(FSMC_NAND_REG(regs, bank, PC)) | FSMC_ECCEN, 323 323 + FSMC_NAND_REG(regs, bank, PC)); 455 324 } 456 325 457 326 /* ··· 464 333 { 465 334 struct fsmc_nand_data *host = container_of(mtd, 466 335 struct fsmc_nand_data, mtd); 467 467 - struct fsmc_regs *regs = host->regs_va; 336 336 + void __iomem *regs = host->regs_va; 468 337 uint32_t bank = host->bank; 469 338 uint32_t ecc_tmp; 470 339 unsigned long deadline = jiffies + FSMC_BUSY_WAIT_TIMEOUT; 471 340 472 341 do { 473 473 - if (readl(&regs->bank_regs[bank].sts) & FSMC_CODE_RDY) 342 342 + if (readl(FSMC_NAND_REG(regs, bank, STS)) & FSMC_CODE_RDY) 474 343 break; 475 344 else 476 345 cond_resched(); 477 346 } while (!time_after_eq(jiffies, deadline)); 478 347 479 479 - ecc_tmp = readl(&regs->bank_regs[bank].ecc1); 348 348 + if (time_after_eq(jiffies, deadline)) { 349 349 + dev_err(host->dev, "calculate ecc timed out\n"); 350 350 + return -ETIMEDOUT; 351 351 + } 352 352 + 353 353 + ecc_tmp = readl(FSMC_NAND_REG(regs, bank, ECC1)); 480 354 ecc[0] = (uint8_t) (ecc_tmp >> 0); 481 355 ecc[1] = (uint8_t) (ecc_tmp >> 8); 482 356 ecc[2] = (uint8_t) (ecc_tmp >> 16); 483 357 ecc[3] = (uint8_t) (ecc_tmp >> 24); 484 358 485 485 - ecc_tmp = readl(&regs->bank_regs[bank].ecc2); 359 359 + ecc_tmp = readl(FSMC_NAND_REG(regs, bank, ECC2)); 486 360 ecc[4] = (uint8_t) (ecc_tmp >> 0); 487 361 ecc[5] = (uint8_t) (ecc_tmp >> 8); 488 362 ecc[6] = (uint8_t) (ecc_tmp >> 16); 489 363 ecc[7] = (uint8_t) (ecc_tmp >> 24); 490 364 491 491 - ecc_tmp = readl(&regs->bank_regs[bank].ecc3); 365 365 + ecc_tmp = readl(FSMC_NAND_REG(regs, bank, ECC3)); 492 366 ecc[8] = (uint8_t) (ecc_tmp >> 0); 493 367 ecc[9] = (uint8_t) (ecc_tmp >> 8); 494 368 ecc[10] = (uint8_t) (ecc_tmp >> 16); 495 369 ecc[11] = (uint8_t) (ecc_tmp >> 24); 496 370 497 497 - ecc_tmp = readl(&regs->bank_regs[bank].sts); 371 371 + ecc_tmp = readl(FSMC_NAND_REG(regs, bank, STS)); 498 372 ecc[12] = (uint8_t) (ecc_tmp >> 16); 499 373 500 374 return 0; ··· 515 379 { 516 380 struct fsmc_nand_data *host = container_of(mtd, 517 381 struct fsmc_nand_data, mtd); 518 518 - struct fsmc_regs *regs = host->regs_va; 382 382 + void __iomem *regs = host->regs_va; 519 383 uint32_t bank = host->bank; 520 384 uint32_t ecc_tmp; 521 385 522 522 - ecc_tmp = readl(&regs->bank_regs[bank].ecc1); 386 386 + ecc_tmp = readl(FSMC_NAND_REG(regs, bank, ECC1)); 523 387 ecc[0] = (uint8_t) (ecc_tmp >> 0); 524 388 ecc[1] = (uint8_t) (ecc_tmp >> 8); 525 389 ecc[2] = (uint8_t) (ecc_tmp >> 16); 526 390 527 391 return 0; 392 392 + } 393 393 + 394 394 + /* Count the number of 0's in buff upto a max of max_bits */ 395 395 + static int count_written_bits(uint8_t *buff, int size, int max_bits) 396 396 + { 397 397 + int k, written_bits = 0; 398 398 + 399 399 + for (k = 0; k < size; k++) { 400 400 + written_bits += hweight8(~buff[k]); 401 401 + if (written_bits > max_bits) 402 402 + break; 403 403 + } 404 404 + 405 405 + return written_bits; 406 406 + } 407 407 + 408 408 + static void dma_complete(void *param) 409 409 + { 410 410 + struct fsmc_nand_data *host = param; 411 411 + 412 412 + complete(&host->dma_access_complete); 413 413 + } 414 414 + 415 415 + static int dma_xfer(struct fsmc_nand_data *host, void *buffer, int len, 416 416 + enum dma_data_direction direction) 417 417 + { 418 418 + struct dma_chan *chan; 419 419 + struct dma_device *dma_dev; 420 420 + struct dma_async_tx_descriptor *tx; 421 421 + dma_addr_t dma_dst, dma_src, dma_addr; 422 422 + dma_cookie_t cookie; 423 423 + unsigned long flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT; 424 424 + int ret; 425 425 + 426 426 + if (direction == DMA_TO_DEVICE) 427 427 + chan = host->write_dma_chan; 428 428 + else if (direction == DMA_FROM_DEVICE) 429 429 + chan = host->read_dma_chan; 430 430 + else 431 431 + return -EINVAL; 432 432 + 433 433 + dma_dev = chan->device; 434 434 + dma_addr = dma_map_single(dma_dev->dev, buffer, len, direction); 435 435 + 436 436 + if (direction == DMA_TO_DEVICE) { 437 437 + dma_src = dma_addr; 438 438 + dma_dst = host->data_pa; 439 439 + flags |= DMA_COMPL_SRC_UNMAP_SINGLE | DMA_COMPL_SKIP_DEST_UNMAP; 440 440 + } else { 441 441 + dma_src = host->data_pa; 442 442 + dma_dst = dma_addr; 443 443 + flags |= DMA_COMPL_DEST_UNMAP_SINGLE | DMA_COMPL_SKIP_SRC_UNMAP; 444 444 + } 445 445 + 446 446 + tx = dma_dev->device_prep_dma_memcpy(chan, dma_dst, dma_src, 447 447 + len, flags); 448 448 + 449 449 + if (!tx) { 450 450 + dev_err(host->dev, "device_prep_dma_memcpy error\n"); 451 451 + dma_unmap_single(dma_dev->dev, dma_addr, len, direction); 452 452 + return -EIO; 453 453 + } 454 454 + 455 455 + tx->callback = dma_complete; 456 456 + tx->callback_param = host; 457 457 + cookie = tx->tx_submit(tx); 458 458 + 459 459 + ret = dma_submit_error(cookie); 460 460 + if (ret) { 461 461 + dev_err(host->dev, "dma_submit_error %d\n", cookie); 462 462 + return ret; 463 463 + } 464 464 + 465 465 + dma_async_issue_pending(chan); 466 466 + 467 467 + ret = 468 468 + wait_for_completion_interruptible_timeout(&host->dma_access_complete, 469 469 + msecs_to_jiffies(3000)); 470 470 + if (ret <= 0) { 471 471 + chan->device->device_control(chan, DMA_TERMINATE_ALL, 0); 472 472 + dev_err(host->dev, "wait_for_completion_timeout\n"); 473 473 + return ret ? ret : -ETIMEDOUT; 474 474 + } 475 475 + 476 476 + return 0; 477 477 + } 478 478 + 479 479 + /* 480 480 + * fsmc_write_buf - write buffer to chip 481 481 + * @mtd: MTD device structure 482 482 + * @buf: data buffer 483 483 + * @len: number of bytes to write 484 484 + */ 485 485 + static void fsmc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len) 486 486 + { 487 487 + int i; 488 488 + struct nand_chip *chip = mtd->priv; 489 489 + 490 490 + if (IS_ALIGNED((uint32_t)buf, sizeof(uint32_t)) && 491 491 + IS_ALIGNED(len, sizeof(uint32_t))) { 492 492 + uint32_t *p = (uint32_t *)buf; 493 493 + len = len >> 2; 494 494 + for (i = 0; i < len; i++) 495 495 + writel(p[i], chip->IO_ADDR_W); 496 496 + } else { 497 497 + for (i = 0; i < len; i++) 498 498 + writeb(buf[i], chip->IO_ADDR_W); 499 499 + } 500 500 + } 501 501 + 502 502 + /* 503 503 + * fsmc_read_buf - read chip data into buffer 504 504 + * @mtd: MTD device structure 505 505 + * @buf: buffer to store date 506 506 + * @len: number of bytes to read 507 507 + */ 508 508 + static void fsmc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len) 509 509 + { 510 510 + int i; 511 511 + struct nand_chip *chip = mtd->priv; 512 512 + 513 513 + if (IS_ALIGNED((uint32_t)buf, sizeof(uint32_t)) && 514 514 + IS_ALIGNED(len, sizeof(uint32_t))) { 515 515 + uint32_t *p = (uint32_t *)buf; 516 516 + len = len >> 2; 517 517 + for (i = 0; i < len; i++) 518 518 + p[i] = readl(chip->IO_ADDR_R); 519 519 + } else { 520 520 + for (i = 0; i < len; i++) 521 521 + buf[i] = readb(chip->IO_ADDR_R); 522 522 + } 523 523 + } 524 524 + 525 525 + /* 526 526 + * fsmc_read_buf_dma - read chip data into buffer 527 527 + * @mtd: MTD device structure 528 528 + * @buf: buffer to store date 529 529 + * @len: number of bytes to read 530 530 + */ 531 531 + static void fsmc_read_buf_dma(struct mtd_info *mtd, uint8_t *buf, int len) 532 532 + { 533 533 + struct fsmc_nand_data *host; 534 534 + 535 535 + host = container_of(mtd, struct fsmc_nand_data, mtd); 536 536 + dma_xfer(host, buf, len, DMA_FROM_DEVICE); 537 537 + } 538 538 + 539 539 + /* 540 540 + * fsmc_write_buf_dma - write buffer to chip 541 541 + * @mtd: MTD device structure 542 542 + * @buf: data buffer 543 543 + * @len: number of bytes to write 544 544 + */ 545 545 + static void fsmc_write_buf_dma(struct mtd_info *mtd, const uint8_t *buf, 546 546 + int len) 547 547 + { 548 548 + struct fsmc_nand_data *host; 549 549 + 550 550 + host = container_of(mtd, struct fsmc_nand_data, mtd); 551 551 + dma_xfer(host, (void *)buf, len, DMA_TO_DEVICE); 528 552 } 529 553 530 554 /* ··· 722 426 uint8_t *oob = (uint8_t *)&ecc_oob[0]; 723 427 724 428 for (i = 0, s = 0; s < eccsteps; s++, i += eccbytes, p += eccsize) { 725 725 - 726 429 chip->cmdfunc(mtd, NAND_CMD_READ0, s * eccsize, page); 727 430 chip->ecc.hwctl(mtd, NAND_ECC_READ); 728 431 chip->read_buf(mtd, p, eccsize); ··· 732 437 group++; 733 438 734 439 /* 735 735 - * length is intentionally kept a higher multiple of 2 736 736 - * to read at least 13 bytes even in case of 16 bit NAND 737 737 - * devices 738 738 - */ 739 739 - len = roundup(len, 2); 440 440 + * length is intentionally kept a higher multiple of 2 441 441 + * to read at least 13 bytes even in case of 16 bit NAND 442 442 + * devices 443 443 + */ 444 444 + if (chip->options & NAND_BUSWIDTH_16) 445 445 + len = roundup(len, 2); 446 446 + 740 447 chip->cmdfunc(mtd, NAND_CMD_READOOB, off, page); 741 448 chip->read_buf(mtd, oob + j, len); 742 449 j += len; 743 450 } 744 451 745 745 - memcpy(&ecc_code[i], oob, 13); 452 452 + memcpy(&ecc_code[i], oob, chip->ecc.bytes); 746 453 chip->ecc.calculate(mtd, p, &ecc_calc[i]); 747 454 748 455 stat = chip->ecc.correct(mtd, p, &ecc_code[i], &ecc_calc[i]); ··· 758 461 } 759 462 760 463 /* 761 761 - * fsmc_correct_data 464 464 + * fsmc_bch8_correct_data 762 465 * @mtd: mtd info structure 763 466 * @dat: buffer of read data 764 467 * @read_ecc: ecc read from device spare area ··· 767 470 * calc_ecc is a 104 bit information containing maximum of 8 error 768 471 * offset informations of 13 bits each in 512 bytes of read data. 769 472 */ 770 770 - static int fsmc_correct_data(struct mtd_info *mtd, uint8_t *dat, 473 473 + static int fsmc_bch8_correct_data(struct mtd_info *mtd, uint8_t *dat, 771 474 uint8_t *read_ecc, uint8_t *calc_ecc) 772 475 { 773 476 struct fsmc_nand_data *host = container_of(mtd, 774 477 struct fsmc_nand_data, mtd); 775 775 - struct fsmc_regs *regs = host->regs_va; 478 478 + struct nand_chip *chip = mtd->priv; 479 479 + void __iomem *regs = host->regs_va; 776 480 unsigned int bank = host->bank; 777 777 - uint16_t err_idx[8]; 778 778 - uint64_t ecc_data[2]; 481 481 + uint32_t err_idx[8]; 779 482 uint32_t num_err, i; 483 483 + uint32_t ecc1, ecc2, ecc3, ecc4; 780 484 781 781 - /* The calculated ecc is actually the correction index in data */ 782 782 - memcpy(ecc_data, calc_ecc, 13); 485 485 + num_err = (readl(FSMC_NAND_REG(regs, bank, STS)) >> 10) & 0xF; 486 486 + 487 487 + /* no bit flipping */ 488 488 + if (likely(num_err == 0)) 489 489 + return 0; 490 490 + 491 491 + /* too many errors */ 492 492 + if (unlikely(num_err > 8)) { 493 493 + /* 494 494 + * This is a temporary erase check. A newly erased page read 495 495 + * would result in an ecc error because the oob data is also 496 496 + * erased to FF and the calculated ecc for an FF data is not 497 497 + * FF..FF. 498 498 + * This is a workaround to skip performing correction in case 499 499 + * data is FF..FF 500 500 + * 501 501 + * Logic: 502 502 + * For every page, each bit written as 0 is counted until these 503 503 + * number of bits are greater than 8 (the maximum correction 504 504 + * capability of FSMC for each 512 + 13 bytes) 505 505 + */ 506 506 + 507 507 + int bits_ecc = count_written_bits(read_ecc, chip->ecc.bytes, 8); 508 508 + int bits_data = count_written_bits(dat, chip->ecc.size, 8); 509 509 + 510 510 + if ((bits_ecc + bits_data) <= 8) { 511 511 + if (bits_data) 512 512 + memset(dat, 0xff, chip->ecc.size); 513 513 + return bits_data; 514 514 + } 515 515 + 516 516 + return -EBADMSG; 517 517 + } 783 518 784 519 /* 785 520 * ------------------- calc_ecc[] bit wise -----------|--13 bits--| ··· 822 493 * uint64_t array and error offset indexes are populated in err_idx 823 494 * array 824 495 */ 825 825 - for (i = 0; i < 8; i++) { 826 826 - if (i == 4) { 827 827 - err_idx[4] = ((ecc_data[1] & 0x1) << 12) | ecc_data[0]; 828 828 - ecc_data[1] >>= 1; 829 829 - continue; 830 830 - } 831 831 - err_idx[i] = (ecc_data[i/4] & 0x1FFF); 832 832 - ecc_data[i/4] >>= 13; 833 833 - } 496 496 + ecc1 = readl(FSMC_NAND_REG(regs, bank, ECC1)); 497 497 + ecc2 = readl(FSMC_NAND_REG(regs, bank, ECC2)); 498 498 + ecc3 = readl(FSMC_NAND_REG(regs, bank, ECC3)); 499 499 + ecc4 = readl(FSMC_NAND_REG(regs, bank, STS)); 834 500 835 835 - num_err = (readl(&regs->bank_regs[bank].sts) >> 10) & 0xF; 836 836 - 837 837 - if (num_err == 0xF) 838 838 - return -EBADMSG; 501 501 + err_idx[0] = (ecc1 >> 0) & 0x1FFF; 502 502 + err_idx[1] = (ecc1 >> 13) & 0x1FFF; 503 503 + err_idx[2] = (((ecc2 >> 0) & 0x7F) << 6) | ((ecc1 >> 26) & 0x3F); 504 504 + err_idx[3] = (ecc2 >> 7) & 0x1FFF; 505 505 + err_idx[4] = (((ecc3 >> 0) & 0x1) << 12) | ((ecc2 >> 20) & 0xFFF); 506 506 + err_idx[5] = (ecc3 >> 1) & 0x1FFF; 507 507 + err_idx[6] = (ecc3 >> 14) & 0x1FFF; 508 508 + err_idx[7] = (((ecc4 >> 16) & 0xFF) << 5) | ((ecc3 >> 27) & 0x1F); 839 509 840 510 i = 0; 841 511 while (num_err--) { 842 512 change_bit(0, (unsigned long *)&err_idx[i]); 843 513 change_bit(1, (unsigned long *)&err_idx[i]); 844 514 845 845 - if (err_idx[i] <= 512 * 8) { 515 515 + if (err_idx[i] < chip->ecc.size * 8) { 846 516 change_bit(err_idx[i], (unsigned long *)dat); 847 517 i++; 848 518 } 849 519 } 850 520 return i; 851 521 } 522 522 + 523 523 + static bool filter(struct dma_chan *chan, void *slave) 524 524 + { 525 525 + chan->private = slave; 526 526 + return true; 527 527 + } 528 528 + 529 529 + #ifdef CONFIG_OF 530 530 + static int __devinit fsmc_nand_probe_config_dt(struct platform_device *pdev, 531 531 + struct device_node *np) 532 532 + { 533 533 + struct fsmc_nand_platform_data *pdata = dev_get_platdata(&pdev->dev); 534 534 + u32 val; 535 535 + 536 536 + /* Set default NAND width to 8 bits */ 537 537 + pdata->width = 8; 538 538 + if (!of_property_read_u32(np, "bank-width", &val)) { 539 539 + if (val == 2) { 540 540 + pdata->width = 16; 541 541 + } else if (val != 1) { 542 542 + dev_err(&pdev->dev, "invalid bank-width %u\n", val); 543 543 + return -EINVAL; 544 544 + } 545 545 + } 546 546 + of_property_read_u32(np, "st,ale-off", &pdata->ale_off); 547 547 + of_property_read_u32(np, "st,cle-off", &pdata->cle_off); 548 548 + if (of_get_property(np, "nand-skip-bbtscan", NULL)) 549 549 + pdata->options = NAND_SKIP_BBTSCAN; 550 550 + 551 551 + return 0; 552 552 + } 553 553 + #else 554 554 + static int __devinit fsmc_nand_probe_config_dt(struct platform_device *pdev, 555 555 + struct device_node *np) 556 556 + { 557 557 + return -ENOSYS; 558 558 + } 559 559 + #endif 852 560 853 561 /* 854 562 * fsmc_nand_probe - Probe function ··· 894 528 static int __init fsmc_nand_probe(struct platform_device *pdev) 895 529 { 896 530 struct fsmc_nand_platform_data *pdata = dev_get_platdata(&pdev->dev); 531 531 + struct device_node __maybe_unused *np = pdev->dev.of_node; 532 532 + struct mtd_part_parser_data ppdata = {}; 897 533 struct fsmc_nand_data *host; 898 534 struct mtd_info *mtd; 899 535 struct nand_chip *nand; 900 900 - struct fsmc_regs *regs; 901 536 struct resource *res; 537 537 + dma_cap_mask_t mask; 902 538 int ret = 0; 903 539 u32 pid; 904 540 int i; 541 541 + 542 542 + if (np) { 543 543 + pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 544 544 + pdev->dev.platform_data = pdata; 545 545 + ret = fsmc_nand_probe_config_dt(pdev, np); 546 546 + if (ret) { 547 547 + dev_err(&pdev->dev, "no platform data\n"); 548 548 + return -ENODEV; 549 549 + } 550 550 + } 905 551 906 552 if (!pdata) { 907 553 dev_err(&pdev->dev, "platform data is NULL\n"); ··· 921 543 } 922 544 923 545 /* Allocate memory for the device structure (and zero it) */ 924 924 - host = kzalloc(sizeof(*host), GFP_KERNEL); 546 546 + host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL); 925 547 if (!host) { 926 548 dev_err(&pdev->dev, "failed to allocate device structure\n"); 927 549 return -ENOMEM; 928 550 } 929 551 930 552 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "nand_data"); 931 931 - if (!res) { 932 932 - ret = -EIO; 933 933 - goto err_probe1; 553 553 + if (!res) 554 554 + return -EINVAL; 555 555 + 556 556 + if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res), 557 557 + pdev->name)) { 558 558 + dev_err(&pdev->dev, "Failed to get memory data resourse\n"); 559 559 + return -ENOENT; 934 560 } 935 561 936 936 - host->resdata = request_mem_region(res->start, resource_size(res), 937 937 - pdev->name); 938 938 - if (!host->resdata) { 939 939 - ret = -EIO; 940 940 - goto err_probe1; 941 941 - } 942 942 - 943 943 - host->data_va = ioremap(res->start, resource_size(res)); 562 562 + host->data_pa = (dma_addr_t)res->start; 563 563 + host->data_va = devm_ioremap(&pdev->dev, res->start, 564 564 + resource_size(res)); 944 565 if (!host->data_va) { 945 945 - ret = -EIO; 946 946 - goto err_probe1; 566 566 + dev_err(&pdev->dev, "data ioremap failed\n"); 567 567 + return -ENOMEM; 947 568 } 948 569 949 949 - host->resaddr = request_mem_region(res->start + PLAT_NAND_ALE, 950 950 - resource_size(res), pdev->name); 951 951 - if (!host->resaddr) { 952 952 - ret = -EIO; 953 953 - goto err_probe1; 570 570 + if (!devm_request_mem_region(&pdev->dev, res->start + pdata->ale_off, 571 571 + resource_size(res), pdev->name)) { 572 572 + dev_err(&pdev->dev, "Failed to get memory ale resourse\n"); 573 573 + return -ENOENT; 954 574 } 955 575 956 956 - host->addr_va = ioremap(res->start + PLAT_NAND_ALE, resource_size(res)); 576 576 + host->addr_va = devm_ioremap(&pdev->dev, res->start + pdata->ale_off, 577 577 + resource_size(res)); 957 578 if (!host->addr_va) { 958 958 - ret = -EIO; 959 959 - goto err_probe1; 579 579 + dev_err(&pdev->dev, "ale ioremap failed\n"); 580 580 + return -ENOMEM; 960 581 } 961 582 962 962 - host->rescmd = request_mem_region(res->start + PLAT_NAND_CLE, 963 963 - resource_size(res), pdev->name); 964 964 - if (!host->rescmd) { 965 965 - ret = -EIO; 966 966 - goto err_probe1; 583 583 + if (!devm_request_mem_region(&pdev->dev, res->start + pdata->cle_off, 584 584 + resource_size(res), pdev->name)) { 585 585 + dev_err(&pdev->dev, "Failed to get memory cle resourse\n"); 586 586 + return -ENOENT; 967 587 } 968 588 969 969 - host->cmd_va = ioremap(res->start + PLAT_NAND_CLE, resource_size(res)); 589 589 + host->cmd_va = devm_ioremap(&pdev->dev, res->start + pdata->cle_off, 590 590 + resource_size(res)); 970 591 if (!host->cmd_va) { 971 971 - ret = -EIO; 972 972 - goto err_probe1; 592 592 + dev_err(&pdev->dev, "ale ioremap failed\n"); 593 593 + return -ENOMEM; 973 594 } 974 595 975 596 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fsmc_regs"); 976 976 - if (!res) { 977 977 - ret = -EIO; 978 978 - goto err_probe1; 597 597 + if (!res) 598 598 + return -EINVAL; 599 599 + 600 600 + if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res), 601 601 + pdev->name)) { 602 602 + dev_err(&pdev->dev, "Failed to get memory regs resourse\n"); 603 603 + return -ENOENT; 979 604 } 980 605 981 981 - host->resregs = request_mem_region(res->start, resource_size(res), 982 982 - pdev->name); 983 983 - if (!host->resregs) { 984 984 - ret = -EIO; 985 985 - goto err_probe1; 986 986 - } 987 987 - 988 988 - host->regs_va = ioremap(res->start, resource_size(res)); 606 606 + host->regs_va = devm_ioremap(&pdev->dev, res->start, 607 607 + resource_size(res)); 989 608 if (!host->regs_va) { 990 990 - ret = -EIO; 991 991 - goto err_probe1; 609 609 + dev_err(&pdev->dev, "regs ioremap failed\n"); 610 610 + return -ENOMEM; 992 611 } 993 612 994 613 host->clk = clk_get(&pdev->dev, NULL); 995 614 if (IS_ERR(host->clk)) { 996 615 dev_err(&pdev->dev, "failed to fetch block clock\n"); 997 997 - ret = PTR_ERR(host->clk); 998 998 - host->clk = NULL; 999 999 - goto err_probe1; 616 616 + return PTR_ERR(host->clk); 1000 617 } 1001 618 1002 619 ret = clk_enable(host->clk); 1003 620 if (ret) 1004 1004 - goto err_probe1; 621 621 + goto err_clk_enable; 1005 622 1006 623 /* 1007 624 * This device ID is actually a common AMBA ID as used on the ··· 1012 639 1013 640 host->bank = pdata->bank; 1014 641 host->select_chip = pdata->select_bank; 1015 1015 - regs = host->regs_va; 642 642 + host->partitions = pdata->partitions; 643 643 + host->nr_partitions = pdata->nr_partitions; 644 644 + host->dev = &pdev->dev; 645 645 + host->dev_timings = pdata->nand_timings; 646 646 + host->mode = pdata->mode; 647 647 + 648 648 + if (host->mode == USE_DMA_ACCESS) 649 649 + init_completion(&host->dma_access_complete); 1016 650 1017 651 /* Link all private pointers */ 1018 652 mtd = &host->mtd; ··· 1038 658 nand->ecc.size = 512; 1039 659 nand->options = pdata->options; 1040 660 nand->select_chip = fsmc_select_chip; 661 661 + nand->badblockbits = 7; 1041 662 1042 663 if (pdata->width == FSMC_NAND_BW16) 1043 664 nand->options |= NAND_BUSWIDTH_16; 1044 665 1045 1045 - fsmc_nand_setup(regs, host->bank, nand->options & NAND_BUSWIDTH_16); 666 666 + switch (host->mode) { 667 667 + case USE_DMA_ACCESS: 668 668 + dma_cap_zero(mask); 669 669 + dma_cap_set(DMA_MEMCPY, mask); 670 670 + host->read_dma_chan = dma_request_channel(mask, filter, 671 671 + pdata->read_dma_priv); 672 672 + if (!host->read_dma_chan) { 673 673 + dev_err(&pdev->dev, "Unable to get read dma channel\n"); 674 674 + goto err_req_read_chnl; 675 675 + } 676 676 + host->write_dma_chan = dma_request_channel(mask, filter, 677 677 + pdata->write_dma_priv); 678 678 + if (!host->write_dma_chan) { 679 679 + dev_err(&pdev->dev, "Unable to get write dma channel\n"); 680 680 + goto err_req_write_chnl; 681 681 + } 682 682 + nand->read_buf = fsmc_read_buf_dma; 683 683 + nand->write_buf = fsmc_write_buf_dma; 684 684 + break; 685 685 + 686 686 + default: 687 687 + case USE_WORD_ACCESS: 688 688 + nand->read_buf = fsmc_read_buf; 689 689 + nand->write_buf = fsmc_write_buf; 690 690 + break; 691 691 + } 692 692 + 693 693 + fsmc_nand_setup(host->regs_va, host->bank, 694 694 + nand->options & NAND_BUSWIDTH_16, 695 695 + host->dev_timings); 1046 696 1047 697 if (AMBA_REV_BITS(host->pid) >= 8) { 1048 698 nand->ecc.read_page = fsmc_read_page_hwecc; 1049 699 nand->ecc.calculate = fsmc_read_hwecc_ecc4; 1050 1050 - nand->ecc.correct = fsmc_correct_data; 700 700 + nand->ecc.correct = fsmc_bch8_correct_data; 1051 701 nand->ecc.bytes = 13; 702 702 + nand->ecc.strength = 8; 1052 703 } else { 1053 704 nand->ecc.calculate = fsmc_read_hwecc_ecc1; 1054 705 nand->ecc.correct = nand_correct_data; 1055 706 nand->ecc.bytes = 3; 707 707 + nand->ecc.strength = 1; 1056 708 } 1057 709 1058 710 /* ··· 1093 681 if (nand_scan_ident(&host->mtd, 1, NULL)) { 1094 682 ret = -ENXIO; 1095 683 dev_err(&pdev->dev, "No NAND Device found!\n"); 1096 1096 - goto err_probe; 684 684 + goto err_scan_ident; 1097 685 } 1098 686 1099 687 if (AMBA_REV_BITS(host->pid) >= 8) { 1100 1100 - if (host->mtd.writesize == 512) { 1101 1101 - nand->ecc.layout = &fsmc_ecc4_sp_layout; 688 688 + switch (host->mtd.oobsize) { 689 689 + case 16: 690 690 + nand->ecc.layout = &fsmc_ecc4_16_layout; 1102 691 host->ecc_place = &fsmc_ecc4_sp_place; 1103 1103 - } else { 1104 1104 - nand->ecc.layout = &fsmc_ecc4_lp_layout; 692 692 + break; 693 693 + case 64: 694 694 + nand->ecc.layout = &fsmc_ecc4_64_layout; 1105 695 host->ecc_place = &fsmc_ecc4_lp_place; 696 696 + break; 697 697 + case 128: 698 698 + nand->ecc.layout = &fsmc_ecc4_128_layout; 699 699 + host->ecc_place = &fsmc_ecc4_lp_place; 700 700 + break; 701 701 + case 224: 702 702 + nand->ecc.layout = &fsmc_ecc4_224_layout; 703 703 + host->ecc_place = &fsmc_ecc4_lp_place; 704 704 + break; 705 705 + case 256: 706 706 + nand->ecc.layout = &fsmc_ecc4_256_layout; 707 707 + host->ecc_place = &fsmc_ecc4_lp_place; 708 708 + break; 709 709 + default: 710 710 + printk(KERN_WARNING "No oob scheme defined for " 711 711 + "oobsize %d\n", mtd->oobsize); 712 712 + BUG(); 1106 713 } 1107 714 } else { 1108 1108 - nand->ecc.layout = &fsmc_ecc1_layout; 715 715 + switch (host->mtd.oobsize) { 716 716 + case 16: 717 717 + nand->ecc.layout = &fsmc_ecc1_16_layout; 718 718 + break; 719 719 + case 64: 720 720 + nand->ecc.layout = &fsmc_ecc1_64_layout; 721 721 + break; 722 722 + case 128: 723 723 + nand->ecc.layout = &fsmc_ecc1_128_layout; 724 724 + break; 725 725 + default: 726 726 + printk(KERN_WARNING "No oob scheme defined for " 727 727 + "oobsize %d\n", mtd->oobsize); 728 728 + BUG(); 729 729 + } 1109 730 } 1110 731 1111 732 /* Second stage of scan to fill MTD data-structures */ ··· 1158 713 * Check for partition info passed 1159 714 */ 1160 715 host->mtd.name = "nand"; 1161 1161 - ret = mtd_device_parse_register(&host->mtd, NULL, 0, 1162 1162 - host->mtd.size <= 0x04000000 ? 1163 1163 - partition_info_16KB_blk : 1164 1164 - partition_info_128KB_blk, 1165 1165 - host->mtd.size <= 0x04000000 ? 1166 1166 - ARRAY_SIZE(partition_info_16KB_blk) : 1167 1167 - ARRAY_SIZE(partition_info_128KB_blk)); 716 716 + ppdata.of_node = np; 717 717 + ret = mtd_device_parse_register(&host->mtd, NULL, &ppdata, 718 718 + host->partitions, host->nr_partitions); 1168 719 if (ret) 1169 720 goto err_probe; 1170 721 ··· 1169 728 return 0; 1170 729 1171 730 err_probe: 731 731 + err_scan_ident: 732 732 + if (host->mode == USE_DMA_ACCESS) 733 733 + dma_release_channel(host->write_dma_chan); 734 734 + err_req_write_chnl: 735 735 + if (host->mode == USE_DMA_ACCESS) 736 736 + dma_release_channel(host->read_dma_chan); 737 737 + err_req_read_chnl: 1172 738 clk_disable(host->clk); 1173 1173 - err_probe1: 1174 1174 - if (host->clk) 1175 1175 - clk_put(host->clk); 1176 1176 - if (host->regs_va) 1177 1177 - iounmap(host->regs_va); 1178 1178 - if (host->resregs) 1179 1179 - release_mem_region(host->resregs->start, 1180 1180 - resource_size(host->resregs)); 1181 1181 - if (host->cmd_va) 1182 1182 - iounmap(host->cmd_va); 1183 1183 - if (host->rescmd) 1184 1184 - release_mem_region(host->rescmd->start, 1185 1185 - resource_size(host->rescmd)); 1186 1186 - if (host->addr_va) 1187 1187 - iounmap(host->addr_va); 1188 1188 - if (host->resaddr) 1189 1189 - release_mem_region(host->resaddr->start, 1190 1190 - resource_size(host->resaddr)); 1191 1191 - if (host->data_va) 1192 1192 - iounmap(host->data_va); 1193 1193 - if (host->resdata) 1194 1194 - release_mem_region(host->resdata->start, 1195 1195 - resource_size(host->resdata)); 1196 1196 - 1197 1197 - kfree(host); 739 739 + err_clk_enable: 740 740 + clk_put(host->clk); 1198 741 return ret; 1199 742 } 1200 743 ··· 1193 768 1194 769 if (host) { 1195 770 nand_release(&host->mtd); 771 771 + 772 772 + if (host->mode == USE_DMA_ACCESS) { 773 773 + dma_release_channel(host->write_dma_chan); 774 774 + dma_release_channel(host->read_dma_chan); 775 775 + } 1196 776 clk_disable(host->clk); 1197 777 clk_put(host->clk); 1198 1198 - 1199 1199 - iounmap(host->regs_va); 1200 1200 - release_mem_region(host->resregs->start, 1201 1201 - resource_size(host->resregs)); 1202 1202 - iounmap(host->cmd_va); 1203 1203 - release_mem_region(host->rescmd->start, 1204 1204 - resource_size(host->rescmd)); 1205 1205 - iounmap(host->addr_va); 1206 1206 - release_mem_region(host->resaddr->start, 1207 1207 - resource_size(host->resaddr)); 1208 1208 - iounmap(host->data_va); 1209 1209 - release_mem_region(host->resdata->start, 1210 1210 - resource_size(host->resdata)); 1211 1211 - 1212 1212 - kfree(host); 1213 778 } 779 779 + 1214 780 return 0; 1215 781 } 1216 782 ··· 1217 801 static int fsmc_nand_resume(struct device *dev) 1218 802 { 1219 803 struct fsmc_nand_data *host = dev_get_drvdata(dev); 1220 1220 - if (host) 804 804 + if (host) { 1221 805 clk_enable(host->clk); 806 806 + fsmc_nand_setup(host->regs_va, host->bank, 807 807 + host->nand.options & NAND_BUSWIDTH_16, 808 808 + host->dev_timings); 809 809 + } 1222 810 return 0; 1223 811 } 1224 812 1225 1225 - static const struct dev_pm_ops fsmc_nand_pm_ops = { 1226 1226 - .suspend = fsmc_nand_suspend, 1227 1227 - .resume = fsmc_nand_resume, 813 813 + static SIMPLE_DEV_PM_OPS(fsmc_nand_pm_ops, fsmc_nand_suspend, fsmc_nand_resume); 814 814 + #endif 815 815 + 816 816 + #ifdef CONFIG_OF 817 817 + static const struct of_device_id fsmc_nand_id_table[] = { 818 818 + { .compatible = "st,spear600-fsmc-nand" }, 819 819 + {} 1228 820 }; 821 821 + MODULE_DEVICE_TABLE(of, fsmc_nand_id_table); 1229 822 #endif 1230 823 1231 824 static struct platform_driver fsmc_nand_driver = { ··· 1242 817 .driver = { 1243 818 .owner = THIS_MODULE, 1244 819 .name = "fsmc-nand", 820 820 + .of_match_table = of_match_ptr(fsmc_nand_id_table), 1245 821 #ifdef CONFIG_PM 1246 822 .pm = &fsmc_nand_pm_ops, 1247 823 #endif

+18 -8

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

reviewed

··· 848 848 849 849 sg_init_one(sgl, this->cmd_buffer, this->command_length); 850 850 dma_map_sg(this->dev, sgl, 1, DMA_TO_DEVICE); 851 851 - desc = dmaengine_prep_slave_sg(channel, sgl, 1, DMA_MEM_TO_DEV, 1); 851 851 + desc = dmaengine_prep_slave_sg(channel, 852 852 + sgl, 1, DMA_MEM_TO_DEV, 853 853 + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 854 854 + 852 855 if (!desc) { 853 856 pr_err("step 2 error\n"); 854 857 return -1; ··· 892 889 /* [2] send DMA request */ 893 890 prepare_data_dma(this, DMA_TO_DEVICE); 894 891 desc = dmaengine_prep_slave_sg(channel, &this->data_sgl, 895 895 - 1, DMA_MEM_TO_DEV, 1); 892 892 + 1, DMA_MEM_TO_DEV, 893 893 + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 896 894 if (!desc) { 897 895 pr_err("step 2 error\n"); 898 896 return -1; ··· 929 925 /* [2] : send DMA request */ 930 926 prepare_data_dma(this, DMA_FROM_DEVICE); 931 927 desc = dmaengine_prep_slave_sg(channel, &this->data_sgl, 932 932 - 1, DMA_DEV_TO_MEM, 1); 928 928 + 1, DMA_DEV_TO_MEM, 929 929 + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 933 930 if (!desc) { 934 931 pr_err("step 2 error\n"); 935 932 return -1; ··· 975 970 pio[4] = payload; 976 971 pio[5] = auxiliary; 977 972 978 978 - desc = dmaengine_prep_slave_sg(channel, (struct scatterlist *)pio, 979 979 - ARRAY_SIZE(pio), DMA_TRANS_NONE, 0); 973 973 + desc = dmaengine_prep_slave_sg(channel, 974 974 + (struct scatterlist *)pio, 975 975 + ARRAY_SIZE(pio), DMA_TRANS_NONE, 976 976 + DMA_CTRL_ACK); 980 977 if (!desc) { 981 978 pr_err("step 2 error\n"); 982 979 return -1; ··· 1042 1035 pio[5] = auxiliary; 1043 1036 desc = dmaengine_prep_slave_sg(channel, 1044 1037 (struct scatterlist *)pio, 1045 1045 - ARRAY_SIZE(pio), DMA_TRANS_NONE, 1); 1038 1038 + ARRAY_SIZE(pio), DMA_TRANS_NONE, 1039 1039 + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 1046 1040 if (!desc) { 1047 1041 pr_err("step 2 error\n"); 1048 1042 return -1; ··· 1060 1052 | BF_GPMI_CTRL0_ADDRESS(address) 1061 1053 | BF_GPMI_CTRL0_XFER_COUNT(geo->page_size); 1062 1054 pio[1] = 0; 1055 1055 + pio[2] = 0; /* clear GPMI_HW_GPMI_ECCCTRL, disable the BCH. */ 1063 1056 desc = dmaengine_prep_slave_sg(channel, 1064 1064 - (struct scatterlist *)pio, 2, 1065 1065 - DMA_TRANS_NONE, 1); 1057 1057 + (struct scatterlist *)pio, 3, 1058 1058 + DMA_TRANS_NONE, 1059 1059 + DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 1066 1060 if (!desc) { 1067 1061 pr_err("step 3 error\n"); 1068 1062 return -1;

+7 -7

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

reviewed

··· 1124 1124 chip->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1); 1125 1125 1126 1126 /* Do we have a flash based bad block table ? */ 1127 1127 - if (chip->options & NAND_BBT_USE_FLASH) 1127 1127 + if (chip->bbt_options & NAND_BBT_USE_FLASH) 1128 1128 ret = nand_update_bbt(mtd, ofs); 1129 1129 else { 1130 1130 chipnr = (int)(ofs >> chip->chip_shift); ··· 1155 1155 return ret; 1156 1156 } 1157 1157 1158 1158 - static int __devinit nand_boot_set_geometry(struct gpmi_nand_data *this) 1158 1158 + static int nand_boot_set_geometry(struct gpmi_nand_data *this) 1159 1159 { 1160 1160 struct boot_rom_geometry *geometry = &this->rom_geometry; 1161 1161 ··· 1182 1182 } 1183 1183 1184 1184 static const char *fingerprint = "STMP"; 1185 1185 - static int __devinit mx23_check_transcription_stamp(struct gpmi_nand_data *this) 1185 1185 + static int mx23_check_transcription_stamp(struct gpmi_nand_data *this) 1186 1186 { 1187 1187 struct boot_rom_geometry *rom_geo = &this->rom_geometry; 1188 1188 struct device *dev = this->dev; ··· 1239 1239 } 1240 1240 1241 1241 /* Writes a transcription stamp. */ 1242 1242 - static int __devinit mx23_write_transcription_stamp(struct gpmi_nand_data *this) 1242 1242 + static int mx23_write_transcription_stamp(struct gpmi_nand_data *this) 1243 1243 { 1244 1244 struct device *dev = this->dev; 1245 1245 struct boot_rom_geometry *rom_geo = &this->rom_geometry; ··· 1322 1322 return 0; 1323 1323 } 1324 1324 1325 1325 - static int __devinit mx23_boot_init(struct gpmi_nand_data *this) 1325 1325 + static int mx23_boot_init(struct gpmi_nand_data *this) 1326 1326 { 1327 1327 struct device *dev = this->dev; 1328 1328 struct nand_chip *chip = &this->nand; ··· 1391 1391 return 0; 1392 1392 } 1393 1393 1394 1394 - static int __devinit nand_boot_init(struct gpmi_nand_data *this) 1394 1394 + static int nand_boot_init(struct gpmi_nand_data *this) 1395 1395 { 1396 1396 nand_boot_set_geometry(this); 1397 1397 ··· 1401 1401 return 0; 1402 1402 } 1403 1403 1404 1404 - static int __devinit gpmi_set_geometry(struct gpmi_nand_data *this) 1404 1404 + static int gpmi_set_geometry(struct gpmi_nand_data *this) 1405 1405 { 1406 1406 int ret; 1407 1407

+1 -1

drivers/mtd/nand/gpmi-nand/gpmi-nand.h

reviewed

··· 20 20 #include <linux/mtd/nand.h> 21 21 #include <linux/platform_device.h> 22 22 #include <linux/dma-mapping.h> 23 23 - #include <mach/dma.h> 23 23 + #include <linux/fsl/mxs-dma.h> 24 24 25 25 struct resources { 26 26 void *gpmi_regs;

+2 -2

drivers/mtd/nand/h1910.c

reviewed

··· 135 135 } 136 136 137 137 /* Register the partitions */ 138 138 - mtd_device_parse_register(h1910_nand_mtd, NULL, 0, 139 139 - partition_info, NUM_PARTITIONS); 138 138 + mtd_device_parse_register(h1910_nand_mtd, NULL, NULL, partition_info, 139 139 + NUM_PARTITIONS); 140 140 141 141 /* Return happy */ 142 142 return 0;

+8 -3

drivers/mtd/nand/jz4740_nand.c

reviewed

··· 332 332 chip->ecc.mode = NAND_ECC_HW_OOB_FIRST; 333 333 chip->ecc.size = 512; 334 334 chip->ecc.bytes = 9; 335 335 + chip->ecc.strength = 2; 336 336 + /* 337 337 + * FIXME: ecc_strength value of 2 bits per 512 bytes of data is a 338 338 + * conservative guess, given 9 ecc bytes and reed-solomon alg. 339 339 + */ 335 340 336 341 if (pdata) 337 342 chip->ecc.layout = pdata->ecc_layout; ··· 372 367 goto err_gpio_free; 373 368 } 374 369 375 375 - ret = mtd_device_parse_register(mtd, NULL, 0, 376 376 - pdata ? pdata->partitions : NULL, 377 377 - pdata ? pdata->num_partitions : 0); 370 370 + ret = mtd_device_parse_register(mtd, NULL, NULL, 371 371 + pdata ? pdata->partitions : NULL, 372 372 + pdata ? pdata->num_partitions : 0); 378 373 379 374 if (ret) { 380 375 dev_err(&pdev->dev, "Failed to add mtd device\n");

+9 -2

drivers/mtd/nand/mxc_nand.c

reviewed

··· 1225 1225 goto escan; 1226 1226 } 1227 1227 1228 1228 + if (this->ecc.mode == NAND_ECC_HW) { 1229 1229 + if (nfc_is_v1()) 1230 1230 + this->ecc.strength = 1; 1231 1231 + else 1232 1232 + this->ecc.strength = (host->eccsize == 4) ? 4 : 8; 1233 1233 + } 1234 1234 + 1228 1235 /* Register the partitions */ 1229 1229 - mtd_device_parse_register(mtd, part_probes, 0, 1230 1230 - pdata->parts, pdata->nr_parts); 1236 1236 + mtd_device_parse_register(mtd, part_probes, NULL, pdata->parts, 1237 1237 + pdata->nr_parts); 1231 1238 1232 1239 platform_set_drvdata(pdev, host); 1233 1240

+99 -95

drivers/mtd/nand/nand_base.c

reviewed

··· 123 123 ret = -EINVAL; 124 124 } 125 125 126 126 - /* Do not allow past end of device */ 127 127 - if (ofs + len > mtd->size) { 128 128 - pr_debug("%s: past end of device\n", __func__); 129 129 - ret = -EINVAL; 130 130 - } 131 131 - 132 126 return ret; 133 127 } 134 128 ··· 332 338 */ 333 339 static int nand_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip) 334 340 { 335 335 - int page, chipnr, res = 0; 341 341 + int page, chipnr, res = 0, i = 0; 336 342 struct nand_chip *chip = mtd->priv; 337 343 u16 bad; 338 344 ··· 350 356 chip->select_chip(mtd, chipnr); 351 357 } 352 358 353 353 - if (chip->options & NAND_BUSWIDTH_16) { 354 354 - chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos & 0xFE, 355 355 - page); 356 356 - bad = cpu_to_le16(chip->read_word(mtd)); 357 357 - if (chip->badblockpos & 0x1) 358 358 - bad >>= 8; 359 359 - else 360 360 - bad &= 0xFF; 361 361 - } else { 362 362 - chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos, page); 363 363 - bad = chip->read_byte(mtd); 364 364 - } 359 359 + do { 360 360 + if (chip->options & NAND_BUSWIDTH_16) { 361 361 + chip->cmdfunc(mtd, NAND_CMD_READOOB, 362 362 + chip->badblockpos & 0xFE, page); 363 363 + bad = cpu_to_le16(chip->read_word(mtd)); 364 364 + if (chip->badblockpos & 0x1) 365 365 + bad >>= 8; 366 366 + else 367 367 + bad &= 0xFF; 368 368 + } else { 369 369 + chip->cmdfunc(mtd, NAND_CMD_READOOB, chip->badblockpos, 370 370 + page); 371 371 + bad = chip->read_byte(mtd); 372 372 + } 365 373 366 366 - if (likely(chip->badblockbits == 8)) 367 367 - res = bad != 0xFF; 368 368 - else 369 369 - res = hweight8(bad) < chip->badblockbits; 374 374 + if (likely(chip->badblockbits == 8)) 375 375 + res = bad != 0xFF; 376 376 + else 377 377 + res = hweight8(bad) < chip->badblockbits; 378 378 + ofs += mtd->writesize; 379 379 + page = (int)(ofs >> chip->page_shift) & chip->pagemask; 380 380 + i++; 381 381 + } while (!res && i < 2 && (chip->bbt_options & NAND_BBT_SCAN2NDPAGE)); 370 382 371 383 if (getchip) 372 384 nand_release_device(mtd); ··· 386 386 * @ofs: offset from device start 387 387 * 388 388 * This is the default implementation, which can be overridden by a hardware 389 389 - * specific driver. 389 389 + * specific driver. We try operations in the following order, according to our 390 390 + * bbt_options (NAND_BBT_NO_OOB_BBM and NAND_BBT_USE_FLASH): 391 391 + * (1) erase the affected block, to allow OOB marker to be written cleanly 392 392 + * (2) update in-memory BBT 393 393 + * (3) write bad block marker to OOB area of affected block 394 394 + * (4) update flash-based BBT 395 395 + * Note that we retain the first error encountered in (3) or (4), finish the 396 396 + * procedures, and dump the error in the end. 390 397 */ 391 398 static int nand_default_block_markbad(struct mtd_info *mtd, loff_t ofs) 392 399 { 393 400 struct nand_chip *chip = mtd->priv; 394 401 uint8_t buf[2] = { 0, 0 }; 395 395 - int block, ret, i = 0; 402 402 + int block, res, ret = 0, i = 0; 403 403 + int write_oob = !(chip->bbt_options & NAND_BBT_NO_OOB_BBM); 396 404 397 397 - if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) 398 398 - ofs += mtd->erasesize - mtd->writesize; 405 405 + if (write_oob) { 406 406 + struct erase_info einfo; 407 407 + 408 408 + /* Attempt erase before marking OOB */ 409 409 + memset(&einfo, 0, sizeof(einfo)); 410 410 + einfo.mtd = mtd; 411 411 + einfo.addr = ofs; 412 412 + einfo.len = 1 << chip->phys_erase_shift; 413 413 + nand_erase_nand(mtd, &einfo, 0); 414 414 + } 399 415 400 416 /* Get block number */ 401 417 block = (int)(ofs >> chip->bbt_erase_shift); 418 418 + /* Mark block bad in memory-based BBT */ 402 419 if (chip->bbt) 403 420 chip->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1); 404 421 405 405 - /* Do we have a flash based bad block table? */ 406 406 - if (chip->bbt_options & NAND_BBT_USE_FLASH) 407 407 - ret = nand_update_bbt(mtd, ofs); 408 408 - else { 422 422 + /* Write bad block marker to OOB */ 423 423 + if (write_oob) { 409 424 struct mtd_oob_ops ops; 425 425 + loff_t wr_ofs = ofs; 410 426 411 427 nand_get_device(chip, mtd, FL_WRITING); 412 428 413 413 - /* 414 414 - * Write to first two pages if necessary. If we write to more 415 415 - * than one location, the first error encountered quits the 416 416 - * procedure. We write two bytes per location, so we dont have 417 417 - * to mess with 16 bit access. 418 418 - */ 419 419 - ops.len = ops.ooblen = 2; 420 429 ops.datbuf = NULL; 421 430 ops.oobbuf = buf; 422 422 - ops.ooboffs = chip->badblockpos & ~0x01; 431 431 + ops.ooboffs = chip->badblockpos; 432 432 + if (chip->options & NAND_BUSWIDTH_16) { 433 433 + ops.ooboffs &= ~0x01; 434 434 + ops.len = ops.ooblen = 2; 435 435 + } else { 436 436 + ops.len = ops.ooblen = 1; 437 437 + } 423 438 ops.mode = MTD_OPS_PLACE_OOB; 439 439 + 440 440 + /* Write to first/last page(s) if necessary */ 441 441 + if (chip->bbt_options & NAND_BBT_SCANLASTPAGE) 442 442 + wr_ofs += mtd->erasesize - mtd->writesize; 424 443 do { 425 425 - ret = nand_do_write_oob(mtd, ofs, &ops); 444 444 + res = nand_do_write_oob(mtd, wr_ofs, &ops); 445 445 + if (!ret) 446 446 + ret = res; 426 447 427 448 i++; 428 428 - ofs += mtd->writesize; 429 429 - } while (!ret && (chip->bbt_options & NAND_BBT_SCAN2NDPAGE) && 430 430 - i < 2); 449 449 + wr_ofs += mtd->writesize; 450 450 + } while ((chip->bbt_options & NAND_BBT_SCAN2NDPAGE) && i < 2); 431 451 432 452 nand_release_device(mtd); 433 453 } 454 454 + 455 455 + /* Update flash-based bad block table */ 456 456 + if (chip->bbt_options & NAND_BBT_USE_FLASH) { 457 457 + res = nand_update_bbt(mtd, ofs); 458 458 + if (!ret) 459 459 + ret = res; 460 460 + } 461 461 + 434 462 if (!ret) 435 463 mtd->ecc_stats.badblocks++; 436 464 ··· 1614 1586 struct mtd_oob_ops ops; 1615 1587 int ret; 1616 1588 1617 1617 - /* Do not allow reads past end of device */ 1618 1618 - if ((from + len) > mtd->size) 1619 1619 - return -EINVAL; 1620 1620 - if (!len) 1621 1621 - return 0; 1622 1622 - 1623 1589 nand_get_device(chip, mtd, FL_READING); 1624 1624 - 1625 1590 ops.len = len; 1626 1591 ops.datbuf = buf; 1627 1592 ops.oobbuf = NULL; 1628 1593 ops.mode = 0; 1629 1629 - 1630 1594 ret = nand_do_read_ops(mtd, from, &ops); 1631 1631 - 1632 1595 *retlen = ops.retlen; 1633 1633 - 1634 1596 nand_release_device(mtd); 1635 1635 - 1636 1597 return ret; 1637 1598 } 1638 1599 ··· 2310 2293 struct mtd_oob_ops ops; 2311 2294 int ret; 2312 2295 2313 2313 - /* Do not allow reads past end of device */ 2314 2314 - if ((to + len) > mtd->size) 2315 2315 - return -EINVAL; 2316 2316 - if (!len) 2317 2317 - return 0; 2318 2318 - 2319 2296 /* Wait for the device to get ready */ 2320 2297 panic_nand_wait(mtd, chip, 400); 2321 2298 ··· 2344 2333 struct mtd_oob_ops ops; 2345 2334 int ret; 2346 2335 2347 2347 - /* Do not allow reads past end of device */ 2348 2348 - if ((to + len) > mtd->size) 2349 2349 - return -EINVAL; 2350 2350 - if (!len) 2351 2351 - return 0; 2352 2352 - 2353 2336 nand_get_device(chip, mtd, FL_WRITING); 2354 2354 - 2355 2337 ops.len = len; 2356 2338 ops.datbuf = (uint8_t *)buf; 2357 2339 ops.oobbuf = NULL; 2358 2340 ops.mode = 0; 2359 2359 - 2360 2341 ret = nand_do_write_ops(mtd, to, &ops); 2361 2361 - 2362 2342 *retlen = ops.retlen; 2363 2363 - 2364 2343 nand_release_device(mtd); 2365 2365 - 2366 2344 return ret; 2367 2345 } 2368 2346 ··· 2550 2550 if (check_offs_len(mtd, instr->addr, instr->len)) 2551 2551 return -EINVAL; 2552 2552 2553 2553 - instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 2554 2554 - 2555 2553 /* Grab the lock and see if the device is available */ 2556 2554 nand_get_device(chip, mtd, FL_ERASING); 2557 2555 ··· 2713 2715 */ 2714 2716 static int nand_block_isbad(struct mtd_info *mtd, loff_t offs) 2715 2717 { 2716 2716 - /* Check for invalid offset */ 2717 2717 - if (offs > mtd->size) 2718 2718 - return -EINVAL; 2719 2719 - 2720 2718 return nand_block_checkbad(mtd, offs, 1, 0); 2721 2719 } 2722 2720 ··· 2851 2857 chip->read_byte(mtd) != 'F' || chip->read_byte(mtd) != 'I') 2852 2858 return 0; 2853 2859 2854 2854 - pr_info("ONFI flash detected\n"); 2855 2860 chip->cmdfunc(mtd, NAND_CMD_PARAM, 0, -1); 2856 2861 for (i = 0; i < 3; i++) { 2857 2862 chip->read_buf(mtd, (uint8_t *)p, sizeof(*p)); ··· 2891 2898 mtd->writesize = le32_to_cpu(p->byte_per_page); 2892 2899 mtd->erasesize = le32_to_cpu(p->pages_per_block) * mtd->writesize; 2893 2900 mtd->oobsize = le16_to_cpu(p->spare_bytes_per_page); 2894 2894 - chip->chipsize = (uint64_t)le32_to_cpu(p->blocks_per_lun) * mtd->erasesize; 2901 2901 + chip->chipsize = le32_to_cpu(p->blocks_per_lun); 2902 2902 + chip->chipsize *= (uint64_t)mtd->erasesize * p->lun_count; 2895 2903 *busw = 0; 2896 2904 if (le16_to_cpu(p->features) & 1) 2897 2905 *busw = NAND_BUSWIDTH_16; ··· 2901 2907 chip->options |= (NAND_NO_READRDY | 2902 2908 NAND_NO_AUTOINCR) & NAND_CHIPOPTIONS_MSK; 2903 2909 2910 2910 + pr_info("ONFI flash detected\n"); 2904 2911 return 1; 2905 2912 } 2906 2913 ··· 3233 3238 int i; 3234 3239 struct nand_chip *chip = mtd->priv; 3235 3240 3241 3241 + /* New bad blocks should be marked in OOB, flash-based BBT, or both */ 3242 3242 + BUG_ON((chip->bbt_options & NAND_BBT_NO_OOB_BBM) && 3243 3243 + !(chip->bbt_options & NAND_BBT_USE_FLASH)); 3244 3244 + 3236 3245 if (!(chip->options & NAND_OWN_BUFFERS)) 3237 3246 chip->buffers = kmalloc(sizeof(*chip->buffers), GFP_KERNEL); 3238 3247 if (!chip->buffers) ··· 3349 3350 if (!chip->ecc.size) 3350 3351 chip->ecc.size = 256; 3351 3352 chip->ecc.bytes = 3; 3353 3353 + chip->ecc.strength = 1; 3352 3354 break; 3353 3355 3354 3356 case NAND_ECC_SOFT_BCH: ··· 3384 3384 pr_warn("BCH ECC initialization failed!\n"); 3385 3385 BUG(); 3386 3386 } 3387 3387 + chip->ecc.strength = 3388 3388 + chip->ecc.bytes*8 / fls(8*chip->ecc.size); 3387 3389 break; 3388 3390 3389 3391 case NAND_ECC_NONE: ··· 3399 3397 chip->ecc.write_oob = nand_write_oob_std; 3400 3398 chip->ecc.size = mtd->writesize; 3401 3399 chip->ecc.bytes = 0; 3400 3400 + chip->ecc.strength = 0; 3402 3401 break; 3403 3402 3404 3403 default: ··· 3464 3461 mtd->type = MTD_NANDFLASH; 3465 3462 mtd->flags = (chip->options & NAND_ROM) ? MTD_CAP_ROM : 3466 3463 MTD_CAP_NANDFLASH; 3467 3467 - mtd->erase = nand_erase; 3468 3468 - mtd->point = NULL; 3469 3469 - mtd->unpoint = NULL; 3470 3470 - mtd->read = nand_read; 3471 3471 - mtd->write = nand_write; 3472 3472 - mtd->panic_write = panic_nand_write; 3473 3473 - mtd->read_oob = nand_read_oob; 3474 3474 - mtd->write_oob = nand_write_oob; 3475 3475 - mtd->sync = nand_sync; 3476 3476 - mtd->lock = NULL; 3477 3477 - mtd->unlock = NULL; 3478 3478 - mtd->suspend = nand_suspend; 3479 3479 - mtd->resume = nand_resume; 3480 3480 - mtd->block_isbad = nand_block_isbad; 3481 3481 - mtd->block_markbad = nand_block_markbad; 3464 3464 + mtd->_erase = nand_erase; 3465 3465 + mtd->_point = NULL; 3466 3466 + mtd->_unpoint = NULL; 3467 3467 + mtd->_read = nand_read; 3468 3468 + mtd->_write = nand_write; 3469 3469 + mtd->_panic_write = panic_nand_write; 3470 3470 + mtd->_read_oob = nand_read_oob; 3471 3471 + mtd->_write_oob = nand_write_oob; 3472 3472 + mtd->_sync = nand_sync; 3473 3473 + mtd->_lock = NULL; 3474 3474 + mtd->_unlock = NULL; 3475 3475 + mtd->_suspend = nand_suspend; 3476 3476 + mtd->_resume = nand_resume; 3477 3477 + mtd->_block_isbad = nand_block_isbad; 3478 3478 + mtd->_block_markbad = nand_block_markbad; 3482 3479 mtd->writebufsize = mtd->writesize; 3483 3480 3484 3484 - /* propagate ecc.layout to mtd_info */ 3481 3481 + /* propagate ecc info to mtd_info */ 3485 3482 mtd->ecclayout = chip->ecc.layout; 3483 3483 + mtd->ecc_strength = chip->ecc.strength * chip->ecc.steps; 3486 3484 3487 3485 /* Check, if we should skip the bad block table scan */ 3488 3486 if (chip->options & NAND_SKIP_BBTSCAN)

+1

drivers/mtd/nand/ndfc.c

reviewed

··· 179 179 chip->ecc.mode = NAND_ECC_HW; 180 180 chip->ecc.size = 256; 181 181 chip->ecc.bytes = 3; 182 182 + chip->ecc.strength = 1; 182 183 chip->priv = ndfc; 183 184 184 185 ndfc->mtd.priv = chip;

+3 -2

drivers/mtd/nand/omap2.c

reviewed

··· 1058 1058 (pdata->ecc_opt == OMAP_ECC_HAMMING_CODE_HW_ROMCODE)) { 1059 1059 info->nand.ecc.bytes = 3; 1060 1060 info->nand.ecc.size = 512; 1061 1061 + info->nand.ecc.strength = 1; 1061 1062 info->nand.ecc.calculate = omap_calculate_ecc; 1062 1063 info->nand.ecc.hwctl = omap_enable_hwecc; 1063 1064 info->nand.ecc.correct = omap_correct_data; ··· 1102 1101 goto out_release_mem_region; 1103 1102 } 1104 1103 1105 1105 - mtd_device_parse_register(&info->mtd, NULL, 0, 1106 1106 - pdata->parts, pdata->nr_parts); 1104 1104 + mtd_device_parse_register(&info->mtd, NULL, NULL, pdata->parts, 1105 1105 + pdata->nr_parts); 1107 1106 1108 1107 platform_set_drvdata(pdev, &info->mtd); 1109 1108

+2 -2

drivers/mtd/nand/orion_nand.c

reviewed

··· 129 129 } 130 130 131 131 mtd->name = "orion_nand"; 132 132 - ret = mtd_device_parse_register(mtd, NULL, 0, 133 133 - board->parts, board->nr_parts); 132 132 + ret = mtd_device_parse_register(mtd, NULL, NULL, board->parts, 133 133 + board->nr_parts); 134 134 if (ret) { 135 135 nand_release(mtd); 136 136 goto no_dev;

+3 -2

drivers/mtd/nand/plat_nand.c

reviewed

··· 99 99 } 100 100 101 101 err = mtd_device_parse_register(&data->mtd, 102 102 - pdata->chip.part_probe_types, 0, 103 103 - pdata->chip.partitions, pdata->chip.nr_partitions); 102 102 + pdata->chip.part_probe_types, NULL, 103 103 + pdata->chip.partitions, 104 104 + pdata->chip.nr_partitions); 104 105 105 106 if (!err) 106 107 return err;

+8 -10

drivers/mtd/nand/ppchameleonevb.c

reviewed

··· 275 275 ppchameleon_mtd->name = "ppchameleon-nand"; 276 276 277 277 /* Register the partitions */ 278 278 - mtd_device_parse_register(ppchameleon_mtd, NULL, 0, 279 279 - ppchameleon_mtd->size == NAND_SMALL_SIZE ? 280 280 - partition_info_me : 281 281 - partition_info_hi, 282 282 - NUM_PARTITIONS); 278 278 + mtd_device_parse_register(ppchameleon_mtd, NULL, NULL, 279 279 + ppchameleon_mtd->size == NAND_SMALL_SIZE ? 280 280 + partition_info_me : partition_info_hi, 281 281 + NUM_PARTITIONS); 283 282 284 283 nand_evb_init: 285 284 /**************************** ··· 364 365 ppchameleonevb_mtd->name = NAND_EVB_MTD_NAME; 365 366 366 367 /* Register the partitions */ 367 367 - mtd_device_parse_register(ppchameleonevb_mtd, NULL, 0, 368 368 - ppchameleon_mtd->size == NAND_SMALL_SIZE ? 369 369 - partition_info_me : 370 370 - partition_info_hi, 371 371 - NUM_PARTITIONS); 368 368 + mtd_device_parse_register(ppchameleonevb_mtd, NULL, NULL, 369 369 + ppchameleon_mtd->size == NAND_SMALL_SIZE ? 370 370 + partition_info_me : partition_info_hi, 371 371 + NUM_PARTITIONS); 372 372 373 373 /* Return happy */ 374 374 return 0;

+4 -2

drivers/mtd/nand/pxa3xx_nand.c

reviewed

··· 1002 1002 KEEP_CONFIG: 1003 1003 chip->ecc.mode = NAND_ECC_HW; 1004 1004 chip->ecc.size = host->page_size; 1005 1005 + chip->ecc.strength = 1; 1005 1006 1006 1007 chip->options = NAND_NO_AUTOINCR; 1007 1008 chip->options |= NAND_NO_READRDY; ··· 1229 1228 continue; 1230 1229 } 1231 1230 1232 1232 - ret = mtd_device_parse_register(info->host[cs]->mtd, NULL, 0, 1233 1233 - pdata->parts[cs], pdata->nr_parts[cs]); 1231 1231 + ret = mtd_device_parse_register(info->host[cs]->mtd, NULL, 1232 1232 + NULL, pdata->parts[cs], 1233 1233 + pdata->nr_parts[cs]); 1234 1234 if (!ret) 1235 1235 probe_success = 1; 1236 1236 }

+1

drivers/mtd/nand/r852.c

reviewed

··· 891 891 chip->ecc.mode = NAND_ECC_HW_SYNDROME; 892 892 chip->ecc.size = R852_DMA_LEN; 893 893 chip->ecc.bytes = SM_OOB_SIZE; 894 894 + chip->ecc.strength = 2; 894 895 chip->ecc.hwctl = r852_ecc_hwctl; 895 896 chip->ecc.calculate = r852_ecc_calculate; 896 897 chip->ecc.correct = r852_ecc_correct;

+1

drivers/mtd/nand/rtc_from4.c

reviewed

··· 527 527 this->ecc.mode = NAND_ECC_HW_SYNDROME; 528 528 this->ecc.size = 512; 529 529 this->ecc.bytes = 8; 530 530 + this->ecc.strength = 3; 530 531 /* return the status of extra status and ECC checks */ 531 532 this->errstat = rtc_from4_errstat; 532 533 /* set the nand_oobinfo to support FPGA H/W error detection */

+3 -2

drivers/mtd/nand/s3c2410.c

reviewed

··· 751 751 if (set) 752 752 mtd->mtd.name = set->name; 753 753 754 754 - return mtd_device_parse_register(&mtd->mtd, NULL, 0, 755 755 - set->partitions, set->nr_partitions); 754 754 + return mtd_device_parse_register(&mtd->mtd, NULL, NULL, 755 755 + set->partitions, set->nr_partitions); 756 756 } 757 757 758 758 /** ··· 823 823 chip->ecc.calculate = s3c2410_nand_calculate_ecc; 824 824 chip->ecc.correct = s3c2410_nand_correct_data; 825 825 chip->ecc.mode = NAND_ECC_HW; 826 826 + chip->ecc.strength = 1; 826 827 827 828 switch (info->cpu_type) { 828 829 case TYPE_S3C2410:

+80 -30

drivers/mtd/nand/sh_flctl.c

reviewed

··· 26 26 #include <linux/delay.h> 27 27 #include <linux/io.h> 28 28 #include <linux/platform_device.h> 29 29 + #include <linux/pm_runtime.h> 29 30 #include <linux/slab.h> 30 31 31 32 #include <linux/mtd/mtd.h> ··· 284 283 static void set_cmd_regs(struct mtd_info *mtd, uint32_t cmd, uint32_t flcmcdr_val) 285 284 { 286 285 struct sh_flctl *flctl = mtd_to_flctl(mtd); 287 287 - uint32_t flcmncr_val = readl(FLCMNCR(flctl)) & ~SEL_16BIT; 286 286 + uint32_t flcmncr_val = flctl->flcmncr_base & ~SEL_16BIT; 288 287 uint32_t flcmdcr_val, addr_len_bytes = 0; 289 288 290 289 /* Set SNAND bit if page size is 2048byte */ ··· 304 303 break; 305 304 case NAND_CMD_READ0: 306 305 case NAND_CMD_READOOB: 306 306 + case NAND_CMD_RNDOUT: 307 307 addr_len_bytes = flctl->rw_ADRCNT; 308 308 flcmdcr_val |= CDSRC_E; 309 309 if (flctl->chip.options & NAND_BUSWIDTH_16) ··· 322 320 break; 323 321 case NAND_CMD_READID: 324 322 flcmncr_val &= ~SNAND_E; 323 323 + flcmdcr_val |= CDSRC_E; 325 324 addr_len_bytes = ADRCNT_1; 326 325 break; 327 326 case NAND_CMD_STATUS: ··· 516 513 struct sh_flctl *flctl = mtd_to_flctl(mtd); 517 514 uint32_t read_cmd = 0; 518 515 516 516 + pm_runtime_get_sync(&flctl->pdev->dev); 517 517 + 519 518 flctl->read_bytes = 0; 520 519 if (command != NAND_CMD_PAGEPROG) 521 520 flctl->index = 0; ··· 530 525 execmd_read_page_sector(mtd, page_addr); 531 526 break; 532 527 } 533 533 - empty_fifo(flctl); 534 528 if (flctl->page_size) 535 529 set_cmd_regs(mtd, command, (NAND_CMD_READSTART << 8) 536 530 | command); ··· 551 547 break; 552 548 } 553 549 554 554 - empty_fifo(flctl); 555 550 if (flctl->page_size) { 556 551 set_cmd_regs(mtd, command, (NAND_CMD_READSTART << 8) 557 552 | NAND_CMD_READ0); ··· 562 559 flctl->read_bytes = mtd->oobsize; 563 560 goto read_normal_exit; 564 561 565 565 - case NAND_CMD_READID: 566 566 - empty_fifo(flctl); 567 567 - set_cmd_regs(mtd, command, command); 568 568 - set_addr(mtd, 0, 0); 562 562 + case NAND_CMD_RNDOUT: 563 563 + if (flctl->hwecc) 564 564 + break; 569 565 570 570 - flctl->read_bytes = 4; 566 566 + if (flctl->page_size) 567 567 + set_cmd_regs(mtd, command, (NAND_CMD_RNDOUTSTART << 8) 568 568 + | command); 569 569 + else 570 570 + set_cmd_regs(mtd, command, command); 571 571 + 572 572 + set_addr(mtd, column, 0); 573 573 + 574 574 + flctl->read_bytes = mtd->writesize + mtd->oobsize - column; 575 575 + goto read_normal_exit; 576 576 + 577 577 + case NAND_CMD_READID: 578 578 + set_cmd_regs(mtd, command, command); 579 579 + 580 580 + /* READID is always performed using an 8-bit bus */ 581 581 + if (flctl->chip.options & NAND_BUSWIDTH_16) 582 582 + column <<= 1; 583 583 + set_addr(mtd, column, 0); 584 584 + 585 585 + flctl->read_bytes = 8; 571 586 writel(flctl->read_bytes, FLDTCNTR(flctl)); /* set read size */ 587 587 + empty_fifo(flctl); 572 588 start_translation(flctl); 573 573 - read_datareg(flctl, 0); /* read and end */ 589 589 + read_fiforeg(flctl, flctl->read_bytes, 0); 590 590 + wait_completion(flctl); 574 591 break; 575 592 576 593 case NAND_CMD_ERASE1: ··· 673 650 default: 674 651 break; 675 652 } 676 676 - return; 653 653 + goto runtime_exit; 677 654 678 655 read_normal_exit: 679 656 writel(flctl->read_bytes, FLDTCNTR(flctl)); /* set read size */ 657 657 + empty_fifo(flctl); 680 658 start_translation(flctl); 681 659 read_fiforeg(flctl, flctl->read_bytes, 0); 682 660 wait_completion(flctl); 661 661 + runtime_exit: 662 662 + pm_runtime_put_sync(&flctl->pdev->dev); 683 663 return; 684 664 } 685 665 686 666 static void flctl_select_chip(struct mtd_info *mtd, int chipnr) 687 667 { 688 668 struct sh_flctl *flctl = mtd_to_flctl(mtd); 689 689 - uint32_t flcmncr_val = readl(FLCMNCR(flctl)); 669 669 + int ret; 690 670 691 671 switch (chipnr) { 692 672 case -1: 693 693 - flcmncr_val &= ~CE0_ENABLE; 694 694 - writel(flcmncr_val, FLCMNCR(flctl)); 673 673 + flctl->flcmncr_base &= ~CE0_ENABLE; 674 674 + 675 675 + pm_runtime_get_sync(&flctl->pdev->dev); 676 676 + writel(flctl->flcmncr_base, FLCMNCR(flctl)); 677 677 + 678 678 + if (flctl->qos_request) { 679 679 + dev_pm_qos_remove_request(&flctl->pm_qos); 680 680 + flctl->qos_request = 0; 681 681 + } 682 682 + 683 683 + pm_runtime_put_sync(&flctl->pdev->dev); 695 684 break; 696 685 case 0: 697 697 - flcmncr_val |= CE0_ENABLE; 698 698 - writel(flcmncr_val, FLCMNCR(flctl)); 686 686 + flctl->flcmncr_base |= CE0_ENABLE; 687 687 + 688 688 + if (!flctl->qos_request) { 689 689 + ret = dev_pm_qos_add_request(&flctl->pdev->dev, 690 690 + &flctl->pm_qos, 100); 691 691 + if (ret < 0) 692 692 + dev_err(&flctl->pdev->dev, 693 693 + "PM QoS request failed: %d\n", ret); 694 694 + flctl->qos_request = 1; 695 695 + } 696 696 + 697 697 + if (flctl->holden) { 698 698 + pm_runtime_get_sync(&flctl->pdev->dev); 699 699 + writel(HOLDEN, FLHOLDCR(flctl)); 700 700 + pm_runtime_put_sync(&flctl->pdev->dev); 701 701 + } 699 702 break; 700 703 default: 701 704 BUG(); ··· 779 730 return 0; 780 731 } 781 732 782 782 - static void flctl_register_init(struct sh_flctl *flctl, unsigned long val) 783 783 - { 784 784 - writel(val, FLCMNCR(flctl)); 785 785 - } 786 786 - 787 733 static int flctl_chip_init_tail(struct mtd_info *mtd) 788 734 { 789 735 struct sh_flctl *flctl = mtd_to_flctl(mtd); ··· 825 781 826 782 chip->ecc.size = 512; 827 783 chip->ecc.bytes = 10; 784 784 + chip->ecc.strength = 4; 828 785 chip->ecc.read_page = flctl_read_page_hwecc; 829 786 chip->ecc.write_page = flctl_write_page_hwecc; 830 787 chip->ecc.mode = NAND_ECC_HW; 831 788 832 789 /* 4 symbols ECC enabled */ 833 833 - writel(readl(FLCMNCR(flctl)) | _4ECCEN | ECCPOS2 | ECCPOS_02, 834 834 - FLCMNCR(flctl)); 790 790 + flctl->flcmncr_base |= _4ECCEN | ECCPOS2 | ECCPOS_02; 835 791 } else { 836 792 chip->ecc.mode = NAND_ECC_SOFT; 837 793 } ··· 863 819 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 864 820 if (!res) { 865 821 dev_err(&pdev->dev, "failed to get I/O memory\n"); 866 866 - goto err; 822 822 + goto err_iomap; 867 823 } 868 824 869 825 flctl->reg = ioremap(res->start, resource_size(res)); 870 826 if (flctl->reg == NULL) { 871 827 dev_err(&pdev->dev, "failed to remap I/O memory\n"); 872 872 - goto err; 828 828 + goto err_iomap; 873 829 } 874 830 875 831 platform_set_drvdata(pdev, flctl); ··· 877 833 nand = &flctl->chip; 878 834 flctl_mtd->priv = nand; 879 835 flctl->pdev = pdev; 836 836 + flctl->flcmncr_base = pdata->flcmncr_val; 880 837 flctl->hwecc = pdata->has_hwecc; 881 881 - 882 882 - flctl_register_init(flctl, pdata->flcmncr_val); 838 838 + flctl->holden = pdata->use_holden; 883 839 884 840 nand->options = NAND_NO_AUTOINCR; 885 841 ··· 899 855 nand->read_word = flctl_read_word; 900 856 } 901 857 858 858 + pm_runtime_enable(&pdev->dev); 859 859 + pm_runtime_resume(&pdev->dev); 860 860 + 902 861 ret = nand_scan_ident(flctl_mtd, 1, NULL); 903 862 if (ret) 904 904 - goto err; 863 863 + goto err_chip; 905 864 906 865 ret = flctl_chip_init_tail(flctl_mtd); 907 866 if (ret) 908 908 - goto err; 867 867 + goto err_chip; 909 868 910 869 ret = nand_scan_tail(flctl_mtd); 911 870 if (ret) 912 912 - goto err; 871 871 + goto err_chip; 913 872 914 873 mtd_device_register(flctl_mtd, pdata->parts, pdata->nr_parts); 915 874 916 875 return 0; 917 876 918 918 - err: 877 877 + err_chip: 878 878 + pm_runtime_disable(&pdev->dev); 879 879 + err_iomap: 919 880 kfree(flctl); 920 881 return ret; 921 882 } ··· 930 881 struct sh_flctl *flctl = platform_get_drvdata(pdev); 931 882 932 883 nand_release(&flctl->mtd); 884 884 + pm_runtime_disable(&pdev->dev); 933 885 kfree(flctl); 934 886 935 887 return 0;

+3 -2

drivers/mtd/nand/sharpsl.c

reviewed

··· 167 167 this->ecc.mode = NAND_ECC_HW; 168 168 this->ecc.size = 256; 169 169 this->ecc.bytes = 3; 170 170 + this->ecc.strength = 1; 170 171 this->badblock_pattern = data->badblock_pattern; 171 172 this->ecc.layout = data->ecc_layout; 172 173 this->ecc.hwctl = sharpsl_nand_enable_hwecc; ··· 182 181 /* Register the partitions */ 183 182 sharpsl->mtd.name = "sharpsl-nand"; 184 183 185 185 - err = mtd_device_parse_register(&sharpsl->mtd, NULL, 0, 186 186 - data->partitions, data->nr_partitions); 184 184 + err = mtd_device_parse_register(&sharpsl->mtd, NULL, NULL, 185 185 + data->partitions, data->nr_partitions); 187 186 if (err) 188 187 goto err_add; 189 188

+4 -3

drivers/mtd/nand/tmio_nand.c

reviewed

··· 430 430 nand_chip->ecc.mode = NAND_ECC_HW; 431 431 nand_chip->ecc.size = 512; 432 432 nand_chip->ecc.bytes = 6; 433 433 + nand_chip->ecc.strength = 2; 433 434 nand_chip->ecc.hwctl = tmio_nand_enable_hwecc; 434 435 nand_chip->ecc.calculate = tmio_nand_calculate_ecc; 435 436 nand_chip->ecc.correct = tmio_nand_correct_data; ··· 457 456 goto err_scan; 458 457 } 459 458 /* Register the partitions */ 460 460 - retval = mtd_device_parse_register(mtd, NULL, 0, 461 461 - data ? data->partition : NULL, 462 462 - data ? data->num_partitions : 0); 459 459 + retval = mtd_device_parse_register(mtd, NULL, NULL, 460 460 + data ? data->partition : NULL, 461 461 + data ? data->num_partitions : 0); 463 462 if (!retval) 464 463 return retval; 465 464

+2 -1

drivers/mtd/nand/txx9ndfmc.c

reviewed

··· 356 356 /* txx9ndfmc_nand_scan will overwrite ecc.size and ecc.bytes */ 357 357 chip->ecc.size = 256; 358 358 chip->ecc.bytes = 3; 359 359 + chip->ecc.strength = 1; 359 360 chip->chip_delay = 100; 360 361 chip->controller = &drvdata->hw_control; 361 362 ··· 387 386 } 388 387 mtd->name = txx9_priv->mtdname; 389 388 390 390 - mtd_device_parse_register(mtd, NULL, 0, NULL, 0); 389 389 + mtd_device_parse_register(mtd, NULL, NULL, NULL, 0); 391 390 drvdata->mtds[i] = mtd; 392 391 } 393 392

-7

drivers/mtd/nftlcore.c

reviewed

··· 56 56 if (memcmp(mtd->name, "DiskOnChip", 10)) 57 57 return; 58 58 59 59 - if (!mtd_can_have_bb(mtd)) { 60 60 - printk(KERN_ERR 61 61 - "NFTL no longer supports the old DiskOnChip drivers loaded via docprobe.\n" 62 62 - "Please use the new diskonchip driver under the NAND subsystem.\n"); 63 63 - return; 64 64 - } 65 65 - 66 59 pr_debug("NFTL: add_mtd for %s\n", mtd->name); 67 60 68 61 nftl = kzalloc(sizeof(struct NFTLrecord), GFP_KERNEL);

+3 -3

drivers/mtd/onenand/generic.c

reviewed

··· 70 70 goto out_iounmap; 71 71 } 72 72 73 73 - err = mtd_device_parse_register(&info->mtd, NULL, 0, 74 74 - pdata ? pdata->parts : NULL, 75 75 - pdata ? pdata->nr_parts : 0); 73 73 + err = mtd_device_parse_register(&info->mtd, NULL, NULL, 74 74 + pdata ? pdata->parts : NULL, 75 75 + pdata ? pdata->nr_parts : 0); 76 76 77 77 platform_set_drvdata(pdev, info); 78 78

+3 -3

drivers/mtd/onenand/omap2.c

reviewed

··· 751 751 if ((r = onenand_scan(&c->mtd, 1)) < 0) 752 752 goto err_release_regulator; 753 753 754 754 - r = mtd_device_parse_register(&c->mtd, NULL, 0, 755 755 - pdata ? pdata->parts : NULL, 756 756 - pdata ? pdata->nr_parts : 0); 754 754 + r = mtd_device_parse_register(&c->mtd, NULL, NULL, 755 755 + pdata ? pdata->parts : NULL, 756 756 + pdata ? pdata->nr_parts : 0); 757 757 if (r) 758 758 goto err_release_onenand; 759 759

+22 -46

drivers/mtd/onenand/onenand_base.c

reviewed

··· 1753 1753 pr_debug("%s: to = 0x%08x, len = %i\n", __func__, (unsigned int)to, 1754 1754 (int)len); 1755 1755 1756 1756 - /* Initialize retlen, in case of early exit */ 1757 1757 - *retlen = 0; 1758 1758 - 1759 1759 - /* Do not allow writes past end of device */ 1760 1760 - if (unlikely((to + len) > mtd->size)) { 1761 1761 - printk(KERN_ERR "%s: Attempt write to past end of device\n", 1762 1762 - __func__); 1763 1763 - return -EINVAL; 1764 1764 - } 1765 1765 - 1766 1756 /* Reject writes, which are not page aligned */ 1767 1757 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) { 1768 1758 printk(KERN_ERR "%s: Attempt to write not page aligned data\n", ··· 1879 1889 /* Initialize retlen, in case of early exit */ 1880 1890 ops->retlen = 0; 1881 1891 ops->oobretlen = 0; 1882 1882 - 1883 1883 - /* Do not allow writes past end of device */ 1884 1884 - if (unlikely((to + len) > mtd->size)) { 1885 1885 - printk(KERN_ERR "%s: Attempt write to past end of device\n", 1886 1886 - __func__); 1887 1887 - return -EINVAL; 1888 1888 - } 1889 1892 1890 1893 /* Reject writes, which are not page aligned */ 1891 1894 if (unlikely(NOTALIGNED(to) || NOTALIGNED(len))) { ··· 2476 2493 (unsigned long long)instr->addr, 2477 2494 (unsigned long long)instr->len); 2478 2495 2479 2479 - /* Do not allow erase past end of device */ 2480 2480 - if (unlikely((len + addr) > mtd->size)) { 2481 2481 - printk(KERN_ERR "%s: Erase past end of device\n", __func__); 2482 2482 - return -EINVAL; 2483 2483 - } 2484 2484 - 2485 2496 if (FLEXONENAND(this)) { 2486 2497 /* Find the eraseregion of this address */ 2487 2498 int i = flexonenand_region(mtd, addr); ··· 2501 2524 printk(KERN_ERR "%s: Length not block aligned\n", __func__); 2502 2525 return -EINVAL; 2503 2526 } 2504 2504 - 2505 2505 - instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 2506 2527 2507 2528 /* Grab the lock and see if the device is available */ 2508 2529 onenand_get_device(mtd, FL_ERASING); ··· 4078 4103 mtd->oobavail = this->ecclayout->oobavail; 4079 4104 4080 4105 mtd->ecclayout = this->ecclayout; 4106 4106 + mtd->ecc_strength = 1; 4081 4107 4082 4108 /* Fill in remaining MTD driver data */ 4083 4109 mtd->type = ONENAND_IS_MLC(this) ? MTD_MLCNANDFLASH : MTD_NANDFLASH; 4084 4110 mtd->flags = MTD_CAP_NANDFLASH; 4085 4085 - mtd->erase = onenand_erase; 4086 4086 - mtd->point = NULL; 4087 4087 - mtd->unpoint = NULL; 4088 4088 - mtd->read = onenand_read; 4089 4089 - mtd->write = onenand_write; 4090 4090 - mtd->read_oob = onenand_read_oob; 4091 4091 - mtd->write_oob = onenand_write_oob; 4092 4092 - mtd->panic_write = onenand_panic_write; 4111 4111 + mtd->_erase = onenand_erase; 4112 4112 + mtd->_point = NULL; 4113 4113 + mtd->_unpoint = NULL; 4114 4114 + mtd->_read = onenand_read; 4115 4115 + mtd->_write = onenand_write; 4116 4116 + mtd->_read_oob = onenand_read_oob; 4117 4117 + mtd->_write_oob = onenand_write_oob; 4118 4118 + mtd->_panic_write = onenand_panic_write; 4093 4119 #ifdef CONFIG_MTD_ONENAND_OTP 4094 4094 - mtd->get_fact_prot_info = onenand_get_fact_prot_info; 4095 4095 - mtd->read_fact_prot_reg = onenand_read_fact_prot_reg; 4096 4096 - mtd->get_user_prot_info = onenand_get_user_prot_info; 4097 4097 - mtd->read_user_prot_reg = onenand_read_user_prot_reg; 4098 4098 - mtd->write_user_prot_reg = onenand_write_user_prot_reg; 4099 4099 - mtd->lock_user_prot_reg = onenand_lock_user_prot_reg; 4120 4120 + mtd->_get_fact_prot_info = onenand_get_fact_prot_info; 4121 4121 + mtd->_read_fact_prot_reg = onenand_read_fact_prot_reg; 4122 4122 + mtd->_get_user_prot_info = onenand_get_user_prot_info; 4123 4123 + mtd->_read_user_prot_reg = onenand_read_user_prot_reg; 4124 4124 + mtd->_write_user_prot_reg = onenand_write_user_prot_reg; 4125 4125 + mtd->_lock_user_prot_reg = onenand_lock_user_prot_reg; 4100 4126 #endif 4101 4101 - mtd->sync = onenand_sync; 4102 4102 - mtd->lock = onenand_lock; 4103 4103 - mtd->unlock = onenand_unlock; 4104 4104 - mtd->suspend = onenand_suspend; 4105 4105 - mtd->resume = onenand_resume; 4106 4106 - mtd->block_isbad = onenand_block_isbad; 4107 4107 - mtd->block_markbad = onenand_block_markbad; 4127 4127 + mtd->_sync = onenand_sync; 4128 4128 + mtd->_lock = onenand_lock; 4129 4129 + mtd->_unlock = onenand_unlock; 4130 4130 + mtd->_suspend = onenand_suspend; 4131 4131 + mtd->_resume = onenand_resume; 4132 4132 + mtd->_block_isbad = onenand_block_isbad; 4133 4133 + mtd->_block_markbad = onenand_block_markbad; 4108 4134 mtd->owner = THIS_MODULE; 4109 4135 mtd->writebufsize = mtd->writesize; 4110 4136

+3 -3

drivers/mtd/onenand/samsung.c

reviewed

··· 923 923 r = platform_get_resource(pdev, IORESOURCE_MEM, 1); 924 924 if (!r) { 925 925 dev_err(&pdev->dev, "no buffer memory resource defined\n"); 926 926 - return -ENOENT; 926 926 + err = -ENOENT; 927 927 goto ahb_resource_failed; 928 928 } 929 929 ··· 964 964 r = platform_get_resource(pdev, IORESOURCE_MEM, 1); 965 965 if (!r) { 966 966 dev_err(&pdev->dev, "no dma memory resource defined\n"); 967 967 - return -ENOENT; 967 967 + err = -ENOENT; 968 968 goto dma_resource_failed; 969 969 } 970 970 ··· 1014 1014 if (s3c_read_reg(MEM_CFG_OFFSET) & ONENAND_SYS_CFG1_SYNC_READ) 1015 1015 dev_info(&onenand->pdev->dev, "OneNAND Sync. Burst Read enabled\n"); 1016 1016 1017 1017 - err = mtd_device_parse_register(mtd, NULL, 0, 1017 1017 + err = mtd_device_parse_register(mtd, NULL, NULL, 1018 1018 pdata ? pdata->parts : NULL, 1019 1019 pdata ? pdata->nr_parts : 0); 1020 1020

+2 -4

drivers/mtd/redboot.c

reviewed

··· 78 78 79 79 if ( directory < 0 ) { 80 80 offset = master->size + directory * master->erasesize; 81 81 - while (mtd_can_have_bb(master) && 82 82 - mtd_block_isbad(master, offset)) { 81 81 + while (mtd_block_isbad(master, offset)) { 83 82 if (!offset) { 84 83 nogood: 85 84 printk(KERN_NOTICE "Failed to find a non-bad block to check for RedBoot partition table\n"); ··· 88 89 } 89 90 } else { 90 91 offset = directory * master->erasesize; 91 91 - while (mtd_can_have_bb(master) && 92 92 - mtd_block_isbad(master, offset)) { 92 92 + while (mtd_block_isbad(master, offset)) { 93 93 offset += master->erasesize; 94 94 if (offset == master->size) 95 95 goto nogood;

+1 -1

drivers/mtd/sm_ftl.c

reviewed

··· 1256 1256 1257 1257 static struct mtd_blktrans_ops sm_ftl_ops = { 1258 1258 .name = "smblk", 1259 1259 - .major = -1, 1259 1259 + .major = 0, 1260 1260 .part_bits = SM_FTL_PARTN_BITS, 1261 1261 .blksize = SM_SECTOR_SIZE, 1262 1262 .getgeo = sm_getgeo,

+5 -24

drivers/mtd/ubi/gluebi.c

reviewed

··· 174 174 int err = 0, lnum, offs, total_read; 175 175 struct gluebi_device *gluebi; 176 176 177 177 - if (len < 0 || from < 0 || from + len > mtd->size) 178 178 - return -EINVAL; 179 179 - 180 177 gluebi = container_of(mtd, struct gluebi_device, mtd); 181 181 - 182 178 lnum = div_u64_rem(from, mtd->erasesize, &offs); 183 179 total_read = len; 184 180 while (total_read) { ··· 214 218 int err = 0, lnum, offs, total_written; 215 219 struct gluebi_device *gluebi; 216 220 217 217 - if (len < 0 || to < 0 || len + to > mtd->size) 218 218 - return -EINVAL; 219 219 - 220 221 gluebi = container_of(mtd, struct gluebi_device, mtd); 221 221 - 222 222 - if (!(mtd->flags & MTD_WRITEABLE)) 223 223 - return -EROFS; 224 224 - 225 222 lnum = div_u64_rem(to, mtd->erasesize, &offs); 226 223 227 224 if (len % mtd->writesize || offs % mtd->writesize) ··· 254 265 int err, i, lnum, count; 255 266 struct gluebi_device *gluebi; 256 267 257 257 - if (instr->addr < 0 || instr->addr > mtd->size - mtd->erasesize) 258 258 - return -EINVAL; 259 259 - if (instr->len < 0 || instr->addr + instr->len > mtd->size) 260 260 - return -EINVAL; 261 268 if (mtd_mod_by_ws(instr->addr, mtd) || mtd_mod_by_ws(instr->len, mtd)) 262 269 return -EINVAL; 263 270 264 271 lnum = mtd_div_by_eb(instr->addr, mtd); 265 272 count = mtd_div_by_eb(instr->len, mtd); 266 266 - 267 273 gluebi = container_of(mtd, struct gluebi_device, mtd); 268 268 - 269 269 - if (!(mtd->flags & MTD_WRITEABLE)) 270 270 - return -EROFS; 271 274 272 275 for (i = 0; i < count - 1; i++) { 273 276 err = ubi_leb_unmap(gluebi->desc, lnum + i); ··· 321 340 mtd->owner = THIS_MODULE; 322 341 mtd->writesize = di->min_io_size; 323 342 mtd->erasesize = vi->usable_leb_size; 324 324 - mtd->read = gluebi_read; 325 325 - mtd->write = gluebi_write; 326 326 - mtd->erase = gluebi_erase; 327 327 - mtd->get_device = gluebi_get_device; 328 328 - mtd->put_device = gluebi_put_device; 343 343 + mtd->_read = gluebi_read; 344 344 + mtd->_write = gluebi_write; 345 345 + mtd->_erase = gluebi_erase; 346 346 + mtd->_get_device = gluebi_get_device; 347 347 + mtd->_put_device = gluebi_put_device; 329 348 330 349 /* 331 350 * In case of dynamic a volume, MTD device size is just volume size. In

+5 -5

drivers/net/ethernet/sfc/mtd.c

reviewed

··· 193 193 erase->state = MTD_ERASE_DONE; 194 194 } else { 195 195 erase->state = MTD_ERASE_FAILED; 196 196 - erase->fail_addr = 0xffffffff; 196 196 + erase->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 197 197 } 198 198 mtd_erase_callback(erase); 199 199 return rc; ··· 263 263 part->mtd.owner = THIS_MODULE; 264 264 part->mtd.priv = efx_mtd; 265 265 part->mtd.name = part->name; 266 266 - part->mtd.erase = efx_mtd_erase; 267 267 - part->mtd.read = efx_mtd->ops->read; 268 268 - part->mtd.write = efx_mtd->ops->write; 269 269 - part->mtd.sync = efx_mtd_sync; 266 266 + part->mtd._erase = efx_mtd_erase; 267 267 + part->mtd._read = efx_mtd->ops->read; 268 268 + part->mtd._write = efx_mtd->ops->write; 269 269 + part->mtd._sync = efx_mtd_sync; 270 270 271 271 if (mtd_device_register(&part->mtd, NULL, 0)) 272 272 goto fail;

+2

fs/jffs2/acl.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/slab.h> 14 16 #include <linux/fs.h>

+18 -11

fs/jffs2/background.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/kernel.h> 14 16 #include <linux/jffs2.h> 15 17 #include <linux/mtd/mtd.h> ··· 44 42 45 43 tsk = kthread_run(jffs2_garbage_collect_thread, c, "jffs2_gcd_mtd%d", c->mtd->index); 46 44 if (IS_ERR(tsk)) { 47 47 - printk(KERN_WARNING "fork failed for JFFS2 garbage collect thread: %ld\n", -PTR_ERR(tsk)); 45 45 + pr_warn("fork failed for JFFS2 garbage collect thread: %ld\n", 46 46 + -PTR_ERR(tsk)); 48 47 complete(&c->gc_thread_exit); 49 48 ret = PTR_ERR(tsk); 50 49 } else { 51 50 /* Wait for it... */ 52 52 - D1(printk(KERN_DEBUG "JFFS2: Garbage collect thread is pid %d\n", tsk->pid)); 51 51 + jffs2_dbg(1, "Garbage collect thread is pid %d\n", tsk->pid); 53 52 wait_for_completion(&c->gc_thread_start); 54 53 ret = tsk->pid; 55 54 } ··· 63 60 int wait = 0; 64 61 spin_lock(&c->erase_completion_lock); 65 62 if (c->gc_task) { 66 66 - D1(printk(KERN_DEBUG "jffs2: Killing GC task %d\n", c->gc_task->pid)); 63 63 + jffs2_dbg(1, "Killing GC task %d\n", c->gc_task->pid); 67 64 send_sig(SIGKILL, c->gc_task, 1); 68 65 wait = 1; 69 66 } ··· 93 90 if (!jffs2_thread_should_wake(c)) { 94 91 set_current_state (TASK_INTERRUPTIBLE); 95 92 spin_unlock(&c->erase_completion_lock); 96 96 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread sleeping...\n")); 93 93 + jffs2_dbg(1, "%s(): sleeping...\n", __func__); 97 94 schedule(); 98 95 } else 99 96 spin_unlock(&c->erase_completion_lock); ··· 112 109 schedule_timeout_interruptible(msecs_to_jiffies(50)); 113 110 114 111 if (kthread_should_stop()) { 115 115 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): kthread_stop() called.\n")); 112 112 + jffs2_dbg(1, "%s(): kthread_stop() called\n", __func__); 116 113 goto die; 117 114 } 118 115 ··· 129 126 130 127 switch(signr) { 131 128 case SIGSTOP: 132 132 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGSTOP received.\n")); 129 129 + jffs2_dbg(1, "%s(): SIGSTOP received\n", 130 130 + __func__); 133 131 set_current_state(TASK_STOPPED); 134 132 schedule(); 135 133 break; 136 134 137 135 case SIGKILL: 138 138 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGKILL received.\n")); 136 136 + jffs2_dbg(1, "%s(): SIGKILL received\n", 137 137 + __func__); 139 138 goto die; 140 139 141 140 case SIGHUP: 142 142 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): SIGHUP received.\n")); 141 141 + jffs2_dbg(1, "%s(): SIGHUP received\n", 142 142 + __func__); 143 143 break; 144 144 default: 145 145 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): signal %ld received\n", signr)); 145 145 + jffs2_dbg(1, "%s(): signal %ld received\n", 146 146 + __func__, signr); 146 147 } 147 148 } 148 149 /* We don't want SIGHUP to interrupt us. STOP and KILL are OK though. */ 149 150 disallow_signal(SIGHUP); 150 151 151 151 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_thread(): pass\n")); 152 152 + jffs2_dbg(1, "%s(): pass\n", __func__); 152 153 if (jffs2_garbage_collect_pass(c) == -ENOSPC) { 153 153 - printk(KERN_NOTICE "No space for garbage collection. Aborting GC thread\n"); 154 154 + pr_notice("No space for garbage collection. Aborting GC thread\n"); 154 155 goto die; 155 156 } 156 157 }

+4 -2

fs/jffs2/build.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/kernel.h> 14 16 #include <linux/sched.h> 15 17 #include <linux/slab.h> ··· 309 307 trying to GC to make more space. It'll be a fruitless task */ 310 308 c->nospc_dirty_size = c->sector_size + (c->flash_size / 100); 311 309 312 312 - dbg_fsbuild("JFFS2 trigger levels (size %d KiB, block size %d KiB, %d blocks)\n", 313 313 - c->flash_size / 1024, c->sector_size / 1024, c->nr_blocks); 310 310 + dbg_fsbuild("trigger levels (size %d KiB, block size %d KiB, %d blocks)\n", 311 311 + c->flash_size / 1024, c->sector_size / 1024, c->nr_blocks); 314 312 dbg_fsbuild("Blocks required to allow deletion: %d (%d KiB)\n", 315 313 c->resv_blocks_deletion, c->resv_blocks_deletion*c->sector_size/1024); 316 314 dbg_fsbuild("Blocks required to allow writes: %d (%d KiB)\n",

+18 -14

fs/jffs2/compr.c

reviewed

··· 12 12 * 13 13 */ 14 14 15 15 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 16 16 + 15 17 #include "compr.h" 16 18 17 19 static DEFINE_SPINLOCK(jffs2_compressor_list_lock); ··· 81 79 82 80 output_buf = kmalloc(*cdatalen, GFP_KERNEL); 83 81 if (!output_buf) { 84 84 - printk(KERN_WARNING "JFFS2: No memory for compressor allocation. Compression failed.\n"); 82 82 + pr_warn("No memory for compressor allocation. Compression failed.\n"); 85 83 return ret; 86 84 } 87 85 orig_slen = *datalen; ··· 190 188 tmp_buf = kmalloc(orig_slen, GFP_KERNEL); 191 189 spin_lock(&jffs2_compressor_list_lock); 192 190 if (!tmp_buf) { 193 193 - printk(KERN_WARNING "JFFS2: No memory for compressor allocation. (%d bytes)\n", orig_slen); 191 191 + pr_warn("No memory for compressor allocation. (%d bytes)\n", 192 192 + orig_slen); 194 193 continue; 195 194 } 196 195 else { ··· 238 235 cpage_out, datalen, cdatalen); 239 236 break; 240 237 default: 241 241 - printk(KERN_ERR "JFFS2: unknown compression mode.\n"); 238 238 + pr_err("unknown compression mode\n"); 242 239 } 243 240 244 241 if (ret == JFFS2_COMPR_NONE) { ··· 280 277 ret = this->decompress(cdata_in, data_out, cdatalen, datalen); 281 278 spin_lock(&jffs2_compressor_list_lock); 282 279 if (ret) { 283 283 - printk(KERN_WARNING "Decompressor \"%s\" returned %d\n", this->name, ret); 280 280 + pr_warn("Decompressor \"%s\" returned %d\n", 281 281 + this->name, ret); 284 282 } 285 283 else { 286 284 this->stat_decompr_blocks++; ··· 291 287 return ret; 292 288 } 293 289 } 294 294 - printk(KERN_WARNING "JFFS2 compression type 0x%02x not available.\n", comprtype); 290 290 + pr_warn("compression type 0x%02x not available\n", comprtype); 295 291 spin_unlock(&jffs2_compressor_list_lock); 296 292 return -EIO; 297 293 } ··· 303 299 struct jffs2_compressor *this; 304 300 305 301 if (!comp->name) { 306 306 - printk(KERN_WARNING "NULL compressor name at registering JFFS2 compressor. Failed.\n"); 302 302 + pr_warn("NULL compressor name at registering JFFS2 compressor. Failed.\n"); 307 303 return -1; 308 304 } 309 305 comp->compr_buf_size=0; ··· 313 309 comp->stat_compr_new_size=0; 314 310 comp->stat_compr_blocks=0; 315 311 comp->stat_decompr_blocks=0; 316 316 - D1(printk(KERN_DEBUG "Registering JFFS2 compressor \"%s\"\n", comp->name)); 312 312 + jffs2_dbg(1, "Registering JFFS2 compressor \"%s\"\n", comp->name); 317 313 318 314 spin_lock(&jffs2_compressor_list_lock); 319 315 ··· 336 332 337 333 int jffs2_unregister_compressor(struct jffs2_compressor *comp) 338 334 { 339 339 - D2(struct jffs2_compressor *this;) 335 335 + D2(struct jffs2_compressor *this); 340 336 341 341 - D1(printk(KERN_DEBUG "Unregistering JFFS2 compressor \"%s\"\n", comp->name)); 337 337 + jffs2_dbg(1, "Unregistering JFFS2 compressor \"%s\"\n", comp->name); 342 338 343 339 spin_lock(&jffs2_compressor_list_lock); 344 340 345 341 if (comp->usecount) { 346 342 spin_unlock(&jffs2_compressor_list_lock); 347 347 - printk(KERN_WARNING "JFFS2: Compressor module is in use. Unregister failed.\n"); 343 343 + pr_warn("Compressor module is in use. Unregister failed.\n"); 348 344 return -1; 349 345 } 350 346 list_del(&comp->list); ··· 381 377 /* Setting default compression mode */ 382 378 #ifdef CONFIG_JFFS2_CMODE_NONE 383 379 jffs2_compression_mode = JFFS2_COMPR_MODE_NONE; 384 384 - D1(printk(KERN_INFO "JFFS2: default compression mode: none\n");) 380 380 + jffs2_dbg(1, "default compression mode: none\n"); 385 381 #else 386 382 #ifdef CONFIG_JFFS2_CMODE_SIZE 387 383 jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE; 388 388 - D1(printk(KERN_INFO "JFFS2: default compression mode: size\n");) 384 384 + jffs2_dbg(1, "default compression mode: size\n"); 389 385 #else 390 386 #ifdef CONFIG_JFFS2_CMODE_FAVOURLZO 391 387 jffs2_compression_mode = JFFS2_COMPR_MODE_FAVOURLZO; 392 392 - D1(printk(KERN_INFO "JFFS2: default compression mode: favourlzo\n");) 388 388 + jffs2_dbg(1, "default compression mode: favourlzo\n"); 393 389 #else 394 394 - D1(printk(KERN_INFO "JFFS2: default compression mode: priority\n");) 390 390 + jffs2_dbg(1, "default compression mode: priority\n"); 395 391 #endif 396 392 #endif 397 393 #endif

-1

fs/jffs2/compr_lzo.c

reviewed

··· 33 33 lzo_compress_buf = vmalloc(lzo1x_worst_compress(PAGE_SIZE)); 34 34 35 35 if (!lzo_mem || !lzo_compress_buf) { 36 36 - printk(KERN_WARNING "Failed to allocate lzo deflate workspace\n"); 37 36 free_workspace(); 38 37 return -ENOMEM; 39 38 }

+2

fs/jffs2/compr_rubin.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/string.h> 14 16 #include <linux/types.h> 15 17 #include <linux/jffs2.h>

+24 -21

fs/jffs2/compr_zlib.c

reviewed

··· 14 14 #error "The userspace support got too messy and was removed. Update your mkfs.jffs2" 15 15 #endif 16 16 17 17 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 18 + 17 19 #include <linux/kernel.h> 18 20 #include <linux/zlib.h> 19 21 #include <linux/zutil.h> ··· 44 42 { 45 43 def_strm.workspace = vmalloc(zlib_deflate_workspacesize(MAX_WBITS, 46 44 MAX_MEM_LEVEL)); 47 47 - if (!def_strm.workspace) { 48 48 - printk(KERN_WARNING "Failed to allocate %d bytes for deflate workspace\n", zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL)); 45 45 + if (!def_strm.workspace) 49 46 return -ENOMEM; 50 50 - } 51 51 - D1(printk(KERN_DEBUG "Allocated %d bytes for deflate workspace\n", zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL))); 47 47 + 48 48 + jffs2_dbg(1, "Allocated %d bytes for deflate workspace\n", 49 49 + zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL)); 52 50 inf_strm.workspace = vmalloc(zlib_inflate_workspacesize()); 53 51 if (!inf_strm.workspace) { 54 54 - printk(KERN_WARNING "Failed to allocate %d bytes for inflate workspace\n", zlib_inflate_workspacesize()); 55 52 vfree(def_strm.workspace); 56 53 return -ENOMEM; 57 54 } 58 58 - D1(printk(KERN_DEBUG "Allocated %d bytes for inflate workspace\n", zlib_inflate_workspacesize())); 55 55 + jffs2_dbg(1, "Allocated %d bytes for inflate workspace\n", 56 56 + zlib_inflate_workspacesize()); 59 57 return 0; 60 58 } 61 59 ··· 81 79 mutex_lock(&deflate_mutex); 82 80 83 81 if (Z_OK != zlib_deflateInit(&def_strm, 3)) { 84 84 - printk(KERN_WARNING "deflateInit failed\n"); 82 82 + pr_warn("deflateInit failed\n"); 85 83 mutex_unlock(&deflate_mutex); 86 84 return -1; 87 85 } ··· 95 93 while (def_strm.total_out < *dstlen - STREAM_END_SPACE && def_strm.total_in < *sourcelen) { 96 94 def_strm.avail_out = *dstlen - (def_strm.total_out + STREAM_END_SPACE); 97 95 def_strm.avail_in = min((unsigned)(*sourcelen-def_strm.total_in), def_strm.avail_out); 98 98 - D1(printk(KERN_DEBUG "calling deflate with avail_in %d, avail_out %d\n", 99 99 - def_strm.avail_in, def_strm.avail_out)); 96 96 + jffs2_dbg(1, "calling deflate with avail_in %d, avail_out %d\n", 97 97 + def_strm.avail_in, def_strm.avail_out); 100 98 ret = zlib_deflate(&def_strm, Z_PARTIAL_FLUSH); 101 101 - D1(printk(KERN_DEBUG "deflate returned with avail_in %d, avail_out %d, total_in %ld, total_out %ld\n", 102 102 - def_strm.avail_in, def_strm.avail_out, def_strm.total_in, def_strm.total_out)); 99 99 + jffs2_dbg(1, "deflate returned with avail_in %d, avail_out %d, total_in %ld, total_out %ld\n", 100 100 + def_strm.avail_in, def_strm.avail_out, 101 101 + def_strm.total_in, def_strm.total_out); 103 102 if (ret != Z_OK) { 104 104 - D1(printk(KERN_DEBUG "deflate in loop returned %d\n", ret)); 103 103 + jffs2_dbg(1, "deflate in loop returned %d\n", ret); 105 104 zlib_deflateEnd(&def_strm); 106 105 mutex_unlock(&deflate_mutex); 107 106 return -1; ··· 114 111 zlib_deflateEnd(&def_strm); 115 112 116 113 if (ret != Z_STREAM_END) { 117 117 - D1(printk(KERN_DEBUG "final deflate returned %d\n", ret)); 114 114 + jffs2_dbg(1, "final deflate returned %d\n", ret); 118 115 ret = -1; 119 116 goto out; 120 117 } 121 118 122 119 if (def_strm.total_out >= def_strm.total_in) { 123 123 - D1(printk(KERN_DEBUG "zlib compressed %ld bytes into %ld; failing\n", 124 124 - def_strm.total_in, def_strm.total_out)); 120 120 + jffs2_dbg(1, "zlib compressed %ld bytes into %ld; failing\n", 121 121 + def_strm.total_in, def_strm.total_out); 125 122 ret = -1; 126 123 goto out; 127 124 } 128 125 129 129 - D1(printk(KERN_DEBUG "zlib compressed %ld bytes into %ld\n", 130 130 - def_strm.total_in, def_strm.total_out)); 126 126 + jffs2_dbg(1, "zlib compressed %ld bytes into %ld\n", 127 127 + def_strm.total_in, def_strm.total_out); 131 128 132 129 *dstlen = def_strm.total_out; 133 130 *sourcelen = def_strm.total_in; ··· 160 157 ((data_in[0] & 0x0f) == Z_DEFLATED) && 161 158 !(((data_in[0]<<8) + data_in[1]) % 31)) { 162 159 163 163 - D2(printk(KERN_DEBUG "inflate skipping adler32\n")); 160 160 + jffs2_dbg(2, "inflate skipping adler32\n"); 164 161 wbits = -((data_in[0] >> 4) + 8); 165 162 inf_strm.next_in += 2; 166 163 inf_strm.avail_in -= 2; 167 164 } else { 168 165 /* Let this remain D1 for now -- it should never happen */ 169 169 - D1(printk(KERN_DEBUG "inflate not skipping adler32\n")); 166 166 + jffs2_dbg(1, "inflate not skipping adler32\n"); 170 167 } 171 168 172 169 173 170 if (Z_OK != zlib_inflateInit2(&inf_strm, wbits)) { 174 174 - printk(KERN_WARNING "inflateInit failed\n"); 171 171 + pr_warn("inflateInit failed\n"); 175 172 mutex_unlock(&inflate_mutex); 176 173 return 1; 177 174 } ··· 179 176 while((ret = zlib_inflate(&inf_strm, Z_FINISH)) == Z_OK) 180 177 ; 181 178 if (ret != Z_STREAM_END) { 182 182 - printk(KERN_NOTICE "inflate returned %d\n", ret); 179 179 + pr_notice("inflate returned %d\n", ret); 183 180 } 184 181 zlib_inflateEnd(&inf_strm); 185 182 mutex_unlock(&inflate_mutex);

+14 -8

fs/jffs2/debug.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/kernel.h> 14 16 #include <linux/types.h> 15 17 #include <linux/pagemap.h> ··· 263 261 bad += c->sector_size; 264 262 } 265 263 266 266 - #define check(sz) \ 267 267 - if (sz != c->sz##_size) { \ 268 268 - printk(KERN_WARNING #sz "_size mismatch counted 0x%x, c->" #sz "_size 0x%x\n", \ 269 269 - sz, c->sz##_size); \ 270 270 - dump = 1; \ 271 271 - } 264 264 + #define check(sz) \ 265 265 + do { \ 266 266 + if (sz != c->sz##_size) { \ 267 267 + pr_warn("%s_size mismatch counted 0x%x, c->%s_size 0x%x\n", \ 268 268 + #sz, sz, #sz, c->sz##_size); \ 269 269 + dump = 1; \ 270 270 + } \ 271 271 + } while (0) 272 272 + 272 273 check(free); 273 274 check(dirty); 274 275 check(used); ··· 279 274 check(unchecked); 280 275 check(bad); 281 276 check(erasing); 277 277 + 282 278 #undef check 283 279 284 280 if (nr_counted != c->nr_blocks) { 285 285 - printk(KERN_WARNING "%s counted only 0x%x blocks of 0x%x. Where are the others?\n", 286 286 - __func__, nr_counted, c->nr_blocks); 281 281 + pr_warn("%s counted only 0x%x blocks of 0x%x. Where are the others?\n", 282 282 + __func__, nr_counted, c->nr_blocks); 287 283 dump = 1; 288 284 } 289 285

+17 -33

fs/jffs2/debug.h

reviewed

··· 51 51 * superseded by nicer dbg_xxx() macros... 52 52 */ 53 53 #if CONFIG_JFFS2_FS_DEBUG > 0 54 54 + #define DEBUG 54 55 #define D1(x) x 55 56 #else 56 57 #define D1(x) ··· 63 62 #define D2(x) 64 63 #endif 65 64 65 65 + #define jffs2_dbg(level, fmt, ...) \ 66 66 + do { \ 67 67 + if (CONFIG_JFFS2_FS_DEBUG >= level) \ 68 68 + pr_debug(fmt, ##__VA_ARGS__); \ 69 69 + } while (0) 70 70 + 66 71 /* The prefixes of JFFS2 messages */ 72 72 + #define JFFS2_DBG KERN_DEBUG 67 73 #define JFFS2_DBG_PREFIX "[JFFS2 DBG]" 68 68 - #define JFFS2_ERR_PREFIX "JFFS2 error:" 69 69 - #define JFFS2_WARN_PREFIX "JFFS2 warning:" 70 70 - #define JFFS2_NOTICE_PREFIX "JFFS2 notice:" 71 71 - 72 72 - #define JFFS2_ERR KERN_ERR 73 73 - #define JFFS2_WARN KERN_WARNING 74 74 - #define JFFS2_NOT KERN_NOTICE 75 75 - #define JFFS2_DBG KERN_DEBUG 76 76 - 77 74 #define JFFS2_DBG_MSG_PREFIX JFFS2_DBG JFFS2_DBG_PREFIX 78 78 - #define JFFS2_ERR_MSG_PREFIX JFFS2_ERR JFFS2_ERR_PREFIX 79 79 - #define JFFS2_WARN_MSG_PREFIX JFFS2_WARN JFFS2_WARN_PREFIX 80 80 - #define JFFS2_NOTICE_MSG_PREFIX JFFS2_NOT JFFS2_NOTICE_PREFIX 81 75 82 76 /* JFFS2 message macros */ 83 83 - #define JFFS2_ERROR(fmt, ...) \ 84 84 - do { \ 85 85 - printk(JFFS2_ERR_MSG_PREFIX \ 86 86 - " (%d) %s: " fmt, task_pid_nr(current), \ 87 87 - __func__ , ##__VA_ARGS__); \ 88 88 - } while(0) 77 77 + #define JFFS2_ERROR(fmt, ...) \ 78 78 + pr_err("error: (%d) %s: " fmt, \ 79 79 + task_pid_nr(current), __func__, ##__VA_ARGS__) 89 80 90 81 #define JFFS2_WARNING(fmt, ...) \ 91 91 - do { \ 92 92 - printk(JFFS2_WARN_MSG_PREFIX \ 93 93 - " (%d) %s: " fmt, task_pid_nr(current), \ 94 94 - __func__ , ##__VA_ARGS__); \ 95 95 - } while(0) 82 82 + pr_warn("warning: (%d) %s: " fmt, \ 83 83 + task_pid_nr(current), __func__, ##__VA_ARGS__) 96 84 97 85 #define JFFS2_NOTICE(fmt, ...) \ 98 98 - do { \ 99 99 - printk(JFFS2_NOTICE_MSG_PREFIX \ 100 100 - " (%d) %s: " fmt, task_pid_nr(current), \ 101 101 - __func__ , ##__VA_ARGS__); \ 102 102 - } while(0) 86 86 + pr_notice("notice: (%d) %s: " fmt, \ 87 87 + task_pid_nr(current), __func__, ##__VA_ARGS__) 103 88 104 89 #define JFFS2_DEBUG(fmt, ...) \ 105 105 - do { \ 106 106 - printk(JFFS2_DBG_MSG_PREFIX \ 107 107 - " (%d) %s: " fmt, task_pid_nr(current), \ 108 108 - __func__ , ##__VA_ARGS__); \ 109 109 - } while(0) 90 90 + printk(KERN_DEBUG "[JFFS2 DBG] (%d) %s: " fmt, \ 91 91 + task_pid_nr(current), __func__, ##__VA_ARGS__) 110 92 111 93 /* 112 94 * We split our debugging messages on several parts, depending on the JFFS2

+24 -17

fs/jffs2/dir.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/kernel.h> 14 16 #include <linux/slab.h> 15 17 #include <linux/fs.h> ··· 81 79 uint32_t ino = 0; 82 80 struct inode *inode = NULL; 83 81 84 84 - D1(printk(KERN_DEBUG "jffs2_lookup()\n")); 82 82 + jffs2_dbg(1, "jffs2_lookup()\n"); 85 83 86 84 if (target->d_name.len > JFFS2_MAX_NAME_LEN) 87 85 return ERR_PTR(-ENAMETOOLONG); ··· 105 103 if (ino) { 106 104 inode = jffs2_iget(dir_i->i_sb, ino); 107 105 if (IS_ERR(inode)) 108 108 - printk(KERN_WARNING "iget() failed for ino #%u\n", ino); 106 106 + pr_warn("iget() failed for ino #%u\n", ino); 109 107 } 110 108 111 109 return d_splice_alias(inode, target); ··· 121 119 struct jffs2_full_dirent *fd; 122 120 unsigned long offset, curofs; 123 121 124 124 - D1(printk(KERN_DEBUG "jffs2_readdir() for dir_i #%lu\n", filp->f_path.dentry->d_inode->i_ino)); 122 122 + jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", 123 123 + filp->f_path.dentry->d_inode->i_ino); 125 124 126 125 f = JFFS2_INODE_INFO(inode); 127 126 128 127 offset = filp->f_pos; 129 128 130 129 if (offset == 0) { 131 131 - D1(printk(KERN_DEBUG "Dirent 0: \".\", ino #%lu\n", inode->i_ino)); 130 130 + jffs2_dbg(1, "Dirent 0: \".\", ino #%lu\n", inode->i_ino); 132 131 if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0) 133 132 goto out; 134 133 offset++; 135 134 } 136 135 if (offset == 1) { 137 136 unsigned long pino = parent_ino(filp->f_path.dentry); 138 138 - D1(printk(KERN_DEBUG "Dirent 1: \"..\", ino #%lu\n", pino)); 137 137 + jffs2_dbg(1, "Dirent 1: \"..\", ino #%lu\n", pino); 139 138 if (filldir(dirent, "..", 2, 1, pino, DT_DIR) < 0) 140 139 goto out; 141 140 offset++; ··· 149 146 curofs++; 150 147 /* First loop: curofs = 2; offset = 2 */ 151 148 if (curofs < offset) { 152 152 - D2(printk(KERN_DEBUG "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 153 153 - fd->name, fd->ino, fd->type, curofs, offset)); 149 149 + jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n", 150 150 + fd->name, fd->ino, fd->type, curofs, offset); 154 151 continue; 155 152 } 156 153 if (!fd->ino) { 157 157 - D2(printk(KERN_DEBUG "Skipping deletion dirent \"%s\"\n", fd->name)); 154 154 + jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n", 155 155 + fd->name); 158 156 offset++; 159 157 continue; 160 158 } 161 161 - D2(printk(KERN_DEBUG "Dirent %ld: \"%s\", ino #%u, type %d\n", offset, fd->name, fd->ino, fd->type)); 159 159 + jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n", 160 160 + offset, fd->name, fd->ino, fd->type); 162 161 if (filldir(dirent, fd->name, strlen(fd->name), offset, fd->ino, fd->type) < 0) 163 162 break; 164 163 offset++; ··· 189 184 190 185 c = JFFS2_SB_INFO(dir_i->i_sb); 191 186 192 192 - D1(printk(KERN_DEBUG "jffs2_create()\n")); 187 187 + jffs2_dbg(1, "%s()\n", __func__); 193 188 194 189 inode = jffs2_new_inode(dir_i, mode, ri); 195 190 196 191 if (IS_ERR(inode)) { 197 197 - D1(printk(KERN_DEBUG "jffs2_new_inode() failed\n")); 192 192 + jffs2_dbg(1, "jffs2_new_inode() failed\n"); 198 193 jffs2_free_raw_inode(ri); 199 194 return PTR_ERR(inode); 200 195 } ··· 222 217 223 218 jffs2_free_raw_inode(ri); 224 219 225 225 - D1(printk(KERN_DEBUG "jffs2_create: Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 226 226 - inode->i_ino, inode->i_mode, inode->i_nlink, 227 227 - f->inocache->pino_nlink, inode->i_mapping->nrpages)); 220 220 + jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n", 221 221 + __func__, inode->i_ino, inode->i_mode, inode->i_nlink, 222 222 + f->inocache->pino_nlink, inode->i_mapping->nrpages); 228 223 229 224 d_instantiate(dentry, inode); 230 225 unlock_new_inode(inode); ··· 367 362 /* We use f->target field to store the target path. */ 368 363 f->target = kmemdup(target, targetlen + 1, GFP_KERNEL); 369 364 if (!f->target) { 370 370 - printk(KERN_WARNING "Can't allocate %d bytes of memory\n", targetlen + 1); 365 365 + pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1); 371 366 mutex_unlock(&f->sem); 372 367 jffs2_complete_reservation(c); 373 368 ret = -ENOMEM; 374 369 goto fail; 375 370 } 376 371 377 377 - D1(printk(KERN_DEBUG "jffs2_symlink: symlink's target '%s' cached\n", (char *)f->target)); 372 372 + jffs2_dbg(1, "%s(): symlink's target '%s' cached\n", 373 373 + __func__, (char *)f->target); 378 374 379 375 /* No data here. Only a metadata node, which will be 380 376 obsoleted by the first data write ··· 862 856 f->inocache->pino_nlink++; 863 857 mutex_unlock(&f->sem); 864 858 865 865 - printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret); 859 859 + pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n", 860 860 + __func__, ret); 866 861 /* Might as well let the VFS know */ 867 862 d_instantiate(new_dentry, old_dentry->d_inode); 868 863 ihold(old_dentry->d_inode);

+43 -29

fs/jffs2/erase.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/kernel.h> 14 16 #include <linux/slab.h> 15 17 #include <linux/mtd/mtd.h> ··· 48 46 #else /* Linux */ 49 47 struct erase_info *instr; 50 48 51 51 - D1(printk(KERN_DEBUG "jffs2_erase_block(): erase block %#08x (range %#08x-%#08x)\n", 52 52 - jeb->offset, jeb->offset, jeb->offset + c->sector_size)); 49 49 + jffs2_dbg(1, "%s(): erase block %#08x (range %#08x-%#08x)\n", 50 50 + __func__, 51 51 + jeb->offset, jeb->offset, jeb->offset + c->sector_size); 53 52 instr = kmalloc(sizeof(struct erase_info) + sizeof(struct erase_priv_struct), GFP_KERNEL); 54 53 if (!instr) { 55 55 - printk(KERN_WARNING "kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n"); 54 54 + pr_warn("kmalloc for struct erase_info in jffs2_erase_block failed. Refiling block for later\n"); 56 55 mutex_lock(&c->erase_free_sem); 57 56 spin_lock(&c->erase_completion_lock); 58 57 list_move(&jeb->list, &c->erase_pending_list); ··· 72 69 instr->len = c->sector_size; 73 70 instr->callback = jffs2_erase_callback; 74 71 instr->priv = (unsigned long)(&instr[1]); 75 75 - instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN; 76 72 77 73 ((struct erase_priv_struct *)instr->priv)->jeb = jeb; 78 74 ((struct erase_priv_struct *)instr->priv)->c = c; ··· 86 84 87 85 if (ret == -ENOMEM || ret == -EAGAIN) { 88 86 /* Erase failed immediately. Refile it on the list */ 89 89 - D1(printk(KERN_DEBUG "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n", jeb->offset, ret)); 87 87 + jffs2_dbg(1, "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n", 88 88 + jeb->offset, ret); 90 89 mutex_lock(&c->erase_free_sem); 91 90 spin_lock(&c->erase_completion_lock); 92 91 list_move(&jeb->list, &c->erase_pending_list); ··· 100 97 } 101 98 102 99 if (ret == -EROFS) 103 103 - printk(KERN_WARNING "Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n", jeb->offset); 100 100 + pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n", 101 101 + jeb->offset); 104 102 else 105 105 - printk(KERN_WARNING "Erase at 0x%08x failed immediately: errno %d\n", jeb->offset, ret); 103 103 + pr_warn("Erase at 0x%08x failed immediately: errno %d\n", 104 104 + jeb->offset, ret); 106 105 107 106 jffs2_erase_failed(c, jeb, bad_offset); 108 107 } ··· 130 125 131 126 work_done++; 132 127 if (!--count) { 133 133 - D1(printk(KERN_DEBUG "Count reached. jffs2_erase_pending_blocks leaving\n")); 128 128 + jffs2_dbg(1, "Count reached. jffs2_erase_pending_blocks leaving\n"); 134 129 goto done; 135 130 } 136 131 137 132 } else if (!list_empty(&c->erase_pending_list)) { 138 133 jeb = list_entry(c->erase_pending_list.next, struct jffs2_eraseblock, list); 139 139 - D1(printk(KERN_DEBUG "Starting erase of pending block 0x%08x\n", jeb->offset)); 134 134 + jffs2_dbg(1, "Starting erase of pending block 0x%08x\n", 135 135 + jeb->offset); 140 136 list_del(&jeb->list); 141 137 c->erasing_size += c->sector_size; 142 138 c->wasted_size -= jeb->wasted_size; ··· 165 159 spin_unlock(&c->erase_completion_lock); 166 160 mutex_unlock(&c->erase_free_sem); 167 161 done: 168 168 - D1(printk(KERN_DEBUG "jffs2_erase_pending_blocks completed\n")); 162 162 + jffs2_dbg(1, "jffs2_erase_pending_blocks completed\n"); 169 163 return work_done; 170 164 } 171 165 172 166 static void jffs2_erase_succeeded(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 173 167 { 174 174 - D1(printk(KERN_DEBUG "Erase completed successfully at 0x%08x\n", jeb->offset)); 168 168 + jffs2_dbg(1, "Erase completed successfully at 0x%08x\n", jeb->offset); 175 169 mutex_lock(&c->erase_free_sem); 176 170 spin_lock(&c->erase_completion_lock); 177 171 list_move_tail(&jeb->list, &c->erase_complete_list); ··· 220 214 struct erase_priv_struct *priv = (void *)instr->priv; 221 215 222 216 if(instr->state != MTD_ERASE_DONE) { 223 223 - printk(KERN_WARNING "Erase at 0x%08llx finished, but state != MTD_ERASE_DONE. State is 0x%x instead.\n", 217 217 + pr_warn("Erase at 0x%08llx finished, but state != MTD_ERASE_DONE. State is 0x%x instead.\n", 224 218 (unsigned long long)instr->addr, instr->state); 225 219 jffs2_erase_failed(priv->c, priv->jeb, instr->fail_addr); 226 220 } else { ··· 275 269 return; 276 270 } 277 271 278 278 - D1(printk(KERN_DEBUG "Removed nodes in range 0x%08x-0x%08x from ino #%u\n", 279 279 - jeb->offset, jeb->offset + c->sector_size, ic->ino)); 272 272 + jffs2_dbg(1, "Removed nodes in range 0x%08x-0x%08x from ino #%u\n", 273 273 + jeb->offset, jeb->offset + c->sector_size, ic->ino); 280 274 281 275 D2({ 282 276 int i=0; ··· 287 281 288 282 printk(KERN_DEBUG); 289 283 while(this) { 290 290 - printk(KERN_CONT "0x%08x(%d)->", 284 284 + pr_cont("0x%08x(%d)->", 291 285 ref_offset(this), ref_flags(this)); 292 286 if (++i == 5) { 293 287 printk(KERN_DEBUG); ··· 295 289 } 296 290 this = this->next_in_ino; 297 291 } 298 298 - printk(KERN_CONT "\n"); 292 292 + pr_cont("\n"); 299 293 }); 300 294 301 295 switch (ic->class) { ··· 316 310 void jffs2_free_jeb_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 317 311 { 318 312 struct jffs2_raw_node_ref *block, *ref; 319 319 - D1(printk(KERN_DEBUG "Freeing all node refs for eraseblock offset 0x%08x\n", jeb->offset)); 313 313 + jffs2_dbg(1, "Freeing all node refs for eraseblock offset 0x%08x\n", 314 314 + jeb->offset); 320 315 321 316 block = ref = jeb->first_node; 322 317 ··· 349 342 &ebuf, NULL); 350 343 if (ret != -EOPNOTSUPP) { 351 344 if (ret) { 352 352 - D1(printk(KERN_DEBUG "MTD point failed %d\n", ret)); 345 345 + jffs2_dbg(1, "MTD point failed %d\n", ret); 353 346 goto do_flash_read; 354 347 } 355 348 if (retlen < c->sector_size) { 356 349 /* Don't muck about if it won't let us point to the whole erase sector */ 357 357 - D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", retlen)); 350 350 + jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n", 351 351 + retlen); 358 352 mtd_unpoint(c->mtd, jeb->offset, retlen); 359 353 goto do_flash_read; 360 354 } ··· 367 359 } while(--retlen); 368 360 mtd_unpoint(c->mtd, jeb->offset, c->sector_size); 369 361 if (retlen) { 370 370 - printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08tx\n", 371 371 - *wordebuf, jeb->offset + c->sector_size-retlen*sizeof(*wordebuf)); 362 362 + pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08tx\n", 363 363 + *wordebuf, 364 364 + jeb->offset + 365 365 + c->sector_size-retlen * sizeof(*wordebuf)); 372 366 return -EIO; 373 367 } 374 368 return 0; ··· 378 368 do_flash_read: 379 369 ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL); 380 370 if (!ebuf) { 381 381 - printk(KERN_WARNING "Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", jeb->offset); 371 371 + pr_warn("Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", 372 372 + jeb->offset); 382 373 return -EAGAIN; 383 374 } 384 375 385 385 - D1(printk(KERN_DEBUG "Verifying erase at 0x%08x\n", jeb->offset)); 376 376 + jffs2_dbg(1, "Verifying erase at 0x%08x\n", jeb->offset); 386 377 387 378 for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) { 388 379 uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs); ··· 393 382 394 383 ret = mtd_read(c->mtd, ofs, readlen, &retlen, ebuf); 395 384 if (ret) { 396 396 - printk(KERN_WARNING "Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", ofs, ret); 385 385 + pr_warn("Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", 386 386 + ofs, ret); 397 387 ret = -EIO; 398 388 goto fail; 399 389 } 400 390 if (retlen != readlen) { 401 401 - printk(KERN_WARNING "Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n", ofs, readlen, retlen); 391 391 + pr_warn("Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n", 392 392 + ofs, readlen, retlen); 402 393 ret = -EIO; 403 394 goto fail; 404 395 } ··· 409 396 unsigned long *datum = ebuf + i; 410 397 if (*datum + 1) { 411 398 *bad_offset += i; 412 412 - printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08x\n", *datum, *bad_offset); 399 399 + pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08x\n", 400 400 + *datum, *bad_offset); 413 401 ret = -EIO; 414 402 goto fail; 415 403 } ··· 436 422 } 437 423 438 424 /* Write the erase complete marker */ 439 439 - D1(printk(KERN_DEBUG "Writing erased marker to block at 0x%08x\n", jeb->offset)); 425 425 + jffs2_dbg(1, "Writing erased marker to block at 0x%08x\n", jeb->offset); 440 426 bad_offset = jeb->offset; 441 427 442 428 /* Cleanmarker in oob area or no cleanmarker at all ? */ ··· 465 451 466 452 if (ret || retlen != sizeof(marker)) { 467 453 if (ret) 468 468 - printk(KERN_WARNING "Write clean marker to block at 0x%08x failed: %d\n", 454 454 + pr_warn("Write clean marker to block at 0x%08x failed: %d\n", 469 455 jeb->offset, ret); 470 456 else 471 471 - printk(KERN_WARNING "Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n", 457 457 + pr_warn("Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n", 472 458 jeb->offset, sizeof(marker), retlen); 473 459 474 460 goto filebad;

+20 -13

fs/jffs2/file.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/kernel.h> 14 16 #include <linux/fs.h> 15 17 #include <linux/time.h> ··· 87 85 unsigned char *pg_buf; 88 86 int ret; 89 87 90 90 - D2(printk(KERN_DEBUG "jffs2_do_readpage_nolock(): ino #%lu, page at offset 0x%lx\n", inode->i_ino, pg->index << PAGE_CACHE_SHIFT)); 88 88 + jffs2_dbg(2, "%s(): ino #%lu, page at offset 0x%lx\n", 89 89 + __func__, inode->i_ino, pg->index << PAGE_CACHE_SHIFT); 91 90 92 91 BUG_ON(!PageLocked(pg)); 93 92 ··· 108 105 flush_dcache_page(pg); 109 106 kunmap(pg); 110 107 111 111 - D2(printk(KERN_DEBUG "readpage finished\n")); 108 108 + jffs2_dbg(2, "readpage finished\n"); 112 109 return ret; 113 110 } 114 111 ··· 147 144 return -ENOMEM; 148 145 *pagep = pg; 149 146 150 150 - D1(printk(KERN_DEBUG "jffs2_write_begin()\n")); 147 147 + jffs2_dbg(1, "%s()\n", __func__); 151 148 152 149 if (pageofs > inode->i_size) { 153 150 /* Make new hole frag from old EOF to new page */ ··· 156 153 struct jffs2_full_dnode *fn; 157 154 uint32_t alloc_len; 158 155 159 159 - D1(printk(KERN_DEBUG "Writing new hole frag 0x%x-0x%x between current EOF and new page\n", 160 160 - (unsigned int)inode->i_size, pageofs)); 156 156 + jffs2_dbg(1, "Writing new hole frag 0x%x-0x%x between current EOF and new page\n", 157 157 + (unsigned int)inode->i_size, pageofs); 161 158 162 159 ret = jffs2_reserve_space(c, sizeof(ri), &alloc_len, 163 160 ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); ··· 201 198 f->metadata = NULL; 202 199 } 203 200 if (ret) { 204 204 - D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in write_begin, returned %d\n", ret)); 201 201 + jffs2_dbg(1, "Eep. add_full_dnode_to_inode() failed in write_begin, returned %d\n", 202 202 + ret); 205 203 jffs2_mark_node_obsolete(c, fn->raw); 206 204 jffs2_free_full_dnode(fn); 207 205 jffs2_complete_reservation(c); ··· 226 222 if (ret) 227 223 goto out_page; 228 224 } 229 229 - D1(printk(KERN_DEBUG "end write_begin(). pg->flags %lx\n", pg->flags)); 225 225 + jffs2_dbg(1, "end write_begin(). pg->flags %lx\n", pg->flags); 230 226 return ret; 231 227 232 228 out_page: ··· 252 248 int ret = 0; 253 249 uint32_t writtenlen = 0; 254 250 255 255 - D1(printk(KERN_DEBUG "jffs2_write_end(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n", 256 256 - inode->i_ino, pg->index << PAGE_CACHE_SHIFT, start, end, pg->flags)); 251 251 + jffs2_dbg(1, "%s(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n", 252 252 + __func__, inode->i_ino, pg->index << PAGE_CACHE_SHIFT, 253 253 + start, end, pg->flags); 257 254 258 255 /* We need to avoid deadlock with page_cache_read() in 259 256 jffs2_garbage_collect_pass(). So the page must be ··· 273 268 ri = jffs2_alloc_raw_inode(); 274 269 275 270 if (!ri) { 276 276 - D1(printk(KERN_DEBUG "jffs2_write_end(): Allocation of raw inode failed\n")); 271 271 + jffs2_dbg(1, "%s(): Allocation of raw inode failed\n", 272 272 + __func__); 277 273 unlock_page(pg); 278 274 page_cache_release(pg); 279 275 return -ENOMEM; ··· 321 315 /* generic_file_write has written more to the page cache than we've 322 316 actually written to the medium. Mark the page !Uptodate so that 323 317 it gets reread */ 324 324 - D1(printk(KERN_DEBUG "jffs2_write_end(): Not all bytes written. Marking page !uptodate\n")); 318 318 + jffs2_dbg(1, "%s(): Not all bytes written. Marking page !uptodate\n", 319 319 + __func__); 325 320 SetPageError(pg); 326 321 ClearPageUptodate(pg); 327 322 } 328 323 329 329 - D1(printk(KERN_DEBUG "jffs2_write_end() returning %d\n", 330 330 - writtenlen > 0 ? writtenlen : ret)); 324 324 + jffs2_dbg(1, "%s() returning %d\n", 325 325 + __func__, writtenlen > 0 ? writtenlen : ret); 331 326 unlock_page(pg); 332 327 page_cache_release(pg); 333 328 return writtenlen > 0 ? writtenlen : ret;

+40 -27

fs/jffs2/fs.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/capability.h> 14 16 #include <linux/kernel.h> 15 17 #include <linux/sched.h> ··· 41 39 int ret; 42 40 int alloc_type = ALLOC_NORMAL; 43 41 44 44 - D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino)); 42 42 + jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino); 45 43 46 44 /* Special cases - we don't want more than one data node 47 45 for these types on the medium at any time. So setattr ··· 52 50 /* For these, we don't actually need to read the old node */ 53 51 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev); 54 52 mdata = (char *)&dev; 55 55 - D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen)); 53 53 + jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n", 54 54 + __func__, mdatalen); 56 55 } else if (S_ISLNK(inode->i_mode)) { 57 56 mutex_lock(&f->sem); 58 57 mdatalen = f->metadata->size; ··· 69 66 return ret; 70 67 } 71 68 mutex_unlock(&f->sem); 72 72 - D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen)); 69 69 + jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n", 70 70 + __func__, mdatalen); 73 71 } 74 72 75 73 ri = jffs2_alloc_raw_inode(); ··· 237 233 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 238 234 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 239 235 240 240 - D1(printk(KERN_DEBUG "jffs2_evict_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode)); 236 236 + jffs2_dbg(1, "%s(): ino #%lu mode %o\n", 237 237 + __func__, inode->i_ino, inode->i_mode); 241 238 truncate_inode_pages(&inode->i_data, 0); 242 239 end_writeback(inode); 243 240 jffs2_do_clear_inode(c, f); ··· 254 249 dev_t rdev = 0; 255 250 int ret; 256 251 257 257 - D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino)); 252 252 + jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino); 258 253 259 254 inode = iget_locked(sb, ino); 260 255 if (!inode) ··· 322 317 /* Read the device numbers from the media */ 323 318 if (f->metadata->size != sizeof(jdev.old_id) && 324 319 f->metadata->size != sizeof(jdev.new_id)) { 325 325 - printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size); 320 320 + pr_notice("Device node has strange size %d\n", 321 321 + f->metadata->size); 326 322 goto error_io; 327 323 } 328 328 - D1(printk(KERN_DEBUG "Reading device numbers from flash\n")); 324 324 + jffs2_dbg(1, "Reading device numbers from flash\n"); 329 325 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size); 330 326 if (ret < 0) { 331 327 /* Eep */ 332 332 - printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino); 328 328 + pr_notice("Read device numbers for inode %lu failed\n", 329 329 + (unsigned long)inode->i_ino); 333 330 goto error; 334 331 } 335 332 if (f->metadata->size == sizeof(jdev.old_id)) ··· 346 339 break; 347 340 348 341 default: 349 349 - printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino); 342 342 + pr_warn("%s(): Bogus i_mode %o for ino %lu\n", 343 343 + __func__, inode->i_mode, (unsigned long)inode->i_ino); 350 344 } 351 345 352 346 mutex_unlock(&f->sem); 353 347 354 354 - D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n")); 348 348 + jffs2_dbg(1, "jffs2_read_inode() returning\n"); 355 349 unlock_new_inode(inode); 356 350 return inode; 357 351 ··· 370 362 struct iattr iattr; 371 363 372 364 if (!(inode->i_state & I_DIRTY_DATASYNC)) { 373 373 - D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino)); 365 365 + jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n", 366 366 + __func__, inode->i_ino); 374 367 return; 375 368 } 376 369 377 377 - D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino)); 370 370 + jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n", 371 371 + __func__, inode->i_ino); 378 372 379 373 iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME; 380 374 iattr.ia_mode = inode->i_mode; ··· 424 414 struct jffs2_inode_info *f; 425 415 int ret; 426 416 427 427 - D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode)); 417 417 + jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n", 418 418 + __func__, dir_i->i_ino, mode); 428 419 429 420 c = JFFS2_SB_INFO(sb); 430 421 ··· 515 504 516 505 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER 517 506 if (c->mtd->type == MTD_NANDFLASH) { 518 518 - printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n"); 507 507 + pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n"); 519 508 return -EINVAL; 520 509 } 521 510 if (c->mtd->type == MTD_DATAFLASH) { 522 522 - printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n"); 511 511 + pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n"); 523 512 return -EINVAL; 524 513 } 525 514 #endif ··· 533 522 */ 534 523 if ((c->sector_size * blocks) != c->flash_size) { 535 524 c->flash_size = c->sector_size * blocks; 536 536 - printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n", 525 525 + pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n", 537 526 c->flash_size / 1024); 538 527 } 539 528 540 529 if (c->flash_size < 5*c->sector_size) { 541 541 - printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size); 530 530 + pr_err("Too few erase blocks (%d)\n", 531 531 + c->flash_size / c->sector_size); 542 532 return -EINVAL; 543 533 } 544 534 ··· 562 550 if ((ret = jffs2_do_mount_fs(c))) 563 551 goto out_inohash; 564 552 565 565 - D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n")); 553 553 + jffs2_dbg(1, "%s(): Getting root inode\n", __func__); 566 554 root_i = jffs2_iget(sb, 1); 567 555 if (IS_ERR(root_i)) { 568 568 - D1(printk(KERN_WARNING "get root inode failed\n")); 556 556 + jffs2_dbg(1, "get root inode failed\n"); 569 557 ret = PTR_ERR(root_i); 570 558 goto out_root; 571 559 } 572 560 573 561 ret = -ENOMEM; 574 562 575 575 - D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n")); 563 563 + jffs2_dbg(1, "%s(): d_make_root()\n", __func__); 576 564 sb->s_root = d_make_root(root_i); 577 565 if (!sb->s_root) 578 566 goto out_root; ··· 630 618 */ 631 619 inode = ilookup(OFNI_BS_2SFFJ(c), inum); 632 620 if (!inode) { 633 633 - D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n", 634 634 - inum)); 621 621 + jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n", 622 622 + inum); 635 623 636 624 spin_lock(&c->inocache_lock); 637 625 ic = jffs2_get_ino_cache(c, inum); 638 626 if (!ic) { 639 639 - D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum)); 627 627 + jffs2_dbg(1, "Inode cache for ino #%u is gone\n", 628 628 + inum); 640 629 spin_unlock(&c->inocache_lock); 641 630 return NULL; 642 631 } 643 632 if (ic->state != INO_STATE_CHECKEDABSENT) { 644 633 /* Wait for progress. Don't just loop */ 645 645 - D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n", 646 646 - ic->ino, ic->state)); 634 634 + jffs2_dbg(1, "Waiting for ino #%u in state %d\n", 635 635 + ic->ino, ic->state); 647 636 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 648 637 } else { 649 638 spin_unlock(&c->inocache_lock); ··· 662 649 return ERR_CAST(inode); 663 650 } 664 651 if (is_bad_inode(inode)) { 665 665 - printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. unlinked %d\n", 666 666 - inum, unlinked); 652 652 + pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n", 653 653 + inum, unlinked); 667 654 /* NB. This will happen again. We need to do something appropriate here. */ 668 655 iput(inode); 669 656 return ERR_PTR(-EIO);

+187 -135

fs/jffs2/gc.c

reviewed

··· 10 10 * 11 11 */ 12 12 13 13 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 14 + 13 15 #include <linux/kernel.h> 14 16 #include <linux/mtd/mtd.h> 15 17 #include <linux/slab.h> ··· 53 51 number of free blocks is low. */ 54 52 again: 55 53 if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) { 56 56 - D1(printk(KERN_DEBUG "Picking block from bad_used_list to GC next\n")); 54 54 + jffs2_dbg(1, "Picking block from bad_used_list to GC next\n"); 57 55 nextlist = &c->bad_used_list; 58 56 } else if (n < 50 && !list_empty(&c->erasable_list)) { 59 57 /* Note that most of them will have gone directly to be erased. 60 58 So don't favour the erasable_list _too_ much. */ 61 61 - D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next\n")); 59 59 + jffs2_dbg(1, "Picking block from erasable_list to GC next\n"); 62 60 nextlist = &c->erasable_list; 63 61 } else if (n < 110 && !list_empty(&c->very_dirty_list)) { 64 62 /* Most of the time, pick one off the very_dirty list */ 65 65 - D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next\n")); 63 63 + jffs2_dbg(1, "Picking block from very_dirty_list to GC next\n"); 66 64 nextlist = &c->very_dirty_list; 67 65 } else if (n < 126 && !list_empty(&c->dirty_list)) { 68 68 - D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next\n")); 66 66 + jffs2_dbg(1, "Picking block from dirty_list to GC next\n"); 69 67 nextlist = &c->dirty_list; 70 68 } else if (!list_empty(&c->clean_list)) { 71 71 - D1(printk(KERN_DEBUG "Picking block from clean_list to GC next\n")); 69 69 + jffs2_dbg(1, "Picking block from clean_list to GC next\n"); 72 70 nextlist = &c->clean_list; 73 71 } else if (!list_empty(&c->dirty_list)) { 74 74 - D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next (clean_list was empty)\n")); 72 72 + jffs2_dbg(1, "Picking block from dirty_list to GC next (clean_list was empty)\n"); 75 73 76 74 nextlist = &c->dirty_list; 77 75 } else if (!list_empty(&c->very_dirty_list)) { 78 78 - D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n")); 76 76 + jffs2_dbg(1, "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n"); 79 77 nextlist = &c->very_dirty_list; 80 78 } else if (!list_empty(&c->erasable_list)) { 81 81 - D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n")); 79 79 + jffs2_dbg(1, "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n"); 82 80 83 81 nextlist = &c->erasable_list; 84 82 } else if (!list_empty(&c->erasable_pending_wbuf_list)) { 85 83 /* There are blocks are wating for the wbuf sync */ 86 86 - D1(printk(KERN_DEBUG "Synching wbuf in order to reuse erasable_pending_wbuf_list blocks\n")); 84 84 + jffs2_dbg(1, "Synching wbuf in order to reuse erasable_pending_wbuf_list blocks\n"); 87 85 spin_unlock(&c->erase_completion_lock); 88 86 jffs2_flush_wbuf_pad(c); 89 87 spin_lock(&c->erase_completion_lock); 90 88 goto again; 91 89 } else { 92 90 /* Eep. All were empty */ 93 93 - D1(printk(KERN_NOTICE "jffs2: No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n")); 91 91 + jffs2_dbg(1, "No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n"); 94 92 return NULL; 95 93 } 96 94 ··· 99 97 c->gcblock = ret; 100 98 ret->gc_node = ret->first_node; 101 99 if (!ret->gc_node) { 102 102 - printk(KERN_WARNING "Eep. ret->gc_node for block at 0x%08x is NULL\n", ret->offset); 100 100 + pr_warn("Eep. ret->gc_node for block at 0x%08x is NULL\n", 101 101 + ret->offset); 103 102 BUG(); 104 103 } 105 104 106 105 /* Have we accidentally picked a clean block with wasted space ? */ 107 106 if (ret->wasted_size) { 108 108 - D1(printk(KERN_DEBUG "Converting wasted_size %08x to dirty_size\n", ret->wasted_size)); 107 107 + jffs2_dbg(1, "Converting wasted_size %08x to dirty_size\n", 108 108 + ret->wasted_size); 109 109 ret->dirty_size += ret->wasted_size; 110 110 c->wasted_size -= ret->wasted_size; 111 111 c->dirty_size += ret->wasted_size; ··· 144 140 145 141 /* checked_ino is protected by the alloc_sem */ 146 142 if (c->checked_ino > c->highest_ino && xattr) { 147 147 - printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n", 148 148 - c->unchecked_size); 143 143 + pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n", 144 144 + c->unchecked_size); 149 145 jffs2_dbg_dump_block_lists_nolock(c); 150 146 spin_unlock(&c->erase_completion_lock); 151 147 mutex_unlock(&c->alloc_sem); ··· 167 163 } 168 164 169 165 if (!ic->pino_nlink) { 170 170 - D1(printk(KERN_DEBUG "Skipping check of ino #%d with nlink/pino zero\n", 171 171 - ic->ino)); 166 166 + jffs2_dbg(1, "Skipping check of ino #%d with nlink/pino zero\n", 167 167 + ic->ino); 172 168 spin_unlock(&c->inocache_lock); 173 169 jffs2_xattr_delete_inode(c, ic); 174 170 continue; ··· 176 172 switch(ic->state) { 177 173 case INO_STATE_CHECKEDABSENT: 178 174 case INO_STATE_PRESENT: 179 179 - D1(printk(KERN_DEBUG "Skipping ino #%u already checked\n", ic->ino)); 175 175 + jffs2_dbg(1, "Skipping ino #%u already checked\n", 176 176 + ic->ino); 180 177 spin_unlock(&c->inocache_lock); 181 178 continue; 182 179 183 180 case INO_STATE_GC: 184 181 case INO_STATE_CHECKING: 185 185 - printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state); 182 182 + pr_warn("Inode #%u is in state %d during CRC check phase!\n", 183 183 + ic->ino, ic->state); 186 184 spin_unlock(&c->inocache_lock); 187 185 BUG(); 188 186 ··· 192 186 /* We need to wait for it to finish, lest we move on 193 187 and trigger the BUG() above while we haven't yet 194 188 finished checking all its nodes */ 195 195 - D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino)); 189 189 + jffs2_dbg(1, "Waiting for ino #%u to finish reading\n", 190 190 + ic->ino); 196 191 /* We need to come back again for the _same_ inode. We've 197 192 made no progress in this case, but that should be OK */ 198 193 c->checked_ino--; ··· 211 204 ic->state = INO_STATE_CHECKING; 212 205 spin_unlock(&c->inocache_lock); 213 206 214 214 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() triggering inode scan of ino#%u\n", ic->ino)); 207 207 + jffs2_dbg(1, "%s(): triggering inode scan of ino#%u\n", 208 208 + __func__, ic->ino); 215 209 216 210 ret = jffs2_do_crccheck_inode(c, ic); 217 211 if (ret) 218 218 - printk(KERN_WARNING "Returned error for crccheck of ino #%u. Expect badness...\n", ic->ino); 212 212 + pr_warn("Returned error for crccheck of ino #%u. Expect badness...\n", 213 213 + ic->ino); 219 214 220 215 jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT); 221 216 mutex_unlock(&c->alloc_sem); ··· 229 220 !list_empty(&c->erase_pending_list)) { 230 221 spin_unlock(&c->erase_completion_lock); 231 222 mutex_unlock(&c->alloc_sem); 232 232 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() erasing pending blocks\n")); 223 223 + jffs2_dbg(1, "%s(): erasing pending blocks\n", __func__); 233 224 if (jffs2_erase_pending_blocks(c, 1)) 234 225 return 0; 235 226 236 236 - D1(printk(KERN_DEBUG "No progress from erasing blocks; doing GC anyway\n")); 227 227 + jffs2_dbg(1, "No progress from erasing block; doing GC anyway\n"); 237 228 spin_lock(&c->erase_completion_lock); 238 229 mutex_lock(&c->alloc_sem); 239 230 } ··· 251 242 mutex_unlock(&c->alloc_sem); 252 243 return -EAGAIN; 253 244 } 254 254 - D1(printk(KERN_NOTICE "jffs2: Couldn't find erase block to garbage collect!\n")); 245 245 + jffs2_dbg(1, "Couldn't find erase block to garbage collect!\n"); 255 246 spin_unlock(&c->erase_completion_lock); 256 247 mutex_unlock(&c->alloc_sem); 257 248 return -EIO; 258 249 } 259 250 260 260 - D1(printk(KERN_DEBUG "GC from block %08x, used_size %08x, dirty_size %08x, free_size %08x\n", jeb->offset, jeb->used_size, jeb->dirty_size, jeb->free_size)); 251 251 + jffs2_dbg(1, "GC from block %08x, used_size %08x, dirty_size %08x, free_size %08x\n", 252 252 + jeb->offset, jeb->used_size, jeb->dirty_size, jeb->free_size); 261 253 D1(if (c->nextblock) 262 254 printk(KERN_DEBUG "Nextblock at %08x, used_size %08x, dirty_size %08x, wasted_size %08x, free_size %08x\n", c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->free_size)); 263 255 ··· 271 261 gcblock_dirty = jeb->dirty_size; 272 262 273 263 while(ref_obsolete(raw)) { 274 274 - D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw))); 264 264 + jffs2_dbg(1, "Node at 0x%08x is obsolete... skipping\n", 265 265 + ref_offset(raw)); 275 266 raw = ref_next(raw); 276 267 if (unlikely(!raw)) { 277 277 - printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n"); 278 278 - printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n", 279 279 - jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size); 268 268 + pr_warn("eep. End of raw list while still supposedly nodes to GC\n"); 269 269 + pr_warn("erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n", 270 270 + jeb->offset, jeb->free_size, 271 271 + jeb->dirty_size, jeb->used_size); 280 272 jeb->gc_node = raw; 281 273 spin_unlock(&c->erase_completion_lock); 282 274 mutex_unlock(&c->alloc_sem); ··· 287 275 } 288 276 jeb->gc_node = raw; 289 277 290 290 - D1(printk(KERN_DEBUG "Going to garbage collect node at 0x%08x\n", ref_offset(raw))); 278 278 + jffs2_dbg(1, "Going to garbage collect node at 0x%08x\n", 279 279 + ref_offset(raw)); 291 280 292 281 if (!raw->next_in_ino) { 293 282 /* Inode-less node. Clean marker, snapshot or something like that */ ··· 329 316 330 317 spin_unlock(&c->erase_completion_lock); 331 318 332 332 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n", jeb->offset, ref_offset(raw), ref_flags(raw), ic->ino)); 319 319 + jffs2_dbg(1, "%s(): collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n", 320 320 + __func__, jeb->offset, ref_offset(raw), ref_flags(raw), 321 321 + ic->ino); 333 322 334 323 /* Three possibilities: 335 324 1. Inode is already in-core. We must iget it and do proper ··· 351 336 if (ref_flags(raw) == REF_PRISTINE) 352 337 ic->state = INO_STATE_GC; 353 338 else { 354 354 - D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n", 355 355 - ic->ino)); 339 339 + jffs2_dbg(1, "Ino #%u is absent but node not REF_PRISTINE. Reading.\n", 340 340 + ic->ino); 356 341 } 357 342 break; 358 343 ··· 368 353 we're holding the alloc_sem, no other garbage collection 369 354 can happen. 370 355 */ 371 371 - printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n", 372 372 - ic->ino, ic->state); 356 356 + pr_crit("Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n", 357 357 + ic->ino, ic->state); 373 358 mutex_unlock(&c->alloc_sem); 374 359 spin_unlock(&c->inocache_lock); 375 360 BUG(); ··· 382 367 drop the alloc_sem before sleeping. */ 383 368 384 369 mutex_unlock(&c->alloc_sem); 385 385 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n", 386 386 - ic->ino, ic->state)); 370 370 + jffs2_dbg(1, "%s(): waiting for ino #%u in state %d\n", 371 371 + __func__, ic->ino, ic->state); 387 372 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock); 388 373 /* And because we dropped the alloc_sem we must start again from the 389 374 beginning. Ponder chance of livelock here -- we're returning success ··· 448 433 test_gcnode: 449 434 if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) { 450 435 /* Eep. This really should never happen. GC is broken */ 451 451 - printk(KERN_ERR "Error garbage collecting node at %08x!\n", ref_offset(jeb->gc_node)); 436 436 + pr_err("Error garbage collecting node at %08x!\n", 437 437 + ref_offset(jeb->gc_node)); 452 438 ret = -ENOSPC; 453 439 } 454 440 release_sem: ··· 461 445 462 446 eraseit: 463 447 if (c->gcblock && !c->gcblock->used_size) { 464 464 - D1(printk(KERN_DEBUG "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", c->gcblock->offset)); 448 448 + jffs2_dbg(1, "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", 449 449 + c->gcblock->offset); 465 450 /* We're GC'ing an empty block? */ 466 451 list_add_tail(&c->gcblock->list, &c->erase_pending_list); 467 452 c->gcblock = NULL; ··· 492 475 493 476 if (c->gcblock != jeb) { 494 477 spin_unlock(&c->erase_completion_lock); 495 495 - D1(printk(KERN_DEBUG "GC block is no longer gcblock. Restart\n")); 478 478 + jffs2_dbg(1, "GC block is no longer gcblock. Restart\n"); 496 479 goto upnout; 497 480 } 498 481 if (ref_obsolete(raw)) { 499 482 spin_unlock(&c->erase_completion_lock); 500 500 - D1(printk(KERN_DEBUG "node to be GC'd was obsoleted in the meantime.\n")); 483 483 + jffs2_dbg(1, "node to be GC'd was obsoleted in the meantime.\n"); 501 484 /* They'll call again */ 502 485 goto upnout; 503 486 } ··· 553 536 } else if (fd) { 554 537 ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd); 555 538 } else { 556 556 - printk(KERN_WARNING "Raw node at 0x%08x wasn't in node lists for ino #%u\n", 557 557 - ref_offset(raw), f->inocache->ino); 539 539 + pr_warn("Raw node at 0x%08x wasn't in node lists for ino #%u\n", 540 540 + ref_offset(raw), f->inocache->ino); 558 541 if (ref_obsolete(raw)) { 559 559 - printk(KERN_WARNING "But it's obsolete so we don't mind too much\n"); 542 542 + pr_warn("But it's obsolete so we don't mind too much\n"); 560 543 } else { 561 544 jffs2_dbg_dump_node(c, ref_offset(raw)); 562 545 BUG(); ··· 579 562 uint32_t crc, rawlen; 580 563 int retried = 0; 581 564 582 582 - D1(printk(KERN_DEBUG "Going to GC REF_PRISTINE node at 0x%08x\n", ref_offset(raw))); 565 565 + jffs2_dbg(1, "Going to GC REF_PRISTINE node at 0x%08x\n", 566 566 + ref_offset(raw)); 583 567 584 568 alloclen = rawlen = ref_totlen(c, c->gcblock, raw); 585 569 ··· 613 595 614 596 crc = crc32(0, node, sizeof(struct jffs2_unknown_node)-4); 615 597 if (je32_to_cpu(node->u.hdr_crc) != crc) { 616 616 - printk(KERN_WARNING "Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 617 617 - ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc); 598 598 + pr_warn("Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 599 599 + ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc); 618 600 goto bail; 619 601 } 620 602 ··· 622 604 case JFFS2_NODETYPE_INODE: 623 605 crc = crc32(0, node, sizeof(node->i)-8); 624 606 if (je32_to_cpu(node->i.node_crc) != crc) { 625 625 - printk(KERN_WARNING "Node CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 626 626 - ref_offset(raw), je32_to_cpu(node->i.node_crc), crc); 607 607 + pr_warn("Node CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 608 608 + ref_offset(raw), je32_to_cpu(node->i.node_crc), 609 609 + crc); 627 610 goto bail; 628 611 } 629 612 630 613 if (je32_to_cpu(node->i.dsize)) { 631 614 crc = crc32(0, node->i.data, je32_to_cpu(node->i.csize)); 632 615 if (je32_to_cpu(node->i.data_crc) != crc) { 633 633 - printk(KERN_WARNING "Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 634 634 - ref_offset(raw), je32_to_cpu(node->i.data_crc), crc); 616 616 + pr_warn("Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 617 617 + ref_offset(raw), 618 618 + je32_to_cpu(node->i.data_crc), crc); 635 619 goto bail; 636 620 } 637 621 } ··· 642 622 case JFFS2_NODETYPE_DIRENT: 643 623 crc = crc32(0, node, sizeof(node->d)-8); 644 624 if (je32_to_cpu(node->d.node_crc) != crc) { 645 645 - printk(KERN_WARNING "Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 646 646 - ref_offset(raw), je32_to_cpu(node->d.node_crc), crc); 625 625 + pr_warn("Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 626 626 + ref_offset(raw), 627 627 + je32_to_cpu(node->d.node_crc), crc); 647 628 goto bail; 648 629 } 649 630 650 631 if (strnlen(node->d.name, node->d.nsize) != node->d.nsize) { 651 651 - printk(KERN_WARNING "Name in dirent node at 0x%08x contains zeroes\n", ref_offset(raw)); 632 632 + pr_warn("Name in dirent node at 0x%08x contains zeroes\n", 633 633 + ref_offset(raw)); 652 634 goto bail; 653 635 } 654 636 655 637 if (node->d.nsize) { 656 638 crc = crc32(0, node->d.name, node->d.nsize); 657 639 if (je32_to_cpu(node->d.name_crc) != crc) { 658 658 - printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 659 659 - ref_offset(raw), je32_to_cpu(node->d.name_crc), crc); 640 640 + pr_warn("Name CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 641 641 + ref_offset(raw), 642 642 + je32_to_cpu(node->d.name_crc), crc); 660 643 goto bail; 661 644 } 662 645 } ··· 667 644 default: 668 645 /* If it's inode-less, we don't _know_ what it is. Just copy it intact */ 669 646 if (ic) { 670 670 - printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n", 671 671 - ref_offset(raw), je16_to_cpu(node->u.nodetype)); 647 647 + pr_warn("Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n", 648 648 + ref_offset(raw), je16_to_cpu(node->u.nodetype)); 672 649 goto bail; 673 650 } 674 651 } ··· 680 657 ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (char *)node); 681 658 682 659 if (ret || (retlen != rawlen)) { 683 683 - printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n", 684 684 - rawlen, phys_ofs, ret, retlen); 660 660 + pr_notice("Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n", 661 661 + rawlen, phys_ofs, ret, retlen); 685 662 if (retlen) { 686 663 jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, rawlen, NULL); 687 664 } else { 688 688 - printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", phys_ofs); 665 665 + pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", 666 666 + phys_ofs); 689 667 } 690 668 if (!retried) { 691 669 /* Try to reallocate space and retry */ ··· 695 671 696 672 retried = 1; 697 673 698 698 - D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n")); 674 674 + jffs2_dbg(1, "Retrying failed write of REF_PRISTINE node.\n"); 699 675 700 676 jffs2_dbg_acct_sanity_check(c,jeb); 701 677 jffs2_dbg_acct_paranoia_check(c, jeb); ··· 705 681 it is only an upper estimation */ 706 682 707 683 if (!ret) { 708 708 - D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", phys_ofs)); 684 684 + jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write.\n", 685 685 + phys_ofs); 709 686 710 687 jffs2_dbg_acct_sanity_check(c,jeb); 711 688 jffs2_dbg_acct_paranoia_check(c, jeb); 712 689 713 690 goto retry; 714 691 } 715 715 - D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 692 692 + jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n", 693 693 + ret); 716 694 } 717 695 718 696 if (!ret) ··· 724 698 jffs2_add_physical_node_ref(c, phys_ofs | REF_PRISTINE, rawlen, ic); 725 699 726 700 jffs2_mark_node_obsolete(c, raw); 727 727 - D1(printk(KERN_DEBUG "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", ref_offset(raw))); 701 701 + jffs2_dbg(1, "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", 702 702 + ref_offset(raw)); 728 703 729 704 out_node: 730 705 kfree(node); ··· 752 725 /* For these, we don't actually need to read the old node */ 753 726 mdatalen = jffs2_encode_dev(&dev, JFFS2_F_I_RDEV(f)); 754 727 mdata = (char *)&dev; 755 755 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen)); 728 728 + jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n", 729 729 + __func__, mdatalen); 756 730 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) { 757 731 mdatalen = fn->size; 758 732 mdata = kmalloc(fn->size, GFP_KERNEL); 759 733 if (!mdata) { 760 760 - printk(KERN_WARNING "kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n"); 734 734 + pr_warn("kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n"); 761 735 return -ENOMEM; 762 736 } 763 737 ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen); 764 738 if (ret) { 765 765 - printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret); 739 739 + pr_warn("read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", 740 740 + ret); 766 741 kfree(mdata); 767 742 return ret; 768 743 } 769 769 - D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen)); 744 744 + jffs2_dbg(1, "%s(): Writing %d bites of symlink target\n", 745 745 + __func__, mdatalen); 770 746 771 747 } 772 748 773 749 ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen, 774 750 JFFS2_SUMMARY_INODE_SIZE); 775 751 if (ret) { 776 776 - printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n", 777 777 - sizeof(ri)+ mdatalen, ret); 752 752 + pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n", 753 753 + sizeof(ri) + mdatalen, ret); 778 754 goto out; 779 755 } 780 756 ··· 814 784 new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC); 815 785 816 786 if (IS_ERR(new_fn)) { 817 817 - printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 787 787 + pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 818 788 ret = PTR_ERR(new_fn); 819 789 goto out; 820 790 } ··· 857 827 ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen, 858 828 JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize)); 859 829 if (ret) { 860 860 - printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n", 861 861 - sizeof(rd)+rd.nsize, ret); 830 830 + pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n", 831 831 + sizeof(rd)+rd.nsize, ret); 862 832 return ret; 863 833 } 864 834 new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC); 865 835 866 836 if (IS_ERR(new_fd)) { 867 867 - printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd)); 837 837 + pr_warn("jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", 838 838 + PTR_ERR(new_fd)); 868 839 return PTR_ERR(new_fd); 869 840 } 870 841 jffs2_add_fd_to_list(c, new_fd, &f->dents); ··· 918 887 if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset)) 919 888 continue; 920 889 921 921 - D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw))); 890 890 + jffs2_dbg(1, "Check potential deletion dirent at %08x\n", 891 891 + ref_offset(raw)); 922 892 923 893 /* This is an obsolete node belonging to the same directory, and it's of the right 924 894 length. We need to take a closer look...*/ 925 895 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)rd); 926 896 if (ret) { 927 927 - printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Read error (%d) reading obsolete node at %08x\n", ret, ref_offset(raw)); 897 897 + pr_warn("%s(): Read error (%d) reading obsolete node at %08x\n", 898 898 + __func__, ret, ref_offset(raw)); 928 899 /* If we can't read it, we don't need to continue to obsolete it. Continue */ 929 900 continue; 930 901 } 931 902 if (retlen != rawlen) { 932 932 - printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Short read (%zd not %u) reading header from obsolete node at %08x\n", 933 933 - retlen, rawlen, ref_offset(raw)); 903 903 + pr_warn("%s(): Short read (%zd not %u) reading header from obsolete node at %08x\n", 904 904 + __func__, retlen, rawlen, 905 905 + ref_offset(raw)); 934 906 continue; 935 907 } 936 908 ··· 957 923 a new deletion dirent to replace it */ 958 924 mutex_unlock(&c->erase_free_sem); 959 925 960 960 - D1(printk(KERN_DEBUG "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n", 961 961 - ref_offset(fd->raw), fd->name, ref_offset(raw), je32_to_cpu(rd->ino))); 926 926 + jffs2_dbg(1, "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n", 927 927 + ref_offset(fd->raw), fd->name, 928 928 + ref_offset(raw), je32_to_cpu(rd->ino)); 962 929 kfree(rd); 963 930 964 931 return jffs2_garbage_collect_dirent(c, jeb, f, fd); ··· 982 947 fdp = &(*fdp)->next; 983 948 } 984 949 if (!found) { 985 985 - printk(KERN_WARNING "Deletion dirent \"%s\" not found in list for ino #%u\n", fd->name, f->inocache->ino); 950 950 + pr_warn("Deletion dirent \"%s\" not found in list for ino #%u\n", 951 951 + fd->name, f->inocache->ino); 986 952 } 987 953 jffs2_mark_node_obsolete(c, fd->raw); 988 954 jffs2_free_full_dirent(fd); ··· 1000 964 uint32_t alloclen, ilen; 1001 965 int ret; 1002 966 1003 1003 - D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n", 1004 1004 - f->inocache->ino, start, end)); 967 967 + jffs2_dbg(1, "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n", 968 968 + f->inocache->ino, start, end); 1005 969 1006 970 memset(&ri, 0, sizeof(ri)); 1007 971 ··· 1012 976 write it out again with the _same_ version as before */ 1013 977 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri); 1014 978 if (readlen != sizeof(ri) || ret) { 1015 1015 - printk(KERN_WARNING "Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", ret, readlen); 979 979 + pr_warn("Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", 980 980 + ret, readlen); 1016 981 goto fill; 1017 982 } 1018 983 if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) { 1019 1019 - printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n", 1020 1020 - ref_offset(fn->raw), 1021 1021 - je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE); 984 984 + pr_warn("%s(): Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n", 985 985 + __func__, ref_offset(fn->raw), 986 986 + je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE); 1022 987 return -EIO; 1023 988 } 1024 989 if (je32_to_cpu(ri.totlen) != sizeof(ri)) { 1025 1025 - printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n", 1026 1026 - ref_offset(fn->raw), 1027 1027 - je32_to_cpu(ri.totlen), sizeof(ri)); 990 990 + pr_warn("%s(): Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n", 991 991 + __func__, ref_offset(fn->raw), 992 992 + je32_to_cpu(ri.totlen), sizeof(ri)); 1028 993 return -EIO; 1029 994 } 1030 995 crc = crc32(0, &ri, sizeof(ri)-8); 1031 996 if (crc != je32_to_cpu(ri.node_crc)) { 1032 1032 - printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n", 1033 1033 - ref_offset(fn->raw), 1034 1034 - je32_to_cpu(ri.node_crc), crc); 997 997 + pr_warn("%s: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n", 998 998 + __func__, ref_offset(fn->raw), 999 999 + je32_to_cpu(ri.node_crc), crc); 1035 1000 /* FIXME: We could possibly deal with this by writing new holes for each frag */ 1036 1036 - printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 1037 1037 - start, end, f->inocache->ino); 1001 1001 + pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 1002 1002 + start, end, f->inocache->ino); 1038 1003 goto fill; 1039 1004 } 1040 1005 if (ri.compr != JFFS2_COMPR_ZERO) { 1041 1041 - printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw)); 1042 1042 - printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 1043 1043 - start, end, f->inocache->ino); 1006 1006 + pr_warn("%s(): Node 0x%08x wasn't a hole node!\n", 1007 1007 + __func__, ref_offset(fn->raw)); 1008 1008 + pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 1009 1009 + start, end, f->inocache->ino); 1044 1010 goto fill; 1045 1011 } 1046 1012 } else { ··· 1081 1043 ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen, 1082 1044 JFFS2_SUMMARY_INODE_SIZE); 1083 1045 if (ret) { 1084 1084 - printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n", 1085 1085 - sizeof(ri), ret); 1046 1046 + pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n", 1047 1047 + sizeof(ri), ret); 1086 1048 return ret; 1087 1049 } 1088 1050 new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC); 1089 1051 1090 1052 if (IS_ERR(new_fn)) { 1091 1091 - printk(KERN_WARNING "Error writing new hole node: %ld\n", PTR_ERR(new_fn)); 1053 1053 + pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn)); 1092 1054 return PTR_ERR(new_fn); 1093 1055 } 1094 1056 if (je32_to_cpu(ri.version) == f->highest_version) { ··· 1108 1070 * above.) 1109 1071 */ 1110 1072 D1(if(unlikely(fn->frags <= 1)) { 1111 1111 - printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n", 1112 1112 - fn->frags, je32_to_cpu(ri.version), f->highest_version, 1113 1113 - je32_to_cpu(ri.ino)); 1073 1073 + pr_warn("%s(): Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n", 1074 1074 + __func__, fn->frags, je32_to_cpu(ri.version), 1075 1075 + f->highest_version, je32_to_cpu(ri.ino)); 1114 1076 }); 1115 1077 1116 1078 /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */ ··· 1127 1089 } 1128 1090 } 1129 1091 if (fn->frags) { 1130 1130 - printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n"); 1092 1092 + pr_warn("%s(): Old node still has frags!\n", __func__); 1131 1093 BUG(); 1132 1094 } 1133 1095 if (!new_fn->frags) { 1134 1134 - printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n"); 1096 1096 + pr_warn("%s(): New node has no frags!\n", __func__); 1135 1097 BUG(); 1136 1098 } 1137 1099 ··· 1155 1117 1156 1118 memset(&ri, 0, sizeof(ri)); 1157 1119 1158 1158 - D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n", 1159 1159 - f->inocache->ino, start, end)); 1120 1120 + jffs2_dbg(1, "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n", 1121 1121 + f->inocache->ino, start, end); 1160 1122 1161 1123 orig_end = end; 1162 1124 orig_start = start; ··· 1187 1149 /* If the previous frag doesn't even reach the beginning, there's 1188 1150 excessive fragmentation. Just merge. */ 1189 1151 if (frag->ofs > min) { 1190 1190 - D1(printk(KERN_DEBUG "Expanding down to cover partial frag (0x%x-0x%x)\n", 1191 1191 - frag->ofs, frag->ofs+frag->size)); 1152 1152 + jffs2_dbg(1, "Expanding down to cover partial frag (0x%x-0x%x)\n", 1153 1153 + frag->ofs, frag->ofs+frag->size); 1192 1154 start = frag->ofs; 1193 1155 continue; 1194 1156 } 1195 1157 /* OK. This frag holds the first byte of the page. */ 1196 1158 if (!frag->node || !frag->node->raw) { 1197 1197 - D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n", 1198 1198 - frag->ofs, frag->ofs+frag->size)); 1159 1159 + jffs2_dbg(1, "First frag in page is hole (0x%x-0x%x). Not expanding down.\n", 1160 1160 + frag->ofs, frag->ofs+frag->size); 1199 1161 break; 1200 1162 } else { 1201 1163 ··· 1209 1171 jeb = &c->blocks[raw->flash_offset / c->sector_size]; 1210 1172 1211 1173 if (jeb == c->gcblock) { 1212 1212 - D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n", 1213 1213 - frag->ofs, frag->ofs+frag->size, ref_offset(raw))); 1174 1174 + jffs2_dbg(1, "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n", 1175 1175 + frag->ofs, 1176 1176 + frag->ofs + frag->size, 1177 1177 + ref_offset(raw)); 1214 1178 start = frag->ofs; 1215 1179 break; 1216 1180 } 1217 1181 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 1218 1218 - D1(printk(KERN_DEBUG "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n", 1219 1219 - frag->ofs, frag->ofs+frag->size, jeb->offset)); 1182 1182 + jffs2_dbg(1, "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n", 1183 1183 + frag->ofs, 1184 1184 + frag->ofs + frag->size, 1185 1185 + jeb->offset); 1220 1186 break; 1221 1187 } 1222 1188 1223 1223 - D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n", 1224 1224 - frag->ofs, frag->ofs+frag->size, jeb->offset)); 1189 1189 + jffs2_dbg(1, "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n", 1190 1190 + frag->ofs, 1191 1191 + frag->ofs + frag->size, 1192 1192 + jeb->offset); 1225 1193 start = frag->ofs; 1226 1194 break; 1227 1195 } ··· 1243 1199 /* If the previous frag doesn't even reach the beginning, there's lots 1244 1200 of fragmentation. Just merge. */ 1245 1201 if (frag->ofs+frag->size < max) { 1246 1246 - D1(printk(KERN_DEBUG "Expanding up to cover partial frag (0x%x-0x%x)\n", 1247 1247 - frag->ofs, frag->ofs+frag->size)); 1202 1202 + jffs2_dbg(1, "Expanding up to cover partial frag (0x%x-0x%x)\n", 1203 1203 + frag->ofs, frag->ofs+frag->size); 1248 1204 end = frag->ofs + frag->size; 1249 1205 continue; 1250 1206 } 1251 1207 1252 1208 if (!frag->node || !frag->node->raw) { 1253 1253 - D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n", 1254 1254 - frag->ofs, frag->ofs+frag->size)); 1209 1209 + jffs2_dbg(1, "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n", 1210 1210 + frag->ofs, frag->ofs+frag->size); 1255 1211 break; 1256 1212 } else { 1257 1213 ··· 1265 1221 jeb = &c->blocks[raw->flash_offset / c->sector_size]; 1266 1222 1267 1223 if (jeb == c->gcblock) { 1268 1268 - D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n", 1269 1269 - frag->ofs, frag->ofs+frag->size, ref_offset(raw))); 1224 1224 + jffs2_dbg(1, "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n", 1225 1225 + frag->ofs, 1226 1226 + frag->ofs + frag->size, 1227 1227 + ref_offset(raw)); 1270 1228 end = frag->ofs + frag->size; 1271 1229 break; 1272 1230 } 1273 1231 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 1274 1274 - D1(printk(KERN_DEBUG "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n", 1275 1275 - frag->ofs, frag->ofs+frag->size, jeb->offset)); 1232 1232 + jffs2_dbg(1, "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n", 1233 1233 + frag->ofs, 1234 1234 + frag->ofs + frag->size, 1235 1235 + jeb->offset); 1276 1236 break; 1277 1237 } 1278 1238 1279 1279 - D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n", 1280 1280 - frag->ofs, frag->ofs+frag->size, jeb->offset)); 1239 1239 + jffs2_dbg(1, "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n", 1240 1240 + frag->ofs, 1241 1241 + frag->ofs + frag->size, 1242 1242 + jeb->offset); 1281 1243 end = frag->ofs + frag->size; 1282 1244 break; 1283 1245 } 1284 1246 } 1285 1285 - D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n", 1286 1286 - orig_start, orig_end, start, end)); 1247 1247 + jffs2_dbg(1, "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n", 1248 1248 + orig_start, orig_end, start, end); 1287 1249 1288 1250 D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size)); 1289 1251 BUG_ON(end < orig_end); ··· 1306 1256 pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg); 1307 1257 1308 1258 if (IS_ERR(pg_ptr)) { 1309 1309 - printk(KERN_WARNING "read_cache_page() returned error: %ld\n", PTR_ERR(pg_ptr)); 1259 1259 + pr_warn("read_cache_page() returned error: %ld\n", 1260 1260 + PTR_ERR(pg_ptr)); 1310 1261 return PTR_ERR(pg_ptr); 1311 1262 } 1312 1263 ··· 1321 1270 &alloclen, JFFS2_SUMMARY_INODE_SIZE); 1322 1271 1323 1272 if (ret) { 1324 1324 - printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n", 1325 1325 - sizeof(ri)+ JFFS2_MIN_DATA_LEN, ret); 1273 1273 + pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n", 1274 1274 + sizeof(ri) + JFFS2_MIN_DATA_LEN, ret); 1326 1275 break; 1327 1276 } 1328 1277 cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset); ··· 1359 1308 jffs2_free_comprbuf(comprbuf, writebuf); 1360 1309 1361 1310 if (IS_ERR(new_fn)) { 1362 1362 - printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 1311 1311 + pr_warn("Error writing new dnode: %ld\n", 1312 1312 + PTR_ERR(new_fn)); 1363 1313 ret = PTR_ERR(new_fn); 1364 1314 break; 1365 1315 }

+2

fs/jffs2/malloc.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/slab.h> 14 16 #include <linux/init.h>

+19 -11

fs/jffs2/nodelist.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/sched.h> 14 16 #include <linux/fs.h> ··· 689 687 if (!size) 690 688 return 0; 691 689 if (unlikely(size > jeb->free_size)) { 692 692 - printk(KERN_CRIT "Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n", 693 693 - size, jeb->free_size, jeb->wasted_size); 690 690 + pr_crit("Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n", 691 691 + size, jeb->free_size, jeb->wasted_size); 694 692 BUG(); 695 693 } 696 694 /* REF_EMPTY_NODE is !obsolete, so that works OK */ ··· 728 726 729 727 /* Last node in block. Use free_space */ 730 728 if (unlikely(ref != jeb->last_node)) { 731 731 - printk(KERN_CRIT "ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n", 732 732 - ref, ref_offset(ref), jeb->last_node, jeb->last_node?ref_offset(jeb->last_node):0); 729 729 + pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n", 730 730 + ref, ref_offset(ref), jeb->last_node, 731 731 + jeb->last_node ? 732 732 + ref_offset(jeb->last_node) : 0); 733 733 BUG(); 734 734 } 735 735 ref_end = jeb->offset + c->sector_size - jeb->free_size; ··· 751 747 if (!jeb) 752 748 jeb = &c->blocks[ref->flash_offset / c->sector_size]; 753 749 754 754 - printk(KERN_CRIT "Totlen for ref at %p (0x%08x-0x%08x) miscalculated as 0x%x instead of %x\n", 755 755 - ref, ref_offset(ref), ref_offset(ref)+ref->__totlen, 756 756 - ret, ref->__totlen); 750 750 + pr_crit("Totlen for ref at %p (0x%08x-0x%08x) miscalculated as 0x%x instead of %x\n", 751 751 + ref, ref_offset(ref), ref_offset(ref) + ref->__totlen, 752 752 + ret, ref->__totlen); 757 753 if (ref_next(ref)) { 758 758 - printk(KERN_CRIT "next %p (0x%08x-0x%08x)\n", ref_next(ref), ref_offset(ref_next(ref)), 759 759 - ref_offset(ref_next(ref))+ref->__totlen); 754 754 + pr_crit("next %p (0x%08x-0x%08x)\n", 755 755 + ref_next(ref), ref_offset(ref_next(ref)), 756 756 + ref_offset(ref_next(ref)) + ref->__totlen); 760 757 } else 761 761 - printk(KERN_CRIT "No next ref. jeb->last_node is %p\n", jeb->last_node); 758 758 + pr_crit("No next ref. jeb->last_node is %p\n", 759 759 + jeb->last_node); 762 760 763 763 - printk(KERN_CRIT "jeb->wasted_size %x, dirty_size %x, used_size %x, free_size %x\n", jeb->wasted_size, jeb->dirty_size, jeb->used_size, jeb->free_size); 761 761 + pr_crit("jeb->wasted_size %x, dirty_size %x, used_size %x, free_size %x\n", 762 762 + jeb->wasted_size, jeb->dirty_size, jeb->used_size, 763 763 + jeb->free_size); 764 764 765 765 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS) 766 766 __jffs2_dbg_dump_node_refs_nolock(c, jeb);

+130 -84

fs/jffs2/nodemgmt.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/mtd/mtd.h> 14 16 #include <linux/compiler.h> ··· 48 46 /* align it */ 49 47 minsize = PAD(minsize); 50 48 51 51 - D1(printk(KERN_DEBUG "jffs2_reserve_space(): Requested 0x%x bytes\n", minsize)); 49 49 + jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 52 50 mutex_lock(&c->alloc_sem); 53 51 54 54 - D1(printk(KERN_DEBUG "jffs2_reserve_space(): alloc sem got\n")); 52 52 + jffs2_dbg(1, "%s(): alloc sem got\n", __func__); 55 53 56 54 spin_lock(&c->erase_completion_lock); 57 55 ··· 75 73 dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size; 76 74 if (dirty < c->nospc_dirty_size) { 77 75 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 78 78 - D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on dirty space to GC, but it's a deletion. Allowing...\n")); 76 76 + jffs2_dbg(1, "%s(): Low on dirty space to GC, but it's a deletion. Allowing...\n", 77 77 + __func__); 79 78 break; 80 79 } 81 81 - D1(printk(KERN_DEBUG "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 82 82 - dirty, c->unchecked_size, c->sector_size)); 80 80 + jffs2_dbg(1, "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n", 81 81 + dirty, c->unchecked_size, 82 82 + c->sector_size); 83 83 84 84 spin_unlock(&c->erase_completion_lock); 85 85 mutex_unlock(&c->alloc_sem); ··· 100 96 avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size; 101 97 if ( (avail / c->sector_size) <= blocksneeded) { 102 98 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) { 103 103 - D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on possibly available space, but it's a deletion. Allowing...\n")); 99 99 + jffs2_dbg(1, "%s(): Low on possibly available space, but it's a deletion. Allowing...\n", 100 100 + __func__); 104 101 break; 105 102 } 106 103 107 107 - D1(printk(KERN_DEBUG "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 108 108 - avail, blocksneeded * c->sector_size)); 104 104 + jffs2_dbg(1, "max. available size 0x%08x < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n", 105 105 + avail, blocksneeded * c->sector_size); 109 106 spin_unlock(&c->erase_completion_lock); 110 107 mutex_unlock(&c->alloc_sem); 111 108 return -ENOSPC; ··· 114 109 115 110 mutex_unlock(&c->alloc_sem); 116 111 117 117 - D1(printk(KERN_DEBUG "Triggering GC pass. nr_free_blocks %d, nr_erasing_blocks %d, free_size 0x%08x, dirty_size 0x%08x, wasted_size 0x%08x, used_size 0x%08x, erasing_size 0x%08x, bad_size 0x%08x (total 0x%08x of 0x%08x)\n", 118 118 - c->nr_free_blocks, c->nr_erasing_blocks, c->free_size, c->dirty_size, c->wasted_size, c->used_size, c->erasing_size, c->bad_size, 119 119 - c->free_size + c->dirty_size + c->wasted_size + c->used_size + c->erasing_size + c->bad_size, c->flash_size)); 112 112 + jffs2_dbg(1, "Triggering GC pass. nr_free_blocks %d, nr_erasing_blocks %d, free_size 0x%08x, dirty_size 0x%08x, wasted_size 0x%08x, used_size 0x%08x, erasing_size 0x%08x, bad_size 0x%08x (total 0x%08x of 0x%08x)\n", 113 113 + c->nr_free_blocks, c->nr_erasing_blocks, 114 114 + c->free_size, c->dirty_size, c->wasted_size, 115 115 + c->used_size, c->erasing_size, c->bad_size, 116 116 + c->free_size + c->dirty_size + 117 117 + c->wasted_size + c->used_size + 118 118 + c->erasing_size + c->bad_size, 119 119 + c->flash_size); 120 120 spin_unlock(&c->erase_completion_lock); 121 121 122 122 ret = jffs2_garbage_collect_pass(c); ··· 134 124 DECLARE_WAITQUEUE(wait, current); 135 125 set_current_state(TASK_UNINTERRUPTIBLE); 136 126 add_wait_queue(&c->erase_wait, &wait); 137 137 - D1(printk(KERN_DEBUG "%s waiting for erase to complete\n", __func__)); 127 127 + jffs2_dbg(1, "%s waiting for erase to complete\n", 128 128 + __func__); 138 129 spin_unlock(&c->erase_completion_lock); 139 130 140 131 schedule(); ··· 155 144 156 145 ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 157 146 if (ret) { 158 158 - D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret)); 147 147 + jffs2_dbg(1, "%s(): ret is %d\n", __func__, ret); 159 148 } 160 149 } 161 150 spin_unlock(&c->erase_completion_lock); ··· 172 161 int ret = -EAGAIN; 173 162 minsize = PAD(minsize); 174 163 175 175 - D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize)); 164 164 + jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize); 176 165 177 166 spin_lock(&c->erase_completion_lock); 178 167 while(ret == -EAGAIN) { 179 168 ret = jffs2_do_reserve_space(c, minsize, len, sumsize); 180 169 if (ret) { 181 181 - D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret)); 170 170 + jffs2_dbg(1, "%s(): looping, ret is %d\n", 171 171 + __func__, ret); 182 172 } 183 173 } 184 174 spin_unlock(&c->erase_completion_lock); ··· 196 184 { 197 185 198 186 if (c->nextblock == NULL) { 199 199 - D1(printk(KERN_DEBUG "jffs2_close_nextblock: Erase block at 0x%08x has already been placed in a list\n", 200 200 - jeb->offset)); 187 187 + jffs2_dbg(1, "%s(): Erase block at 0x%08x has already been placed in a list\n", 188 188 + __func__, jeb->offset); 201 189 return; 202 190 } 203 191 /* Check, if we have a dirty block now, or if it was dirty already */ ··· 207 195 jeb->dirty_size += jeb->wasted_size; 208 196 jeb->wasted_size = 0; 209 197 if (VERYDIRTY(c, jeb->dirty_size)) { 210 210 - D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to very_dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 211 211 - jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 198 198 + jffs2_dbg(1, "Adding full erase block at 0x%08x to very_dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 199 199 + jeb->offset, jeb->free_size, jeb->dirty_size, 200 200 + jeb->used_size); 212 201 list_add_tail(&jeb->list, &c->very_dirty_list); 213 202 } else { 214 214 - D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 215 215 - jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 203 203 + jffs2_dbg(1, "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 204 204 + jeb->offset, jeb->free_size, jeb->dirty_size, 205 205 + jeb->used_size); 216 206 list_add_tail(&jeb->list, &c->dirty_list); 217 207 } 218 208 } else { 219 219 - D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 220 220 - jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 209 209 + jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 210 210 + jeb->offset, jeb->free_size, jeb->dirty_size, 211 211 + jeb->used_size); 221 212 list_add_tail(&jeb->list, &c->clean_list); 222 213 } 223 214 c->nextblock = NULL; ··· 245 230 list_move_tail(&ejeb->list, &c->erase_pending_list); 246 231 c->nr_erasing_blocks++; 247 232 jffs2_garbage_collect_trigger(c); 248 248 - D1(printk(KERN_DEBUG "jffs2_find_nextblock: Triggering erase of erasable block at 0x%08x\n", 249 249 - ejeb->offset)); 233 233 + jffs2_dbg(1, "%s(): Triggering erase of erasable block at 0x%08x\n", 234 234 + __func__, ejeb->offset); 250 235 } 251 236 252 237 if (!c->nr_erasing_blocks && 253 238 !list_empty(&c->erasable_pending_wbuf_list)) { 254 254 - D1(printk(KERN_DEBUG "jffs2_find_nextblock: Flushing write buffer\n")); 239 239 + jffs2_dbg(1, "%s(): Flushing write buffer\n", 240 240 + __func__); 255 241 /* c->nextblock is NULL, no update to c->nextblock allowed */ 256 242 spin_unlock(&c->erase_completion_lock); 257 243 jffs2_flush_wbuf_pad(c); ··· 264 248 if (!c->nr_erasing_blocks) { 265 249 /* Ouch. We're in GC, or we wouldn't have got here. 266 250 And there's no space left. At all. */ 267 267 - printk(KERN_CRIT "Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasableempty: %s, erasingempty: %s, erasependingempty: %s)\n", 268 268 - c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no", 269 269 - list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no"); 251 251 + pr_crit("Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasableempty: %s, erasingempty: %s, erasependingempty: %s)\n", 252 252 + c->nr_erasing_blocks, c->nr_free_blocks, 253 253 + list_empty(&c->erasable_list) ? "yes" : "no", 254 254 + list_empty(&c->erasing_list) ? "yes" : "no", 255 255 + list_empty(&c->erase_pending_list) ? "yes" : "no"); 270 256 return -ENOSPC; 271 257 } 272 258 ··· 296 278 c->wbuf_ofs = 0xffffffff; 297 279 #endif 298 280 299 299 - D1(printk(KERN_DEBUG "jffs2_find_nextblock(): new nextblock = 0x%08x\n", c->nextblock->offset)); 281 281 + jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 282 282 + __func__, c->nextblock->offset); 300 283 301 284 return 0; 302 285 } ··· 364 345 365 346 if (jffs2_wbuf_dirty(c)) { 366 347 spin_unlock(&c->erase_completion_lock); 367 367 - D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Flushing write buffer\n")); 348 348 + jffs2_dbg(1, "%s(): Flushing write buffer\n", 349 349 + __func__); 368 350 jffs2_flush_wbuf_pad(c); 369 351 spin_lock(&c->erase_completion_lock); 370 352 jeb = c->nextblock; ··· 407 387 jeb = c->nextblock; 408 388 409 389 if (jeb->free_size != c->sector_size - c->cleanmarker_size) { 410 410 - printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size); 390 390 + pr_warn("Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", 391 391 + jeb->offset, jeb->free_size); 411 392 goto restart; 412 393 } 413 394 } ··· 429 408 spin_lock(&c->erase_completion_lock); 430 409 } 431 410 432 432 - D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n", 433 433 - *len, jeb->offset + (c->sector_size - jeb->free_size))); 411 411 + jffs2_dbg(1, "%s(): Giving 0x%x bytes at 0x%x\n", 412 412 + __func__, 413 413 + *len, jeb->offset + (c->sector_size - jeb->free_size)); 434 414 return 0; 435 415 } 436 416 ··· 456 434 457 435 jeb = &c->blocks[ofs / c->sector_size]; 458 436 459 459 - D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n", 460 460 - ofs & ~3, ofs & 3, len)); 437 437 + jffs2_dbg(1, "%s(): Node at 0x%x(%d), size 0x%x\n", 438 438 + __func__, ofs & ~3, ofs & 3, len); 461 439 #if 1 462 440 /* Allow non-obsolete nodes only to be added at the end of c->nextblock, 463 441 if c->nextblock is set. Note that wbuf.c will file obsolete nodes 464 442 even after refiling c->nextblock */ 465 443 if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 466 444 && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) { 467 467 - printk(KERN_WARNING "argh. node added in wrong place at 0x%08x(%d)\n", ofs & ~3, ofs & 3); 445 445 + pr_warn("argh. node added in wrong place at 0x%08x(%d)\n", 446 446 + ofs & ~3, ofs & 3); 468 447 if (c->nextblock) 469 469 - printk(KERN_WARNING "nextblock 0x%08x", c->nextblock->offset); 448 448 + pr_warn("nextblock 0x%08x", c->nextblock->offset); 470 449 else 471 471 - printk(KERN_WARNING "No nextblock"); 472 472 - printk(", expected at %08x\n", jeb->offset + (c->sector_size - jeb->free_size)); 450 450 + pr_warn("No nextblock"); 451 451 + pr_cont(", expected at %08x\n", 452 452 + jeb->offset + (c->sector_size - jeb->free_size)); 473 453 return ERR_PTR(-EINVAL); 474 454 } 475 455 #endif ··· 481 457 482 458 if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 483 459 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */ 484 484 - D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 485 485 - jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 460 460 + jffs2_dbg(1, "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n", 461 461 + jeb->offset, jeb->free_size, jeb->dirty_size, 462 462 + jeb->used_size); 486 463 if (jffs2_wbuf_dirty(c)) { 487 464 /* Flush the last write in the block if it's outstanding */ 488 465 spin_unlock(&c->erase_completion_lock); ··· 505 480 506 481 void jffs2_complete_reservation(struct jffs2_sb_info *c) 507 482 { 508 508 - D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n")); 483 483 + jffs2_dbg(1, "jffs2_complete_reservation()\n"); 509 484 spin_lock(&c->erase_completion_lock); 510 485 jffs2_garbage_collect_trigger(c); 511 486 spin_unlock(&c->erase_completion_lock); ··· 518 493 519 494 list_for_each(this, head) { 520 495 if (this == obj) { 521 521 - D1(printk("%p is on list at %p\n", obj, head)); 496 496 + jffs2_dbg(1, "%p is on list at %p\n", obj, head); 522 497 return 1; 523 498 524 499 } ··· 536 511 uint32_t freed_len; 537 512 538 513 if(unlikely(!ref)) { 539 539 - printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 514 514 + pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n"); 540 515 return; 541 516 } 542 517 if (ref_obsolete(ref)) { 543 543 - D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref_offset(ref))); 518 518 + jffs2_dbg(1, "%s(): called with already obsolete node at 0x%08x\n", 519 519 + __func__, ref_offset(ref)); 544 520 return; 545 521 } 546 522 blocknr = ref->flash_offset / c->sector_size; 547 523 if (blocknr >= c->nr_blocks) { 548 548 - printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset); 524 524 + pr_notice("raw node at 0x%08x is off the end of device!\n", 525 525 + ref->flash_offset); 549 526 BUG(); 550 527 } 551 528 jeb = &c->blocks[blocknr]; ··· 569 542 570 543 if (ref_flags(ref) == REF_UNCHECKED) { 571 544 D1(if (unlikely(jeb->unchecked_size < freed_len)) { 572 572 - printk(KERN_NOTICE "raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n", 573 573 - freed_len, blocknr, ref->flash_offset, jeb->used_size); 545 545 + pr_notice("raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n", 546 546 + freed_len, blocknr, 547 547 + ref->flash_offset, jeb->used_size); 574 548 BUG(); 575 549 }) 576 576 - D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), freed_len)); 550 550 + jffs2_dbg(1, "Obsoleting previously unchecked node at 0x%08x of len %x\n", 551 551 + ref_offset(ref), freed_len); 577 552 jeb->unchecked_size -= freed_len; 578 553 c->unchecked_size -= freed_len; 579 554 } else { 580 555 D1(if (unlikely(jeb->used_size < freed_len)) { 581 581 - printk(KERN_NOTICE "raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n", 582 582 - freed_len, blocknr, ref->flash_offset, jeb->used_size); 556 556 + pr_notice("raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n", 557 557 + freed_len, blocknr, 558 558 + ref->flash_offset, jeb->used_size); 583 559 BUG(); 584 560 }) 585 585 - D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref), freed_len)); 561 561 + jffs2_dbg(1, "Obsoleting node at 0x%08x of len %#x: ", 562 562 + ref_offset(ref), freed_len); 586 563 jeb->used_size -= freed_len; 587 564 c->used_size -= freed_len; 588 565 } 589 566 590 567 // Take care, that wasted size is taken into concern 591 568 if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) { 592 592 - D1(printk("Dirtying\n")); 569 569 + jffs2_dbg(1, "Dirtying\n"); 593 570 addedsize = freed_len; 594 571 jeb->dirty_size += freed_len; 595 572 c->dirty_size += freed_len; ··· 601 570 /* Convert wasted space to dirty, if not a bad block */ 602 571 if (jeb->wasted_size) { 603 572 if (on_list(&jeb->list, &c->bad_used_list)) { 604 604 - D1(printk(KERN_DEBUG "Leaving block at %08x on the bad_used_list\n", 605 605 - jeb->offset)); 573 573 + jffs2_dbg(1, "Leaving block at %08x on the bad_used_list\n", 574 574 + jeb->offset); 606 575 addedsize = 0; /* To fool the refiling code later */ 607 576 } else { 608 608 - D1(printk(KERN_DEBUG "Converting %d bytes of wasted space to dirty in block at %08x\n", 609 609 - jeb->wasted_size, jeb->offset)); 577 577 + jffs2_dbg(1, "Converting %d bytes of wasted space to dirty in block at %08x\n", 578 578 + jeb->wasted_size, jeb->offset); 610 579 addedsize += jeb->wasted_size; 611 580 jeb->dirty_size += jeb->wasted_size; 612 581 c->dirty_size += jeb->wasted_size; ··· 615 584 } 616 585 } 617 586 } else { 618 618 - D1(printk("Wasting\n")); 587 587 + jffs2_dbg(1, "Wasting\n"); 619 588 addedsize = 0; 620 589 jeb->wasted_size += freed_len; 621 590 c->wasted_size += freed_len; ··· 637 606 } 638 607 639 608 if (jeb == c->nextblock) { 640 640 - D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset)); 609 609 + jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n", 610 610 + jeb->offset); 641 611 } else if (!jeb->used_size && !jeb->unchecked_size) { 642 612 if (jeb == c->gcblock) { 643 643 - D1(printk(KERN_DEBUG "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", jeb->offset)); 613 613 + jffs2_dbg(1, "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", 614 614 + jeb->offset); 644 615 c->gcblock = NULL; 645 616 } else { 646 646 - D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset)); 617 617 + jffs2_dbg(1, "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", 618 618 + jeb->offset); 647 619 list_del(&jeb->list); 648 620 } 649 621 if (jffs2_wbuf_dirty(c)) { 650 650 - D1(printk(KERN_DEBUG "...and adding to erasable_pending_wbuf_list\n")); 622 622 + jffs2_dbg(1, "...and adding to erasable_pending_wbuf_list\n"); 651 623 list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list); 652 624 } else { 653 625 if (jiffies & 127) { 654 626 /* Most of the time, we just erase it immediately. Otherwise we 655 627 spend ages scanning it on mount, etc. */ 656 656 - D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n")); 628 628 + jffs2_dbg(1, "...and adding to erase_pending_list\n"); 657 629 list_add_tail(&jeb->list, &c->erase_pending_list); 658 630 c->nr_erasing_blocks++; 659 631 jffs2_garbage_collect_trigger(c); 660 632 } else { 661 633 /* Sometimes, however, we leave it elsewhere so it doesn't get 662 634 immediately reused, and we spread the load a bit. */ 663 663 - D1(printk(KERN_DEBUG "...and adding to erasable_list\n")); 635 635 + jffs2_dbg(1, "...and adding to erasable_list\n"); 664 636 list_add_tail(&jeb->list, &c->erasable_list); 665 637 } 666 638 } 667 667 - D1(printk(KERN_DEBUG "Done OK\n")); 639 639 + jffs2_dbg(1, "Done OK\n"); 668 640 } else if (jeb == c->gcblock) { 669 669 - D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty_list\n", jeb->offset)); 641 641 + jffs2_dbg(2, "Not moving gcblock 0x%08x to dirty_list\n", 642 642 + jeb->offset); 670 643 } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) { 671 671 - D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset)); 644 644 + jffs2_dbg(1, "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", 645 645 + jeb->offset); 672 646 list_del(&jeb->list); 673 673 - D1(printk(KERN_DEBUG "...and adding to dirty_list\n")); 647 647 + jffs2_dbg(1, "...and adding to dirty_list\n"); 674 648 list_add_tail(&jeb->list, &c->dirty_list); 675 649 } else if (VERYDIRTY(c, jeb->dirty_size) && 676 650 !VERYDIRTY(c, jeb->dirty_size - addedsize)) { 677 677 - D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", jeb->offset)); 651 651 + jffs2_dbg(1, "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", 652 652 + jeb->offset); 678 653 list_del(&jeb->list); 679 679 - D1(printk(KERN_DEBUG "...and adding to very_dirty_list\n")); 654 654 + jffs2_dbg(1, "...and adding to very_dirty_list\n"); 680 655 list_add_tail(&jeb->list, &c->very_dirty_list); 681 656 } else { 682 682 - D1(printk(KERN_DEBUG "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 683 683 - jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size)); 657 657 + jffs2_dbg(1, "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n", 658 658 + jeb->offset, jeb->free_size, jeb->dirty_size, 659 659 + jeb->used_size); 684 660 } 685 661 686 662 spin_unlock(&c->erase_completion_lock); ··· 703 665 the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet 704 666 by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */ 705 667 706 706 - D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref_offset(ref))); 668 668 + jffs2_dbg(1, "obliterating obsoleted node at 0x%08x\n", 669 669 + ref_offset(ref)); 707 670 ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 708 671 if (ret) { 709 709 - printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 672 672 + pr_warn("Read error reading from obsoleted node at 0x%08x: %d\n", 673 673 + ref_offset(ref), ret); 710 674 goto out_erase_sem; 711 675 } 712 676 if (retlen != sizeof(n)) { 713 713 - printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 677 677 + pr_warn("Short read from obsoleted node at 0x%08x: %zd\n", 678 678 + ref_offset(ref), retlen); 714 679 goto out_erase_sem; 715 680 } 716 681 if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) { 717 717 - printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len); 682 682 + pr_warn("Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", 683 683 + je32_to_cpu(n.totlen), freed_len); 718 684 goto out_erase_sem; 719 685 } 720 686 if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) { 721 721 - D1(printk(KERN_DEBUG "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", ref_offset(ref), je16_to_cpu(n.nodetype))); 687 687 + jffs2_dbg(1, "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", 688 688 + ref_offset(ref), je16_to_cpu(n.nodetype)); 722 689 goto out_erase_sem; 723 690 } 724 691 /* XXX FIXME: This is ugly now */ 725 692 n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE); 726 693 ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n); 727 694 if (ret) { 728 728 - printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret); 695 695 + pr_warn("Write error in obliterating obsoleted node at 0x%08x: %d\n", 696 696 + ref_offset(ref), ret); 729 697 goto out_erase_sem; 730 698 } 731 699 if (retlen != sizeof(n)) { 732 732 - printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen); 700 700 + pr_warn("Short write in obliterating obsoleted node at 0x%08x: %zd\n", 701 701 + ref_offset(ref), retlen); 733 702 goto out_erase_sem; 734 703 } 735 704 ··· 796 751 return 1; 797 752 798 753 if (c->unchecked_size) { 799 799 - D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n", 800 800 - c->unchecked_size, c->checked_ino)); 754 754 + jffs2_dbg(1, "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n", 755 755 + c->unchecked_size, c->checked_ino); 801 756 return 1; 802 757 } 803 758 ··· 825 780 } 826 781 } 827 782 828 828 - D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n", 829 829 - c->nr_free_blocks, c->nr_erasing_blocks, c->dirty_size, nr_very_dirty, ret?"yes":"no")); 783 783 + jffs2_dbg(1, "%s(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n", 784 784 + __func__, c->nr_free_blocks, c->nr_erasing_blocks, 785 785 + c->dirty_size, nr_very_dirty, ret ? "yes" : "no"); 830 786 831 787 return ret; 832 788 }

+1 -3

fs/jffs2/os-linux.h

reviewed

··· 76 76 #define jffs2_write_nand_cleanmarker(c,jeb) (-EIO) 77 77 78 78 #define jffs2_flash_write(c, ofs, len, retlen, buf) jffs2_flash_direct_write(c, ofs, len, retlen, buf) 79 79 - #define jffs2_flash_read(c, ofs, len, retlen, buf) ((c)->mtd->read((c)->mtd, ofs, len, retlen, buf)) 79 79 + #define jffs2_flash_read(c, ofs, len, retlen, buf) (mtd_read((c)->mtd, ofs, len, retlen, buf)) 80 80 #define jffs2_flush_wbuf_pad(c) ({ do{} while(0); (void)(c), 0; }) 81 81 #define jffs2_flush_wbuf_gc(c, i) ({ do{} while(0); (void)(c), (void) i, 0; }) 82 82 #define jffs2_write_nand_badblock(c,jeb,bad_offset) (1) ··· 108 108 109 109 #define jffs2_cleanmarker_oob(c) (c->mtd->type == MTD_NANDFLASH) 110 110 111 111 - #define jffs2_flash_write_oob(c, ofs, len, retlen, buf) ((c)->mtd->write_oob((c)->mtd, ofs, len, retlen, buf)) 112 112 - #define jffs2_flash_read_oob(c, ofs, len, retlen, buf) ((c)->mtd->read_oob((c)->mtd, ofs, len, retlen, buf)) 113 111 #define jffs2_wbuf_dirty(c) (!!(c)->wbuf_len) 114 112 115 113 /* wbuf.c */

+41 -29

fs/jffs2/read.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/slab.h> 14 16 #include <linux/crc32.h> ··· 38 36 ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri); 39 37 if (ret) { 40 38 jffs2_free_raw_inode(ri); 41 41 - printk(KERN_WARNING "Error reading node from 0x%08x: %d\n", ref_offset(fd->raw), ret); 39 39 + pr_warn("Error reading node from 0x%08x: %d\n", 40 40 + ref_offset(fd->raw), ret); 42 41 return ret; 43 42 } 44 43 if (readlen != sizeof(*ri)) { 45 44 jffs2_free_raw_inode(ri); 46 46 - printk(KERN_WARNING "Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n", 47 47 - ref_offset(fd->raw), sizeof(*ri), readlen); 45 45 + pr_warn("Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n", 46 46 + ref_offset(fd->raw), sizeof(*ri), readlen); 48 47 return -EIO; 49 48 } 50 49 crc = crc32(0, ri, sizeof(*ri)-8); 51 50 52 52 - D1(printk(KERN_DEBUG "Node read from %08x: node_crc %08x, calculated CRC %08x. dsize %x, csize %x, offset %x, buf %p\n", 51 51 + jffs2_dbg(1, "Node read from %08x: node_crc %08x, calculated CRC %08x. dsize %x, csize %x, offset %x, buf %p\n", 53 52 ref_offset(fd->raw), je32_to_cpu(ri->node_crc), 54 53 crc, je32_to_cpu(ri->dsize), je32_to_cpu(ri->csize), 55 55 - je32_to_cpu(ri->offset), buf)); 54 54 + je32_to_cpu(ri->offset), buf); 56 55 if (crc != je32_to_cpu(ri->node_crc)) { 57 57 - printk(KERN_WARNING "Node CRC %08x != calculated CRC %08x for node at %08x\n", 58 58 - je32_to_cpu(ri->node_crc), crc, ref_offset(fd->raw)); 56 56 + pr_warn("Node CRC %08x != calculated CRC %08x for node at %08x\n", 57 57 + je32_to_cpu(ri->node_crc), crc, ref_offset(fd->raw)); 59 58 ret = -EIO; 60 59 goto out_ri; 61 60 } ··· 69 66 } 70 67 71 68 D1(if(ofs + len > je32_to_cpu(ri->dsize)) { 72 72 - printk(KERN_WARNING "jffs2_read_dnode() asked for %d bytes at %d from %d-byte node\n", 73 73 - len, ofs, je32_to_cpu(ri->dsize)); 69 69 + pr_warn("jffs2_read_dnode() asked for %d bytes at %d from %d-byte node\n", 70 70 + len, ofs, je32_to_cpu(ri->dsize)); 74 71 ret = -EINVAL; 75 72 goto out_ri; 76 73 }); ··· 110 107 decomprbuf = readbuf; 111 108 } 112 109 113 113 - D2(printk(KERN_DEBUG "Read %d bytes to %p\n", je32_to_cpu(ri->csize), 114 114 - readbuf)); 110 110 + jffs2_dbg(2, "Read %d bytes to %p\n", je32_to_cpu(ri->csize), 111 111 + readbuf); 115 112 ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri), 116 113 je32_to_cpu(ri->csize), &readlen, readbuf); 117 114 ··· 122 119 123 120 crc = crc32(0, readbuf, je32_to_cpu(ri->csize)); 124 121 if (crc != je32_to_cpu(ri->data_crc)) { 125 125 - printk(KERN_WARNING "Data CRC %08x != calculated CRC %08x for node at %08x\n", 126 126 - je32_to_cpu(ri->data_crc), crc, ref_offset(fd->raw)); 122 122 + pr_warn("Data CRC %08x != calculated CRC %08x for node at %08x\n", 123 123 + je32_to_cpu(ri->data_crc), crc, ref_offset(fd->raw)); 127 124 ret = -EIO; 128 125 goto out_decomprbuf; 129 126 } 130 130 - D2(printk(KERN_DEBUG "Data CRC matches calculated CRC %08x\n", crc)); 127 127 + jffs2_dbg(2, "Data CRC matches calculated CRC %08x\n", crc); 131 128 if (ri->compr != JFFS2_COMPR_NONE) { 132 132 - D2(printk(KERN_DEBUG "Decompress %d bytes from %p to %d bytes at %p\n", 133 133 - je32_to_cpu(ri->csize), readbuf, je32_to_cpu(ri->dsize), decomprbuf)); 129 129 + jffs2_dbg(2, "Decompress %d bytes from %p to %d bytes at %p\n", 130 130 + je32_to_cpu(ri->csize), readbuf, 131 131 + je32_to_cpu(ri->dsize), decomprbuf); 134 132 ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize)); 135 133 if (ret) { 136 136 - printk(KERN_WARNING "Error: jffs2_decompress returned %d\n", ret); 134 134 + pr_warn("Error: jffs2_decompress returned %d\n", ret); 137 135 goto out_decomprbuf; 138 136 } 139 137 } ··· 161 157 struct jffs2_node_frag *frag; 162 158 int ret; 163 159 164 164 - D1(printk(KERN_DEBUG "jffs2_read_inode_range: ino #%u, range 0x%08x-0x%08x\n", 165 165 - f->inocache->ino, offset, offset+len)); 160 160 + jffs2_dbg(1, "%s(): ino #%u, range 0x%08x-0x%08x\n", 161 161 + __func__, f->inocache->ino, offset, offset + len); 166 162 167 163 frag = jffs2_lookup_node_frag(&f->fragtree, offset); 168 164 ··· 172 168 * (or perhaps is before it, if we've been asked to read off the 173 169 * end of the file). */ 174 170 while(offset < end) { 175 175 - D2(printk(KERN_DEBUG "jffs2_read_inode_range: offset %d, end %d\n", offset, end)); 171 171 + jffs2_dbg(2, "%s(): offset %d, end %d\n", 172 172 + __func__, offset, end); 176 173 if (unlikely(!frag || frag->ofs > offset || 177 174 frag->ofs + frag->size <= offset)) { 178 175 uint32_t holesize = end - offset; 179 176 if (frag && frag->ofs > offset) { 180 180 - D1(printk(KERN_NOTICE "Eep. Hole in ino #%u fraglist. frag->ofs = 0x%08x, offset = 0x%08x\n", f->inocache->ino, frag->ofs, offset)); 177 177 + jffs2_dbg(1, "Eep. Hole in ino #%u fraglist. frag->ofs = 0x%08x, offset = 0x%08x\n", 178 178 + f->inocache->ino, frag->ofs, offset); 181 179 holesize = min(holesize, frag->ofs - offset); 182 180 } 183 183 - D1(printk(KERN_DEBUG "Filling non-frag hole from %d-%d\n", offset, offset+holesize)); 181 181 + jffs2_dbg(1, "Filling non-frag hole from %d-%d\n", 182 182 + offset, offset + holesize); 184 183 memset(buf, 0, holesize); 185 184 buf += holesize; 186 185 offset += holesize; 187 186 continue; 188 187 } else if (unlikely(!frag->node)) { 189 188 uint32_t holeend = min(end, frag->ofs + frag->size); 190 190 - D1(printk(KERN_DEBUG "Filling frag hole from %d-%d (frag 0x%x 0x%x)\n", offset, holeend, frag->ofs, frag->ofs + frag->size)); 189 189 + jffs2_dbg(1, "Filling frag hole from %d-%d (frag 0x%x 0x%x)\n", 190 190 + offset, holeend, frag->ofs, 191 191 + frag->ofs + frag->size); 191 192 memset(buf, 0, holeend - offset); 192 193 buf += holeend - offset; 193 194 offset = holeend; ··· 204 195 205 196 fragofs = offset - frag->ofs; 206 197 readlen = min(frag->size - fragofs, end - offset); 207 207 - D1(printk(KERN_DEBUG "Reading %d-%d from node at 0x%08x (%d)\n", 208 208 - frag->ofs+fragofs, frag->ofs+fragofs+readlen, 209 209 - ref_offset(frag->node->raw), ref_flags(frag->node->raw))); 198 198 + jffs2_dbg(1, "Reading %d-%d from node at 0x%08x (%d)\n", 199 199 + frag->ofs+fragofs, 200 200 + frag->ofs + fragofs+readlen, 201 201 + ref_offset(frag->node->raw), 202 202 + ref_flags(frag->node->raw)); 210 203 ret = jffs2_read_dnode(c, f, frag->node, buf, fragofs + frag->ofs - frag->node->ofs, readlen); 211 211 - D2(printk(KERN_DEBUG "node read done\n")); 204 204 + jffs2_dbg(2, "node read done\n"); 212 205 if (ret) { 213 213 - D1(printk(KERN_DEBUG"jffs2_read_inode_range error %d\n",ret)); 206 206 + jffs2_dbg(1, "%s(): error %d\n", 207 207 + __func__, ret); 214 208 memset(buf, 0, readlen); 215 209 return ret; 216 210 } 217 211 buf += readlen; 218 212 offset += readlen; 219 213 frag = frag_next(frag); 220 220 - D2(printk(KERN_DEBUG "node read was OK. Looping\n")); 214 214 + jffs2_dbg(2, "node read was OK. Looping\n"); 221 215 } 222 216 } 223 217 return 0;

+2

fs/jffs2/readinode.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/sched.h> 14 16 #include <linux/slab.h>

+129 -100

fs/jffs2/scan.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/sched.h> 14 16 #include <linux/slab.h> ··· 24 22 25 23 #define DEFAULT_EMPTY_SCAN_SIZE 256 26 24 27 27 - #define noisy_printk(noise, args...) do { \ 28 28 - if (*(noise)) { \ 29 29 - printk(KERN_NOTICE args); \ 30 30 - (*(noise))--; \ 31 31 - if (!(*(noise))) { \ 32 32 - printk(KERN_NOTICE "Further such events for this erase block will not be printed\n"); \ 33 33 - } \ 34 34 - } \ 35 35 - } while(0) 25 25 + #define noisy_printk(noise, fmt, ...) \ 26 26 + do { \ 27 27 + if (*(noise)) { \ 28 28 + pr_notice(fmt, ##__VA_ARGS__); \ 29 29 + (*(noise))--; \ 30 30 + if (!(*(noise))) \ 31 31 + pr_notice("Further such events for this erase block will not be printed\n"); \ 32 32 + } \ 33 33 + } while (0) 36 34 37 35 static uint32_t pseudo_random; 38 36 ··· 98 96 #ifndef __ECOS 99 97 size_t pointlen, try_size; 100 98 101 101 - if (c->mtd->point) { 102 102 - ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen, 103 103 - (void **)&flashbuf, NULL); 104 104 - if (!ret && pointlen < c->mtd->size) { 105 105 - /* Don't muck about if it won't let us point to the whole flash */ 106 106 - D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen)); 107 107 - mtd_unpoint(c->mtd, 0, pointlen); 108 108 - flashbuf = NULL; 109 109 - } 110 110 - if (ret && ret != -EOPNOTSUPP) 111 111 - D1(printk(KERN_DEBUG "MTD point failed %d\n", ret)); 99 99 + ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen, 100 100 + (void **)&flashbuf, NULL); 101 101 + if (!ret && pointlen < c->mtd->size) { 102 102 + /* Don't muck about if it won't let us point to the whole flash */ 103 103 + jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n", 104 104 + pointlen); 105 105 + mtd_unpoint(c->mtd, 0, pointlen); 106 106 + flashbuf = NULL; 112 107 } 108 108 + if (ret && ret != -EOPNOTSUPP) 109 109 + jffs2_dbg(1, "MTD point failed %d\n", ret); 113 110 #endif 114 111 if (!flashbuf) { 115 112 /* For NAND it's quicker to read a whole eraseblock at a time, ··· 118 117 else 119 118 try_size = PAGE_SIZE; 120 119 121 121 - D1(printk(KERN_DEBUG "Trying to allocate readbuf of %zu " 122 122 - "bytes\n", try_size)); 120 120 + jffs2_dbg(1, "Trying to allocate readbuf of %zu " 121 121 + "bytes\n", try_size); 123 122 124 123 flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size); 125 124 if (!flashbuf) 126 125 return -ENOMEM; 127 126 128 128 - D1(printk(KERN_DEBUG "Allocated readbuf of %zu bytes\n", 129 129 - try_size)); 127 127 + jffs2_dbg(1, "Allocated readbuf of %zu bytes\n", 128 128 + try_size); 130 129 131 130 buf_size = (uint32_t)try_size; 132 131 } ··· 179 178 c->nr_free_blocks++; 180 179 } else { 181 180 /* Dirt */ 182 182 - D1(printk(KERN_DEBUG "Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb->offset)); 181 181 + jffs2_dbg(1, "Adding all-dirty block at 0x%08x to erase_pending_list\n", 182 182 + jeb->offset); 183 183 list_add(&jeb->list, &c->erase_pending_list); 184 184 c->nr_erasing_blocks++; 185 185 } ··· 207 205 } 208 206 /* update collected summary information for the current nextblock */ 209 207 jffs2_sum_move_collected(c, s); 210 210 - D1(printk(KERN_DEBUG "jffs2_scan_medium(): new nextblock = 0x%08x\n", jeb->offset)); 208 208 + jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n", 209 209 + __func__, jeb->offset); 211 210 c->nextblock = jeb; 212 211 } else { 213 212 ret = file_dirty(c, jeb); ··· 220 217 case BLK_STATE_ALLDIRTY: 221 218 /* Nothing valid - not even a clean marker. Needs erasing. */ 222 219 /* For now we just put it on the erasing list. We'll start the erases later */ 223 223 - D1(printk(KERN_NOTICE "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb->offset)); 220 220 + jffs2_dbg(1, "Erase block at 0x%08x is not formatted. It will be erased\n", 221 221 + jeb->offset); 224 222 list_add(&jeb->list, &c->erase_pending_list); 225 223 c->nr_erasing_blocks++; 226 224 break; 227 225 228 226 case BLK_STATE_BADBLOCK: 229 229 - D1(printk(KERN_NOTICE "JFFS2: Block at 0x%08x is bad\n", jeb->offset)); 227 227 + jffs2_dbg(1, "Block at 0x%08x is bad\n", jeb->offset); 230 228 list_add(&jeb->list, &c->bad_list); 231 229 c->bad_size += c->sector_size; 232 230 c->free_size -= c->sector_size; 233 231 bad_blocks++; 234 232 break; 235 233 default: 236 236 - printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n"); 234 234 + pr_warn("%s(): unknown block state\n", __func__); 237 235 BUG(); 238 236 } 239 237 } ··· 254 250 255 251 uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize; 256 252 257 257 - D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n", 258 258 - skip)); 253 253 + jffs2_dbg(1, "%s(): Skipping %d bytes in nextblock to ensure page alignment\n", 254 254 + __func__, skip); 259 255 jffs2_prealloc_raw_node_refs(c, c->nextblock, 1); 260 256 jffs2_scan_dirty_space(c, c->nextblock, skip); 261 257 } 262 258 #endif 263 259 if (c->nr_erasing_blocks) { 264 260 if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) { 265 265 - printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 266 266 - printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks); 261 261 + pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n"); 262 262 + pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n", 263 263 + empty_blocks, bad_blocks, c->nr_blocks); 267 264 ret = -EIO; 268 265 goto out; 269 266 } ··· 292 287 293 288 ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 294 289 if (ret) { 295 295 - D1(printk(KERN_WARNING "mtd->read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret)); 290 290 + jffs2_dbg(1, "mtd->read(0x%x bytes from 0x%x) returned %d\n", 291 291 + len, ofs, ret); 296 292 return ret; 297 293 } 298 294 if (retlen < len) { 299 299 - D1(printk(KERN_WARNING "Read at 0x%x gave only 0x%zx bytes\n", ofs, retlen)); 295 295 + jffs2_dbg(1, "Read at 0x%x gave only 0x%zx bytes\n", 296 296 + ofs, retlen); 300 297 return -EIO; 301 298 } 302 299 return 0; ··· 375 368 376 369 if (jffs2_sum_active()) 377 370 jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset); 378 378 - dbg_xattr("scaning xdatum at %#08x (xid=%u, version=%u)\n", 371 371 + dbg_xattr("scanning xdatum at %#08x (xid=%u, version=%u)\n", 379 372 ofs, xd->xid, xd->version); 380 373 return 0; 381 374 } ··· 456 449 ofs = jeb->offset; 457 450 prevofs = jeb->offset - 1; 458 451 459 459 - D1(printk(KERN_DEBUG "jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs)); 452 452 + jffs2_dbg(1, "%s(): Scanning block at 0x%x\n", __func__, ofs); 460 453 461 454 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 462 455 if (jffs2_cleanmarker_oob(c)) { ··· 466 459 return BLK_STATE_BADBLOCK; 467 460 468 461 ret = jffs2_check_nand_cleanmarker(c, jeb); 469 469 - D2(printk(KERN_NOTICE "jffs_check_nand_cleanmarker returned %d\n",ret)); 462 462 + jffs2_dbg(2, "jffs_check_nand_cleanmarker returned %d\n", ret); 470 463 471 464 /* Even if it's not found, we still scan to see 472 465 if the block is empty. We use this information ··· 568 561 if (jffs2_cleanmarker_oob(c)) { 569 562 /* scan oob, take care of cleanmarker */ 570 563 int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound); 571 571 - D2(printk(KERN_NOTICE "jffs2_check_oob_empty returned %d\n",ret)); 564 564 + jffs2_dbg(2, "jffs2_check_oob_empty returned %d\n", 565 565 + ret); 572 566 switch (ret) { 573 567 case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF; 574 568 case 1: return BLK_STATE_ALLDIRTY; ··· 577 569 } 578 570 } 579 571 #endif 580 580 - D1(printk(KERN_DEBUG "Block at 0x%08x is empty (erased)\n", jeb->offset)); 572 572 + jffs2_dbg(1, "Block at 0x%08x is empty (erased)\n", 573 573 + jeb->offset); 581 574 if (c->cleanmarker_size == 0) 582 575 return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */ 583 576 else 584 577 return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */ 585 578 } 586 579 if (ofs) { 587 587 - D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset, 588 588 - jeb->offset + ofs)); 580 580 + jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb->offset, 581 581 + jeb->offset + ofs); 589 582 if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1))) 590 583 return err; 591 584 if ((err = jffs2_scan_dirty_space(c, jeb, ofs))) ··· 613 604 cond_resched(); 614 605 615 606 if (ofs & 3) { 616 616 - printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs); 607 607 + pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs); 617 608 ofs = PAD(ofs); 618 609 continue; 619 610 } 620 611 if (ofs == prevofs) { 621 621 - printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs); 612 612 + pr_warn("ofs 0x%08x has already been seen. Skipping\n", 613 613 + ofs); 622 614 if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 623 615 return err; 624 616 ofs += 4; ··· 628 618 prevofs = ofs; 629 619 630 620 if (jeb->offset + c->sector_size < ofs + sizeof(*node)) { 631 631 - D1(printk(KERN_DEBUG "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n", sizeof(struct jffs2_unknown_node), 632 632 - jeb->offset, c->sector_size, ofs, sizeof(*node))); 621 621 + jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n", 622 622 + sizeof(struct jffs2_unknown_node), 623 623 + jeb->offset, c->sector_size, ofs, 624 624 + sizeof(*node)); 633 625 if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs))) 634 626 return err; 635 627 break; ··· 639 627 640 628 if (buf_ofs + buf_len < ofs + sizeof(*node)) { 641 629 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 642 642 - D1(printk(KERN_DEBUG "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 643 643 - sizeof(struct jffs2_unknown_node), buf_len, ofs)); 630 630 + jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n", 631 631 + sizeof(struct jffs2_unknown_node), 632 632 + buf_len, ofs); 644 633 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 645 634 if (err) 646 635 return err; ··· 658 645 ofs += 4; 659 646 scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len); 660 647 661 661 - D1(printk(KERN_DEBUG "Found empty flash at 0x%08x\n", ofs)); 648 648 + jffs2_dbg(1, "Found empty flash at 0x%08x\n", ofs); 662 649 more_empty: 663 650 inbuf_ofs = ofs - buf_ofs; 664 651 while (inbuf_ofs < scan_end) { 665 652 if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) { 666 666 - printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n", 667 667 - empty_start, ofs); 653 653 + pr_warn("Empty flash at 0x%08x ends at 0x%08x\n", 654 654 + empty_start, ofs); 668 655 if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start))) 669 656 return err; 670 657 goto scan_more; ··· 674 661 ofs += 4; 675 662 } 676 663 /* Ran off end. */ 677 677 - D1(printk(KERN_DEBUG "Empty flash to end of buffer at 0x%08x\n", ofs)); 664 664 + jffs2_dbg(1, "Empty flash to end of buffer at 0x%08x\n", 665 665 + ofs); 678 666 679 667 /* If we're only checking the beginning of a block with a cleanmarker, 680 668 bail now */ 681 669 if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) && 682 670 c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) { 683 683 - D1(printk(KERN_DEBUG "%d bytes at start of block seems clean... assuming all clean\n", EMPTY_SCAN_SIZE(c->sector_size))); 671 671 + jffs2_dbg(1, "%d bytes at start of block seems clean... assuming all clean\n", 672 672 + EMPTY_SCAN_SIZE(c->sector_size)); 684 673 return BLK_STATE_CLEANMARKER; 685 674 } 686 675 if (!buf_size && (scan_end != buf_len)) {/* XIP/point case */ ··· 695 680 if (!buf_len) { 696 681 /* No more to read. Break out of main loop without marking 697 682 this range of empty space as dirty (because it's not) */ 698 698 - D1(printk(KERN_DEBUG "Empty flash at %08x runs to end of block. Treating as free_space\n", 699 699 - empty_start)); 683 683 + jffs2_dbg(1, "Empty flash at %08x runs to end of block. Treating as free_space\n", 684 684 + empty_start); 700 685 break; 701 686 } 702 687 /* point never reaches here */ 703 688 scan_end = buf_len; 704 704 - D1(printk(KERN_DEBUG "Reading another 0x%x at 0x%08x\n", buf_len, ofs)); 689 689 + jffs2_dbg(1, "Reading another 0x%x at 0x%08x\n", 690 690 + buf_len, ofs); 705 691 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 706 692 if (err) 707 693 return err; ··· 711 695 } 712 696 713 697 if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) { 714 714 - printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs); 698 698 + pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", 699 699 + ofs); 715 700 if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 716 701 return err; 717 702 ofs += 4; 718 703 continue; 719 704 } 720 705 if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) { 721 721 - D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs)); 706 706 + jffs2_dbg(1, "Dirty bitmask at 0x%08x\n", ofs); 722 707 if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 723 708 return err; 724 709 ofs += 4; 725 710 continue; 726 711 } 727 712 if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) { 728 728 - printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs); 729 729 - printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n"); 713 713 + pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs); 714 714 + pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n"); 730 715 if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 731 716 return err; 732 717 ofs += 4; ··· 735 718 } 736 719 if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) { 737 720 /* OK. We're out of possibilities. Whinge and move on */ 738 738 - noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 721 721 + noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n", 722 722 + __func__, 739 723 JFFS2_MAGIC_BITMASK, ofs, 740 724 je16_to_cpu(node->magic)); 741 725 if ((err = jffs2_scan_dirty_space(c, jeb, 4))) ··· 751 733 hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4); 752 734 753 735 if (hdr_crc != je32_to_cpu(node->hdr_crc)) { 754 754 - noisy_printk(&noise, "jffs2_scan_eraseblock(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n", 736 736 + noisy_printk(&noise, "%s(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n", 737 737 + __func__, 755 738 ofs, je16_to_cpu(node->magic), 756 739 je16_to_cpu(node->nodetype), 757 740 je32_to_cpu(node->totlen), ··· 766 747 767 748 if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) { 768 749 /* Eep. Node goes over the end of the erase block. */ 769 769 - printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 770 770 - ofs, je32_to_cpu(node->totlen)); 771 771 - printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n"); 750 750 + pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n", 751 751 + ofs, je32_to_cpu(node->totlen)); 752 752 + pr_warn("Perhaps the file system was created with the wrong erase size?\n"); 772 753 if ((err = jffs2_scan_dirty_space(c, jeb, 4))) 773 754 return err; 774 755 ofs += 4; ··· 777 758 778 759 if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) { 779 760 /* Wheee. This is an obsoleted node */ 780 780 - D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs)); 761 761 + jffs2_dbg(2, "Node at 0x%08x is obsolete. Skipping\n", 762 762 + ofs); 781 763 if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 782 764 return err; 783 765 ofs += PAD(je32_to_cpu(node->totlen)); ··· 789 769 case JFFS2_NODETYPE_INODE: 790 770 if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) { 791 771 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 792 792 - D1(printk(KERN_DEBUG "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 793 793 - sizeof(struct jffs2_raw_inode), buf_len, ofs)); 772 772 + jffs2_dbg(1, "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n", 773 773 + sizeof(struct jffs2_raw_inode), 774 774 + buf_len, ofs); 794 775 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 795 776 if (err) 796 777 return err; ··· 806 785 case JFFS2_NODETYPE_DIRENT: 807 786 if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 808 787 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 809 809 - D1(printk(KERN_DEBUG "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 810 810 - je32_to_cpu(node->totlen), buf_len, ofs)); 788 788 + jffs2_dbg(1, "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n", 789 789 + je32_to_cpu(node->totlen), buf_len, 790 790 + ofs); 811 791 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 812 792 if (err) 813 793 return err; ··· 824 802 case JFFS2_NODETYPE_XATTR: 825 803 if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 826 804 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 827 827 - D1(printk(KERN_DEBUG "Fewer than %d bytes (xattr node)" 828 828 - " left to end of buf. Reading 0x%x at 0x%08x\n", 829 829 - je32_to_cpu(node->totlen), buf_len, ofs)); 805 805 + jffs2_dbg(1, "Fewer than %d bytes (xattr node) left to end of buf. Reading 0x%x at 0x%08x\n", 806 806 + je32_to_cpu(node->totlen), buf_len, 807 807 + ofs); 830 808 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 831 809 if (err) 832 810 return err; ··· 841 819 case JFFS2_NODETYPE_XREF: 842 820 if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) { 843 821 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 844 844 - D1(printk(KERN_DEBUG "Fewer than %d bytes (xref node)" 845 845 - " left to end of buf. Reading 0x%x at 0x%08x\n", 846 846 - je32_to_cpu(node->totlen), buf_len, ofs)); 822 822 + jffs2_dbg(1, "Fewer than %d bytes (xref node) left to end of buf. Reading 0x%x at 0x%08x\n", 823 823 + je32_to_cpu(node->totlen), buf_len, 824 824 + ofs); 847 825 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len); 848 826 if (err) 849 827 return err; ··· 858 836 #endif /* CONFIG_JFFS2_FS_XATTR */ 859 837 860 838 case JFFS2_NODETYPE_CLEANMARKER: 861 861 - D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs)); 839 839 + jffs2_dbg(1, "CLEANMARKER node found at 0x%08x\n", ofs); 862 840 if (je32_to_cpu(node->totlen) != c->cleanmarker_size) { 863 863 - printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 864 864 - ofs, je32_to_cpu(node->totlen), c->cleanmarker_size); 841 841 + pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n", 842 842 + ofs, je32_to_cpu(node->totlen), 843 843 + c->cleanmarker_size); 865 844 if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 866 845 return err; 867 846 ofs += PAD(sizeof(struct jffs2_unknown_node)); 868 847 } else if (jeb->first_node) { 869 869 - printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset); 848 848 + pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", 849 849 + ofs, jeb->offset); 870 850 if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node))))) 871 851 return err; 872 852 ofs += PAD(sizeof(struct jffs2_unknown_node)); ··· 890 866 default: 891 867 switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) { 892 868 case JFFS2_FEATURE_ROCOMPAT: 893 893 - printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 869 869 + pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", 870 870 + je16_to_cpu(node->nodetype), ofs); 894 871 c->flags |= JFFS2_SB_FLAG_RO; 895 872 if (!(jffs2_is_readonly(c))) 896 873 return -EROFS; ··· 901 876 break; 902 877 903 878 case JFFS2_FEATURE_INCOMPAT: 904 904 - printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs); 879 879 + pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n", 880 880 + je16_to_cpu(node->nodetype), ofs); 905 881 return -EINVAL; 906 882 907 883 case JFFS2_FEATURE_RWCOMPAT_DELETE: 908 908 - D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 884 884 + jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", 885 885 + je16_to_cpu(node->nodetype), ofs); 909 886 if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen))))) 910 887 return err; 911 888 ofs += PAD(je32_to_cpu(node->totlen)); 912 889 break; 913 890 914 891 case JFFS2_FEATURE_RWCOMPAT_COPY: { 915 915 - D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs)); 892 892 + jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", 893 893 + je16_to_cpu(node->nodetype), ofs); 916 894 917 895 jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL); 918 896 ··· 936 908 } 937 909 } 938 910 939 939 - D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n", 940 940 - jeb->offset,jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size, jeb->wasted_size)); 911 911 + jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n", 912 912 + jeb->offset, jeb->free_size, jeb->dirty_size, 913 913 + jeb->unchecked_size, jeb->used_size, jeb->wasted_size); 941 914 942 915 /* mark_node_obsolete can add to wasted !! */ 943 916 if (jeb->wasted_size) { ··· 964 935 965 936 ic = jffs2_alloc_inode_cache(); 966 937 if (!ic) { 967 967 - printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n"); 938 938 + pr_notice("%s(): allocation of inode cache failed\n", __func__); 968 939 return NULL; 969 940 } 970 941 memset(ic, 0, sizeof(*ic)); ··· 983 954 struct jffs2_inode_cache *ic; 984 955 uint32_t crc, ino = je32_to_cpu(ri->ino); 985 956 986 986 - D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs)); 957 957 + jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs); 987 958 988 959 /* We do very little here now. Just check the ino# to which we should attribute 989 960 this node; we can do all the CRC checking etc. later. There's a tradeoff here -- ··· 997 968 /* Check the node CRC in any case. */ 998 969 crc = crc32(0, ri, sizeof(*ri)-8); 999 970 if (crc != je32_to_cpu(ri->node_crc)) { 1000 1000 - printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on " 1001 1001 - "node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1002 1002 - ofs, je32_to_cpu(ri->node_crc), crc); 971 971 + pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 972 972 + __func__, ofs, je32_to_cpu(ri->node_crc), crc); 1003 973 /* 1004 974 * We believe totlen because the CRC on the node 1005 975 * _header_ was OK, just the node itself failed. ··· 1017 989 /* Wheee. It worked */ 1018 990 jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic); 1019 991 1020 1020 - D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 992 992 + jffs2_dbg(1, "Node is ino #%u, version %d. Range 0x%x-0x%x\n", 1021 993 je32_to_cpu(ri->ino), je32_to_cpu(ri->version), 1022 994 je32_to_cpu(ri->offset), 1023 1023 - je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize))); 995 995 + je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize)); 1024 996 1025 997 pseudo_random += je32_to_cpu(ri->version); 1026 998 ··· 1040 1012 uint32_t crc; 1041 1013 int err; 1042 1014 1043 1043 - D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs)); 1015 1015 + jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs); 1044 1016 1045 1017 /* We don't get here unless the node is still valid, so we don't have to 1046 1018 mask in the ACCURATE bit any more. */ 1047 1019 crc = crc32(0, rd, sizeof(*rd)-8); 1048 1020 1049 1021 if (crc != je32_to_cpu(rd->node_crc)) { 1050 1050 - printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1051 1051 - ofs, je32_to_cpu(rd->node_crc), crc); 1022 1022 + pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1023 1023 + __func__, ofs, je32_to_cpu(rd->node_crc), crc); 1052 1024 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */ 1053 1025 if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen))))) 1054 1026 return err; ··· 1060 1032 /* Should never happen. Did. (OLPC trac #4184)*/ 1061 1033 checkedlen = strnlen(rd->name, rd->nsize); 1062 1034 if (checkedlen < rd->nsize) { 1063 1063 - printk(KERN_ERR "Dirent at %08x has zeroes in name. Truncating to %d chars\n", 1035 1035 + pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n", 1064 1036 ofs, checkedlen); 1065 1037 } 1066 1038 fd = jffs2_alloc_full_dirent(checkedlen+1); ··· 1072 1044 1073 1045 crc = crc32(0, fd->name, rd->nsize); 1074 1046 if (crc != je32_to_cpu(rd->name_crc)) { 1075 1075 - printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1076 1076 - ofs, je32_to_cpu(rd->name_crc), crc); 1077 1077 - D1(printk(KERN_NOTICE "Name for which CRC failed is (now) '%s', ino #%d\n", fd->name, je32_to_cpu(rd->ino))); 1047 1047 + pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n", 1048 1048 + __func__, ofs, je32_to_cpu(rd->name_crc), crc); 1049 1049 + jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n", 1050 1050 + fd->name, je32_to_cpu(rd->ino)); 1078 1051 jffs2_free_full_dirent(fd); 1079 1052 /* FIXME: Why do we believe totlen? */ 1080 1053 /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */

+2 -2

fs/jffs2/security.c

reviewed

··· 23 23 #include "nodelist.h" 24 24 25 25 /* ---- Initial Security Label(s) Attachment callback --- */ 26 26 - int jffs2_initxattrs(struct inode *inode, const struct xattr *xattr_array, 27 27 - void *fs_info) 26 26 + static int jffs2_initxattrs(struct inode *inode, 27 27 + const struct xattr *xattr_array, void *fs_info) 28 28 { 29 29 const struct xattr *xattr; 30 30 int err = 0;

+10 -6

fs/jffs2/summary.c

reviewed

··· 11 11 * 12 12 */ 13 13 14 14 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 15 + 14 16 #include <linux/kernel.h> 15 17 #include <linux/slab.h> 16 18 #include <linux/mtd/mtd.h> ··· 444 442 /* This should never happen, but https://dev.laptop.org/ticket/4184 */ 445 443 checkedlen = strnlen(spd->name, spd->nsize); 446 444 if (!checkedlen) { 447 447 - printk(KERN_ERR "Dirent at %08x has zero at start of name. Aborting mount.\n", 448 448 - jeb->offset + je32_to_cpu(spd->offset)); 445 445 + pr_err("Dirent at %08x has zero at start of name. Aborting mount.\n", 446 446 + jeb->offset + 447 447 + je32_to_cpu(spd->offset)); 449 448 return -EIO; 450 449 } 451 450 if (checkedlen < spd->nsize) { 452 452 - printk(KERN_ERR "Dirent at %08x has zeroes in name. Truncating to %d chars\n", 453 453 - jeb->offset + je32_to_cpu(spd->offset), checkedlen); 451 451 + pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n", 452 452 + jeb->offset + 453 453 + je32_to_cpu(spd->offset), 454 454 + checkedlen); 454 455 } 455 456 456 457 ··· 813 808 814 809 sum_ofs = jeb->offset + c->sector_size - jeb->free_size; 815 810 816 816 - dbg_summary("JFFS2: writing out data to flash to pos : 0x%08x\n", 817 817 - sum_ofs); 811 811 + dbg_summary("writing out data to flash to pos : 0x%08x\n", sum_ofs); 818 812 819 813 ret = jffs2_flash_writev(c, vecs, 2, sum_ofs, &retlen, 0); 820 814

+16 -14

fs/jffs2/super.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/module.h> 14 16 #include <linux/slab.h> ··· 71 69 sb->s_dirt = 0; 72 70 73 71 if (!(sb->s_flags & MS_RDONLY)) { 74 74 - D1(printk(KERN_DEBUG "jffs2_write_super()\n")); 72 72 + jffs2_dbg(1, "%s()\n", __func__); 75 73 jffs2_flush_wbuf_gc(c, 0); 76 74 } 77 75 ··· 216 214 JFFS2_COMPR_MODE_FORCEZLIB; 217 215 #endif 218 216 else { 219 219 - printk(KERN_ERR "JFFS2 Error: unknown compressor \"%s\"", 220 220 - name); 217 217 + pr_err("Error: unknown compressor \"%s\"\n", 218 218 + name); 221 219 kfree(name); 222 220 return -EINVAL; 223 221 } ··· 225 223 c->mount_opts.override_compr = true; 226 224 break; 227 225 default: 228 228 - printk(KERN_ERR "JFFS2 Error: unrecognized mount option '%s' or missing value\n", 229 229 - p); 226 226 + pr_err("Error: unrecognized mount option '%s' or missing value\n", 227 227 + p); 230 228 return -EINVAL; 231 229 } 232 230 } ··· 268 266 struct jffs2_sb_info *c; 269 267 int ret; 270 268 271 271 - D1(printk(KERN_DEBUG "jffs2_get_sb_mtd():" 269 269 + jffs2_dbg(1, "jffs2_get_sb_mtd():" 272 270 " New superblock for device %d (\"%s\")\n", 273 273 - sb->s_mtd->index, sb->s_mtd->name)); 271 271 + sb->s_mtd->index, sb->s_mtd->name); 274 272 275 273 c = kzalloc(sizeof(*c), GFP_KERNEL); 276 274 if (!c) ··· 317 315 { 318 316 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 319 317 320 320 - D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n")); 318 318 + jffs2_dbg(2, "%s()\n", __func__); 321 319 322 320 if (sb->s_dirt) 323 321 jffs2_write_super(sb); ··· 338 336 kfree(c->inocache_list); 339 337 jffs2_clear_xattr_subsystem(c); 340 338 mtd_sync(c->mtd); 341 341 - D1(printk(KERN_DEBUG "jffs2_put_super returning\n")); 339 339 + jffs2_dbg(1, "%s(): returning\n", __func__); 342 340 } 343 341 344 342 static void jffs2_kill_sb(struct super_block *sb) ··· 373 371 BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68); 374 372 BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32); 375 373 376 376 - printk(KERN_INFO "JFFS2 version 2.2." 374 374 + pr_info("version 2.2." 377 375 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 378 376 " (NAND)" 379 377 #endif ··· 388 386 SLAB_MEM_SPREAD), 389 387 jffs2_i_init_once); 390 388 if (!jffs2_inode_cachep) { 391 391 - printk(KERN_ERR "JFFS2 error: Failed to initialise inode cache\n"); 389 389 + pr_err("error: Failed to initialise inode cache\n"); 392 390 return -ENOMEM; 393 391 } 394 392 ret = jffs2_compressors_init(); 395 393 if (ret) { 396 396 - printk(KERN_ERR "JFFS2 error: Failed to initialise compressors\n"); 394 394 + pr_err("error: Failed to initialise compressors\n"); 397 395 goto out; 398 396 } 399 397 ret = jffs2_create_slab_caches(); 400 398 if (ret) { 401 401 - printk(KERN_ERR "JFFS2 error: Failed to initialise slab caches\n"); 399 399 + pr_err("error: Failed to initialise slab caches\n"); 402 400 goto out_compressors; 403 401 } 404 402 ret = register_filesystem(&jffs2_fs_type); 405 403 if (ret) { 406 406 - printk(KERN_ERR "JFFS2 error: Failed to register filesystem\n"); 404 404 + pr_err("error: Failed to register filesystem\n"); 407 405 goto out_slab; 408 406 } 409 407 return 0;

+5 -2

fs/jffs2/symlink.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/fs.h> 14 16 #include <linux/namei.h> ··· 49 47 */ 50 48 51 49 if (!p) { 52 52 - printk(KERN_ERR "jffs2_follow_link(): can't find symlink target\n"); 50 50 + pr_err("%s(): can't find symlink target\n", __func__); 53 51 p = ERR_PTR(-EIO); 54 52 } 55 55 - D1(printk(KERN_DEBUG "jffs2_follow_link(): target path is '%s'\n", (char *) f->target)); 53 53 + jffs2_dbg(1, "%s(): target path is '%s'\n", 54 54 + __func__, (char *)f->target); 56 55 57 56 nd_set_link(nd, p); 58 57

+79 -69

fs/jffs2/wbuf.c

reviewed

··· 11 11 * 12 12 */ 13 13 14 14 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 15 + 14 16 #include <linux/kernel.h> 15 17 #include <linux/slab.h> 16 18 #include <linux/mtd/mtd.h> ··· 93 91 94 92 new = kmalloc(sizeof(*new), GFP_KERNEL); 95 93 if (!new) { 96 96 - D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n")); 94 94 + jffs2_dbg(1, "No memory to allocate inodirty. Fallback to all considered dirty\n"); 97 95 jffs2_clear_wbuf_ino_list(c); 98 96 c->wbuf_inodes = &inodirty_nomem; 99 97 return; ··· 115 113 list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) { 116 114 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 117 115 118 118 - D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset)); 116 116 + jffs2_dbg(1, "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", 117 117 + jeb->offset); 119 118 list_del(this); 120 119 if ((jiffies + (n++)) & 127) { 121 120 /* Most of the time, we just erase it immediately. Otherwise we 122 121 spend ages scanning it on mount, etc. */ 123 123 - D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n")); 122 122 + jffs2_dbg(1, "...and adding to erase_pending_list\n"); 124 123 list_add_tail(&jeb->list, &c->erase_pending_list); 125 124 c->nr_erasing_blocks++; 126 125 jffs2_garbage_collect_trigger(c); 127 126 } else { 128 127 /* Sometimes, however, we leave it elsewhere so it doesn't get 129 128 immediately reused, and we spread the load a bit. */ 130 130 - D1(printk(KERN_DEBUG "...and adding to erasable_list\n")); 129 129 + jffs2_dbg(1, "...and adding to erasable_list\n"); 131 130 list_add_tail(&jeb->list, &c->erasable_list); 132 131 } 133 132 } ··· 139 136 140 137 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty) 141 138 { 142 142 - D1(printk("About to refile bad block at %08x\n", jeb->offset)); 139 139 + jffs2_dbg(1, "About to refile bad block at %08x\n", jeb->offset); 143 140 144 141 /* File the existing block on the bad_used_list.... */ 145 142 if (c->nextblock == jeb) ··· 147 144 else /* Not sure this should ever happen... need more coffee */ 148 145 list_del(&jeb->list); 149 146 if (jeb->first_node) { 150 150 - D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset)); 147 147 + jffs2_dbg(1, "Refiling block at %08x to bad_used_list\n", 148 148 + jeb->offset); 151 149 list_add(&jeb->list, &c->bad_used_list); 152 150 } else { 153 151 BUG_ON(allow_empty == REFILE_NOTEMPTY); 154 152 /* It has to have had some nodes or we couldn't be here */ 155 155 - D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset)); 153 153 + jffs2_dbg(1, "Refiling block at %08x to erase_pending_list\n", 154 154 + jeb->offset); 156 155 list_add(&jeb->list, &c->erase_pending_list); 157 156 c->nr_erasing_blocks++; 158 157 jffs2_garbage_collect_trigger(c); ··· 235 230 236 231 ret = mtd_read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify); 237 232 if (ret && ret != -EUCLEAN && ret != -EBADMSG) { 238 238 - printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x failed: %d\n", c->wbuf_ofs, ret); 233 233 + pr_warn("%s(): Read back of page at %08x failed: %d\n", 234 234 + __func__, c->wbuf_ofs, ret); 239 235 return ret; 240 236 } else if (retlen != c->wbuf_pagesize) { 241 241 - printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x gave short read: %zd not %d.\n", ofs, retlen, c->wbuf_pagesize); 237 237 + pr_warn("%s(): Read back of page at %08x gave short read: %zd not %d\n", 238 238 + __func__, ofs, retlen, c->wbuf_pagesize); 242 239 return -EIO; 243 240 } 244 241 if (!memcmp(buf, c->wbuf_verify, c->wbuf_pagesize)) ··· 253 246 else 254 247 eccstr = "OK or unused"; 255 248 256 256 - printk(KERN_WARNING "Write verify error (ECC %s) at %08x. Wrote:\n", 257 257 - eccstr, c->wbuf_ofs); 249 249 + pr_warn("Write verify error (ECC %s) at %08x. Wrote:\n", 250 250 + eccstr, c->wbuf_ofs); 258 251 print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1, 259 252 c->wbuf, c->wbuf_pagesize, 0); 260 253 261 261 - printk(KERN_WARNING "Read back:\n"); 254 254 + pr_warn("Read back:\n"); 262 255 print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1, 263 256 c->wbuf_verify, c->wbuf_pagesize, 0); 264 257 ··· 315 308 316 309 if (!first_raw) { 317 310 /* All nodes were obsolete. Nothing to recover. */ 318 318 - D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n")); 311 311 + jffs2_dbg(1, "No non-obsolete nodes to be recovered. Just filing block bad\n"); 319 312 c->wbuf_len = 0; 320 313 return; 321 314 } ··· 338 331 339 332 buf = kmalloc(end - start, GFP_KERNEL); 340 333 if (!buf) { 341 341 - printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n"); 334 334 + pr_crit("Malloc failure in wbuf recovery. Data loss ensues.\n"); 342 335 343 336 goto read_failed; 344 337 } ··· 353 346 ret = 0; 354 347 355 348 if (ret || retlen != c->wbuf_ofs - start) { 356 356 - printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n"); 349 349 + pr_crit("Old data are already lost in wbuf recovery. Data loss ensues.\n"); 357 350 358 351 kfree(buf); 359 352 buf = NULL; ··· 387 380 /* ... and get an allocation of space from a shiny new block instead */ 388 381 ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE); 389 382 if (ret) { 390 390 - printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n"); 383 383 + pr_warn("Failed to allocate space for wbuf recovery. Data loss ensues.\n"); 391 384 kfree(buf); 392 385 return; 393 386 } ··· 397 390 398 391 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile); 399 392 if (ret) { 400 400 - printk(KERN_WARNING "Failed to allocate node refs for wbuf recovery. Data loss ensues.\n"); 393 393 + pr_warn("Failed to allocate node refs for wbuf recovery. Data loss ensues.\n"); 401 394 kfree(buf); 402 395 return; 403 396 } ··· 413 406 unsigned char *rewrite_buf = buf?:c->wbuf; 414 407 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize); 415 408 416 416 - D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n", 417 417 - towrite, ofs)); 409 409 + jffs2_dbg(1, "Write 0x%x bytes at 0x%08x in wbuf recover\n", 410 410 + towrite, ofs); 418 411 419 412 #ifdef BREAKMEHEADER 420 413 static int breakme; 421 414 if (breakme++ == 20) { 422 422 - printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs); 415 415 + pr_notice("Faking write error at 0x%08x\n", ofs); 423 416 breakme = 0; 424 417 mtd_write(c->mtd, ofs, towrite, &retlen, brokenbuf); 425 418 ret = -EIO; ··· 430 423 431 424 if (ret || retlen != towrite || jffs2_verify_write(c, rewrite_buf, ofs)) { 432 425 /* Argh. We tried. Really we did. */ 433 433 - printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n"); 426 426 + pr_crit("Recovery of wbuf failed due to a second write error\n"); 434 427 kfree(buf); 435 428 436 429 if (retlen) ··· 438 431 439 432 return; 440 433 } 441 441 - printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs); 434 434 + pr_notice("Recovery of wbuf succeeded to %08x\n", ofs); 442 435 443 436 c->wbuf_len = (end - start) - towrite; 444 437 c->wbuf_ofs = ofs + towrite; ··· 466 459 struct jffs2_raw_node_ref **adjust_ref = NULL; 467 460 struct jffs2_inode_info *f = NULL; 468 461 469 469 - D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n", 470 470 - rawlen, ref_offset(raw), ref_flags(raw), ofs)); 462 462 + jffs2_dbg(1, "Refiling block of %08x at %08x(%d) to %08x\n", 463 463 + rawlen, ref_offset(raw), ref_flags(raw), ofs); 471 464 472 465 ic = jffs2_raw_ref_to_ic(raw); 473 466 ··· 547 540 548 541 /* Fix up the original jeb now it's on the bad_list */ 549 542 if (first_raw == jeb->first_node) { 550 550 - D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset)); 543 543 + jffs2_dbg(1, "Failing block at %08x is now empty. Moving to erase_pending_list\n", 544 544 + jeb->offset); 551 545 list_move(&jeb->list, &c->erase_pending_list); 552 546 c->nr_erasing_blocks++; 553 547 jffs2_garbage_collect_trigger(c); ··· 562 554 563 555 spin_unlock(&c->erase_completion_lock); 564 556 565 565 - D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len)); 557 557 + jffs2_dbg(1, "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", 558 558 + c->wbuf_ofs, c->wbuf_len); 566 559 567 560 } 568 561 ··· 588 579 return 0; 589 580 590 581 if (!mutex_is_locked(&c->alloc_sem)) { 591 591 - printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n"); 582 582 + pr_crit("jffs2_flush_wbuf() called with alloc_sem not locked!\n"); 592 583 BUG(); 593 584 } 594 585 ··· 626 617 #ifdef BREAKME 627 618 static int breakme; 628 619 if (breakme++ == 20) { 629 629 - printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs); 620 620 + pr_notice("Faking write error at 0x%08x\n", c->wbuf_ofs); 630 621 breakme = 0; 631 622 mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, 632 623 brokenbuf); ··· 638 629 &retlen, c->wbuf); 639 630 640 631 if (ret) { 641 641 - printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n", ret); 632 632 + pr_warn("jffs2_flush_wbuf(): Write failed with %d\n", ret); 642 633 goto wfail; 643 634 } else if (retlen != c->wbuf_pagesize) { 644 644 - printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n", 645 645 - retlen, c->wbuf_pagesize); 635 635 + pr_warn("jffs2_flush_wbuf(): Write was short: %zd instead of %d\n", 636 636 + retlen, c->wbuf_pagesize); 646 637 ret = -EIO; 647 638 goto wfail; 648 639 } else if ((ret = jffs2_verify_write(c, c->wbuf, c->wbuf_ofs))) { ··· 656 647 if (pad) { 657 648 uint32_t waste = c->wbuf_pagesize - c->wbuf_len; 658 649 659 659 - D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n", 660 660 - (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset)); 650 650 + jffs2_dbg(1, "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n", 651 651 + (wbuf_jeb == c->nextblock) ? "next" : "", 652 652 + wbuf_jeb->offset); 661 653 662 654 /* wbuf_pagesize - wbuf_len is the amount of space that's to be 663 655 padded. If there is less free space in the block than that, 664 656 something screwed up */ 665 657 if (wbuf_jeb->free_size < waste) { 666 666 - printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n", 667 667 - c->wbuf_ofs, c->wbuf_len, waste); 668 668 - printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n", 669 669 - wbuf_jeb->offset, wbuf_jeb->free_size); 658 658 + pr_crit("jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n", 659 659 + c->wbuf_ofs, c->wbuf_len, waste); 660 660 + pr_crit("jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n", 661 661 + wbuf_jeb->offset, wbuf_jeb->free_size); 670 662 BUG(); 671 663 } 672 664 ··· 704 694 uint32_t old_wbuf_len; 705 695 int ret = 0; 706 696 707 707 - D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino)); 697 697 + jffs2_dbg(1, "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino); 708 698 709 699 if (!c->wbuf) 710 700 return 0; 711 701 712 702 mutex_lock(&c->alloc_sem); 713 703 if (!jffs2_wbuf_pending_for_ino(c, ino)) { 714 714 - D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino)); 704 704 + jffs2_dbg(1, "Ino #%d not pending in wbuf. Returning\n", ino); 715 705 mutex_unlock(&c->alloc_sem); 716 706 return 0; 717 707 } ··· 721 711 722 712 if (c->unchecked_size) { 723 713 /* GC won't make any progress for a while */ 724 724 - D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n")); 714 714 + jffs2_dbg(1, "%s(): padding. Not finished checking\n", 715 715 + __func__); 725 716 down_write(&c->wbuf_sem); 726 717 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING); 727 718 /* retry flushing wbuf in case jffs2_wbuf_recover ··· 735 724 736 725 mutex_unlock(&c->alloc_sem); 737 726 738 738 - D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n")); 727 727 + jffs2_dbg(1, "%s(): calls gc pass\n", __func__); 739 728 740 729 ret = jffs2_garbage_collect_pass(c); 741 730 if (ret) { ··· 753 742 mutex_lock(&c->alloc_sem); 754 743 } 755 744 756 756 - D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n")); 745 745 + jffs2_dbg(1, "%s(): ends...\n", __func__); 757 746 758 747 mutex_unlock(&c->alloc_sem); 759 748 return ret; ··· 822 811 if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) { 823 812 /* It's a write to a new block */ 824 813 if (c->wbuf_len) { 825 825 - D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx " 826 826 - "causes flush of wbuf at 0x%08x\n", 827 827 - (unsigned long)to, c->wbuf_ofs)); 814 814 + jffs2_dbg(1, "%s(): to 0x%lx causes flush of wbuf at 0x%08x\n", 815 815 + __func__, (unsigned long)to, c->wbuf_ofs); 828 816 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT); 829 817 if (ret) 830 818 goto outerr; ··· 835 825 836 826 if (to != PAD(c->wbuf_ofs + c->wbuf_len)) { 837 827 /* We're not writing immediately after the writebuffer. Bad. */ 838 838 - printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write " 839 839 - "to %08lx\n", (unsigned long)to); 828 828 + pr_crit("%s(): Non-contiguous write to %08lx\n", 829 829 + __func__, (unsigned long)to); 840 830 if (c->wbuf_len) 841 841 - printk(KERN_CRIT "wbuf was previously %08x-%08x\n", 842 842 - c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len); 831 831 + pr_crit("wbuf was previously %08x-%08x\n", 832 832 + c->wbuf_ofs, c->wbuf_ofs + c->wbuf_len); 843 833 BUG(); 844 834 } 845 835 ··· 967 957 968 958 if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) { 969 959 if (ret == -EBADMSG) 970 970 - printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)" 971 971 - " returned ECC error\n", len, ofs); 960 960 + pr_warn("mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n", 961 961 + len, ofs); 972 962 /* 973 963 * We have the raw data without ECC correction in the buffer, 974 964 * maybe we are lucky and all data or parts are correct. We ··· 1044 1034 1045 1035 ret = mtd_read_oob(c->mtd, jeb->offset, &ops); 1046 1036 if (ret || ops.oobretlen != ops.ooblen) { 1047 1047 - printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd" 1048 1048 - " bytes, read %zd bytes, error %d\n", 1049 1049 - jeb->offset, ops.ooblen, ops.oobretlen, ret); 1037 1037 + pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n", 1038 1038 + jeb->offset, ops.ooblen, ops.oobretlen, ret); 1050 1039 if (!ret) 1051 1040 ret = -EIO; 1052 1041 return ret; ··· 1057 1048 continue; 1058 1049 1059 1050 if (ops.oobbuf[i] != 0xFF) { 1060 1060 - D2(printk(KERN_DEBUG "Found %02x at %x in OOB for " 1061 1061 - "%08x\n", ops.oobbuf[i], i, jeb->offset)); 1051 1051 + jffs2_dbg(2, "Found %02x at %x in OOB for " 1052 1052 + "%08x\n", ops.oobbuf[i], i, jeb->offset); 1062 1053 return 1; 1063 1054 } 1064 1055 } ··· 1086 1077 1087 1078 ret = mtd_read_oob(c->mtd, jeb->offset, &ops); 1088 1079 if (ret || ops.oobretlen != ops.ooblen) { 1089 1089 - printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd" 1090 1090 - " bytes, read %zd bytes, error %d\n", 1091 1091 - jeb->offset, ops.ooblen, ops.oobretlen, ret); 1080 1080 + pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n", 1081 1081 + jeb->offset, ops.ooblen, ops.oobretlen, ret); 1092 1082 if (!ret) 1093 1083 ret = -EIO; 1094 1084 return ret; ··· 1111 1103 1112 1104 ret = mtd_write_oob(c->mtd, jeb->offset, &ops); 1113 1105 if (ret || ops.oobretlen != ops.ooblen) { 1114 1114 - printk(KERN_ERR "cannot write OOB for EB at %08x, requested %zd" 1115 1115 - " bytes, read %zd bytes, error %d\n", 1116 1116 - jeb->offset, ops.ooblen, ops.oobretlen, ret); 1106 1106 + pr_err("cannot write OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n", 1107 1107 + jeb->offset, ops.ooblen, ops.oobretlen, ret); 1117 1108 if (!ret) 1118 1109 ret = -EIO; 1119 1110 return ret; ··· 1137 1130 if( ++jeb->bad_count < MAX_ERASE_FAILURES) 1138 1131 return 0; 1139 1132 1140 1140 - printk(KERN_WARNING "JFFS2: marking eraseblock at %08x\n as bad", bad_offset); 1133 1133 + pr_warn("marking eraseblock at %08x as bad\n", bad_offset); 1141 1134 ret = mtd_block_markbad(c->mtd, bad_offset); 1142 1135 1143 1136 if (ret) { 1144 1144 - D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret)); 1137 1137 + jffs2_dbg(1, "%s(): Write failed for block at %08x: error %d\n", 1138 1138 + __func__, jeb->offset, ret); 1145 1139 return ret; 1146 1140 } 1147 1141 return 1; ··· 1159 1151 c->cleanmarker_size = 0; 1160 1152 1161 1153 if (!oinfo || oinfo->oobavail == 0) { 1162 1162 - printk(KERN_ERR "inconsistent device description\n"); 1154 1154 + pr_err("inconsistent device description\n"); 1163 1155 return -EINVAL; 1164 1156 } 1165 1157 1166 1166 - D1(printk(KERN_DEBUG "JFFS2 using OOB on NAND\n")); 1158 1158 + jffs2_dbg(1, "using OOB on NAND\n"); 1167 1159 1168 1160 c->oobavail = oinfo->oobavail; 1169 1161 ··· 1230 1222 1231 1223 if ((c->flash_size % c->sector_size) != 0) { 1232 1224 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size; 1233 1233 - printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size); 1225 1225 + pr_warn("flash size adjusted to %dKiB\n", c->flash_size); 1234 1226 }; 1235 1227 1236 1228 c->wbuf_ofs = 0xFFFFFFFF; ··· 1247 1239 } 1248 1240 #endif 1249 1241 1250 1250 - printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size); 1242 1242 + pr_info("write-buffering enabled buffer (%d) erasesize (%d)\n", 1243 1243 + c->wbuf_pagesize, c->sector_size); 1251 1244 1252 1245 return 0; 1253 1246 } ··· 1306 1297 if (!c->wbuf) 1307 1298 return -ENOMEM; 1308 1299 1309 1309 - printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size); 1300 1300 + pr_info("write-buffering enabled buffer (%d) erasesize (%d)\n", 1301 1301 + c->wbuf_pagesize, c->sector_size); 1310 1302 1311 1303 return 0; 1312 1304 }

+64 -49

fs/jffs2/write.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/fs.h> 14 16 #include <linux/crc32.h> ··· 38 36 f->inocache->state = INO_STATE_PRESENT; 39 37 40 38 jffs2_add_ino_cache(c, f->inocache); 41 41 - D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino)); 39 39 + jffs2_dbg(1, "%s(): Assigned ino# %d\n", __func__, f->inocache->ino); 42 40 ri->ino = cpu_to_je32(f->inocache->ino); 43 41 44 42 ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); ··· 70 68 unsigned long cnt = 2; 71 69 72 70 D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) { 73 73 - printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n"); 71 71 + pr_crit("Eep. CRC not correct in jffs2_write_dnode()\n"); 74 72 BUG(); 75 73 } 76 74 ); ··· 80 78 vecs[1].iov_len = datalen; 81 79 82 80 if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) { 83 83 - printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", je32_to_cpu(ri->totlen), sizeof(*ri), datalen); 81 81 + pr_warn("%s(): ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", 82 82 + __func__, je32_to_cpu(ri->totlen), 83 83 + sizeof(*ri), datalen); 84 84 } 85 85 86 86 fn = jffs2_alloc_full_dnode(); ··· 99 95 100 96 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) { 101 97 BUG_ON(!retried); 102 102 - D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, " 103 103 - "highest version %d -> updating dnode\n", 104 104 - je32_to_cpu(ri->version), f->highest_version)); 98 98 + jffs2_dbg(1, "%s(): dnode_version %d, highest version %d -> updating dnode\n", 99 99 + __func__, 100 100 + je32_to_cpu(ri->version), f->highest_version); 105 101 ri->version = cpu_to_je32(++f->highest_version); 106 102 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 107 103 } ··· 110 106 (alloc_mode==ALLOC_GC)?0:f->inocache->ino); 111 107 112 108 if (ret || (retlen != sizeof(*ri) + datalen)) { 113 113 - printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 114 114 - sizeof(*ri)+datalen, flash_ofs, ret, retlen); 109 109 + pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 110 110 + sizeof(*ri) + datalen, flash_ofs, ret, retlen); 115 111 116 112 /* Mark the space as dirtied */ 117 113 if (retlen) { ··· 122 118 this node */ 123 119 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL); 124 120 } else { 125 125 - printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 121 121 + pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", 122 122 + flash_ofs); 126 123 } 127 124 if (!retried && alloc_mode != ALLOC_NORETRY) { 128 125 /* Try to reallocate space and retry */ ··· 132 127 133 128 retried = 1; 134 129 135 135 - D1(printk(KERN_DEBUG "Retrying failed write.\n")); 130 130 + jffs2_dbg(1, "Retrying failed write.\n"); 136 131 137 132 jffs2_dbg_acct_sanity_check(c,jeb); 138 133 jffs2_dbg_acct_paranoia_check(c, jeb); ··· 152 147 153 148 if (!ret) { 154 149 flash_ofs = write_ofs(c); 155 155 - D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 150 150 + jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write.\n", 151 151 + flash_ofs); 156 152 157 153 jffs2_dbg_acct_sanity_check(c,jeb); 158 154 jffs2_dbg_acct_paranoia_check(c, jeb); 159 155 160 156 goto retry; 161 157 } 162 162 - D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 158 158 + jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n", 159 159 + ret); 163 160 } 164 161 /* Release the full_dnode which is now useless, and return */ 165 162 jffs2_free_full_dnode(fn); ··· 190 183 fn->size = je32_to_cpu(ri->dsize); 191 184 fn->frags = 0; 192 185 193 193 - D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n", 186 186 + jffs2_dbg(1, "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n", 194 187 flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize), 195 188 je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc), 196 196 - je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen))); 189 189 + je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)); 197 190 198 191 if (retried) { 199 192 jffs2_dbg_acct_sanity_check(c,NULL); ··· 213 206 int retried = 0; 214 207 int ret; 215 208 216 216 - D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 209 209 + jffs2_dbg(1, "%s(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n", 210 210 + __func__, 217 211 je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 218 218 - je32_to_cpu(rd->name_crc))); 212 212 + je32_to_cpu(rd->name_crc)); 219 213 220 214 D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) { 221 221 - printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n"); 215 215 + pr_crit("Eep. CRC not correct in jffs2_write_dirent()\n"); 222 216 BUG(); 223 217 }); 224 218 225 219 if (strnlen(name, namelen) != namelen) { 226 220 /* This should never happen, but seems to have done on at least one 227 221 occasion: https://dev.laptop.org/ticket/4184 */ 228 228 - printk(KERN_CRIT "Error in jffs2_write_dirent() -- name contains zero bytes!\n"); 229 229 - printk(KERN_CRIT "Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n", 230 230 - je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 231 231 - je32_to_cpu(rd->name_crc)); 222 222 + pr_crit("Error in jffs2_write_dirent() -- name contains zero bytes!\n"); 223 223 + pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n", 224 224 + je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino), 225 225 + je32_to_cpu(rd->name_crc)); 232 226 WARN_ON(1); 233 227 return ERR_PTR(-EIO); 234 228 } ··· 257 249 258 250 if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) { 259 251 BUG_ON(!retried); 260 260 - D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, " 261 261 - "highest version %d -> updating dirent\n", 262 262 - je32_to_cpu(rd->version), f->highest_version)); 252 252 + jffs2_dbg(1, "%s(): dirent_version %d, highest version %d -> updating dirent\n", 253 253 + __func__, 254 254 + je32_to_cpu(rd->version), f->highest_version); 263 255 rd->version = cpu_to_je32(++f->highest_version); 264 256 fd->version = je32_to_cpu(rd->version); 265 257 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); ··· 268 260 ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen, 269 261 (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino)); 270 262 if (ret || (retlen != sizeof(*rd) + namelen)) { 271 271 - printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 272 272 - sizeof(*rd)+namelen, flash_ofs, ret, retlen); 263 263 + pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n", 264 264 + sizeof(*rd) + namelen, flash_ofs, ret, retlen); 273 265 /* Mark the space as dirtied */ 274 266 if (retlen) { 275 267 jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL); 276 268 } else { 277 277 - printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs); 269 269 + pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", 270 270 + flash_ofs); 278 271 } 279 272 if (!retried) { 280 273 /* Try to reallocate space and retry */ ··· 284 275 285 276 retried = 1; 286 277 287 287 - D1(printk(KERN_DEBUG "Retrying failed write.\n")); 278 278 + jffs2_dbg(1, "Retrying failed write.\n"); 288 279 289 280 jffs2_dbg_acct_sanity_check(c,jeb); 290 281 jffs2_dbg_acct_paranoia_check(c, jeb); ··· 304 295 305 296 if (!ret) { 306 297 flash_ofs = write_ofs(c); 307 307 - D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs)); 298 298 + jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write\n", 299 299 + flash_ofs); 308 300 jffs2_dbg_acct_sanity_check(c,jeb); 309 301 jffs2_dbg_acct_paranoia_check(c, jeb); 310 302 goto retry; 311 303 } 312 312 - D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret)); 304 304 + jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n", 305 305 + ret); 313 306 } 314 307 /* Release the full_dnode which is now useless, and return */ 315 308 jffs2_free_full_dirent(fd); ··· 344 333 int ret = 0; 345 334 uint32_t writtenlen = 0; 346 335 347 347 - D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n", 348 348 - f->inocache->ino, offset, writelen)); 336 336 + jffs2_dbg(1, "%s(): Ino #%u, ofs 0x%x, len 0x%x\n", 337 337 + __func__, f->inocache->ino, offset, writelen); 349 338 350 339 while(writelen) { 351 340 struct jffs2_full_dnode *fn; ··· 356 345 int retried = 0; 357 346 358 347 retry: 359 359 - D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset)); 348 348 + jffs2_dbg(2, "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", 349 349 + writelen, offset); 360 350 361 351 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, 362 352 &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); 363 353 if (ret) { 364 364 - D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret)); 354 354 + jffs2_dbg(1, "jffs2_reserve_space returned %d\n", ret); 365 355 break; 366 356 } 367 357 mutex_lock(&f->sem); ··· 398 386 if (!retried) { 399 387 /* Write error to be retried */ 400 388 retried = 1; 401 401 - D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n")); 389 389 + jffs2_dbg(1, "Retrying node write in jffs2_write_inode_range()\n"); 402 390 goto retry; 403 391 } 404 392 break; ··· 411 399 } 412 400 if (ret) { 413 401 /* Eep */ 414 414 - D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret)); 402 402 + jffs2_dbg(1, "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", 403 403 + ret); 415 404 jffs2_mark_node_obsolete(c, fn->raw); 416 405 jffs2_free_full_dnode(fn); 417 406 ··· 423 410 mutex_unlock(&f->sem); 424 411 jffs2_complete_reservation(c); 425 412 if (!datalen) { 426 426 - printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); 413 413 + pr_warn("Eep. We didn't actually write any data in jffs2_write_inode_range()\n"); 427 414 ret = -EIO; 428 415 break; 429 416 } 430 430 - D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen)); 417 417 + jffs2_dbg(1, "increasing writtenlen by %d\n", datalen); 431 418 writtenlen += datalen; 432 419 offset += datalen; 433 420 writelen -= datalen; ··· 452 439 */ 453 440 ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 454 441 JFFS2_SUMMARY_INODE_SIZE); 455 455 - D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen)); 442 442 + jffs2_dbg(1, "%s(): reserved 0x%x bytes\n", __func__, alloclen); 456 443 if (ret) 457 444 return ret; 458 445 ··· 463 450 464 451 fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 465 452 466 466 - D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n", 467 467 - jemode_to_cpu(ri->mode))); 453 453 + jffs2_dbg(1, "jffs2_do_create created file with mode 0x%x\n", 454 454 + jemode_to_cpu(ri->mode)); 468 455 469 456 if (IS_ERR(fn)) { 470 470 - D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n")); 457 457 + jffs2_dbg(1, "jffs2_write_dnode() failed\n"); 471 458 /* Eeek. Wave bye bye */ 472 459 mutex_unlock(&f->sem); 473 460 jffs2_complete_reservation(c); ··· 493 480 494 481 if (ret) { 495 482 /* Eep. */ 496 496 - D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n")); 483 483 + jffs2_dbg(1, "jffs2_reserve_space() for dirent failed\n"); 497 484 return ret; 498 485 } 499 486 ··· 610 597 !memcmp(fd->name, name, namelen) && 611 598 !fd->name[namelen]) { 612 599 613 613 - D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n", 614 614 - fd->ino, ref_offset(fd->raw))); 600 600 + jffs2_dbg(1, "Marking old dirent node (ino #%u) @%08x obsolete\n", 601 601 + fd->ino, ref_offset(fd->raw)); 615 602 jffs2_mark_node_obsolete(c, fd->raw); 616 603 /* We don't want to remove it from the list immediately, 617 604 because that screws up getdents()/seek() semantics even ··· 640 627 dead_f->dents = fd->next; 641 628 642 629 if (fd->ino) { 643 643 - printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 644 644 - dead_f->inocache->ino, fd->name, fd->ino); 630 630 + pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 631 631 + dead_f->inocache->ino, 632 632 + fd->name, fd->ino); 645 633 } else { 646 646 - D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n", 647 647 - fd->name, dead_f->inocache->ino)); 634 634 + jffs2_dbg(1, "Removing deletion dirent for \"%s\" from dir ino #%u\n", 635 635 + fd->name, 636 636 + dead_f->inocache->ino); 648 637 } 649 638 if (fd->raw) 650 639 jffs2_mark_node_obsolete(c, fd->raw);

+2

fs/jffs2/xattr.c

reviewed

··· 9 9 * 10 10 */ 11 11 12 12 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 13 + 12 14 #include <linux/kernel.h> 13 15 #include <linux/slab.h> 14 16 #include <linux/fs.h>

+1 -1

fs/romfs/storage.c

reviewed

··· 19 19 #endif 20 20 21 21 #ifdef CONFIG_ROMFS_ON_MTD 22 22 - #define ROMFS_MTD_READ(sb, ...) ((sb)->s_mtd->read((sb)->s_mtd, ##__VA_ARGS__)) 22 22 + #define ROMFS_MTD_READ(sb, ...) mtd_read((sb)->s_mtd, ##__VA_ARGS__) 23 23 24 24 /* 25 25 * read data from an romfs image on an MTD device

+5

include/linux/mtd/bbm.h

reviewed

··· 112 112 #define NAND_BBT_USE_FLASH 0x00020000 113 113 /* Do not store flash based bad block table in OOB area; store it in-band */ 114 114 #define NAND_BBT_NO_OOB 0x00040000 115 115 + /* 116 116 + * Do not write new bad block markers to OOB; useful, e.g., when ECC covers 117 117 + * entire spare area. Must be used with NAND_BBT_USE_FLASH. 118 118 + */ 119 119 + #define NAND_BBT_NO_OOB_BBM 0x00080000 115 120 116 121 /* 117 122 * Flag set by nand_create_default_bbt_descr(), marking that the nand_bbt_descr

+1

include/linux/mtd/blktrans.h

reviewed

··· 47 47 struct request_queue *rq; 48 48 spinlock_t queue_lock; 49 49 void *priv; 50 50 + fmode_t file_mode; 50 51 }; 51 52 52 53 struct mtd_blktrans_ops {

+89 -76

include/linux/mtd/fsmc.h

reviewed

··· 26 26 #define FSMC_NAND_BW8 1 27 27 #define FSMC_NAND_BW16 2 28 28 29 29 - /* 30 30 - * The placement of the Command Latch Enable (CLE) and 31 31 - * Address Latch Enable (ALE) is twisted around in the 32 32 - * SPEAR310 implementation. 33 33 - */ 34 34 - #if defined(CONFIG_MACH_SPEAR310) 35 35 - #define PLAT_NAND_CLE (1 << 17) 36 36 - #define PLAT_NAND_ALE (1 << 16) 37 37 - #else 38 38 - #define PLAT_NAND_CLE (1 << 16) 39 39 - #define PLAT_NAND_ALE (1 << 17) 40 40 - #endif 41 41 - 42 29 #define FSMC_MAX_NOR_BANKS 4 43 30 #define FSMC_MAX_NAND_BANKS 4 44 31 45 32 #define FSMC_FLASH_WIDTH8 1 46 33 #define FSMC_FLASH_WIDTH16 2 47 34 48 48 - struct fsmc_nor_bank_regs { 49 49 - uint32_t ctrl; 50 50 - uint32_t ctrl_tim; 51 51 - }; 35 35 + /* fsmc controller registers for NOR flash */ 36 36 + #define CTRL 0x0 37 37 + /* ctrl register definitions */ 38 38 + #define BANK_ENABLE (1 << 0) 39 39 + #define MUXED (1 << 1) 40 40 + #define NOR_DEV (2 << 2) 41 41 + #define WIDTH_8 (0 << 4) 42 42 + #define WIDTH_16 (1 << 4) 43 43 + #define RSTPWRDWN (1 << 6) 44 44 + #define WPROT (1 << 7) 45 45 + #define WRT_ENABLE (1 << 12) 46 46 + #define WAIT_ENB (1 << 13) 52 47 53 53 - /* ctrl register definitions */ 54 54 - #define BANK_ENABLE (1 << 0) 55 55 - #define MUXED (1 << 1) 56 56 - #define NOR_DEV (2 << 2) 57 57 - #define WIDTH_8 (0 << 4) 58 58 - #define WIDTH_16 (1 << 4) 59 59 - #define RSTPWRDWN (1 << 6) 60 60 - #define WPROT (1 << 7) 61 61 - #define WRT_ENABLE (1 << 12) 62 62 - #define WAIT_ENB (1 << 13) 48 48 + #define CTRL_TIM 0x4 49 49 + /* ctrl_tim register definitions */ 63 50 64 64 - /* ctrl_tim register definitions */ 65 65 - 66 66 - struct fsmc_nand_bank_regs { 67 67 - uint32_t pc; 68 68 - uint32_t sts; 69 69 - uint32_t comm; 70 70 - uint32_t attrib; 71 71 - uint32_t ioata; 72 72 - uint32_t ecc1; 73 73 - uint32_t ecc2; 74 74 - uint32_t ecc3; 75 75 - }; 76 76 - 51 51 + #define FSMC_NOR_BANK_SZ 0x8 77 52 #define FSMC_NOR_REG_SIZE 0x40 78 53 79 79 - struct fsmc_regs { 80 80 - struct fsmc_nor_bank_regs nor_bank_regs[FSMC_MAX_NOR_BANKS]; 81 81 - uint8_t reserved_1[0x40 - 0x20]; 82 82 - struct fsmc_nand_bank_regs bank_regs[FSMC_MAX_NAND_BANKS]; 83 83 - uint8_t reserved_2[0xfe0 - 0xc0]; 84 84 - uint32_t peripid0; /* 0xfe0 */ 85 85 - uint32_t peripid1; /* 0xfe4 */ 86 86 - uint32_t peripid2; /* 0xfe8 */ 87 87 - uint32_t peripid3; /* 0xfec */ 88 88 - uint32_t pcellid0; /* 0xff0 */ 89 89 - uint32_t pcellid1; /* 0xff4 */ 90 90 - uint32_t pcellid2; /* 0xff8 */ 91 91 - uint32_t pcellid3; /* 0xffc */ 92 92 - }; 54 54 + #define FSMC_NOR_REG(base, bank, reg) (base + \ 55 55 + FSMC_NOR_BANK_SZ * (bank) + \ 56 56 + reg) 57 57 + 58 58 + /* fsmc controller registers for NAND flash */ 59 59 + #define PC 0x00 60 60 + /* pc register definitions */ 61 61 + #define FSMC_RESET (1 << 0) 62 62 + #define FSMC_WAITON (1 << 1) 63 63 + #define FSMC_ENABLE (1 << 2) 64 64 + #define FSMC_DEVTYPE_NAND (1 << 3) 65 65 + #define FSMC_DEVWID_8 (0 << 4) 66 66 + #define FSMC_DEVWID_16 (1 << 4) 67 67 + #define FSMC_ECCEN (1 << 6) 68 68 + #define FSMC_ECCPLEN_512 (0 << 7) 69 69 + #define FSMC_ECCPLEN_256 (1 << 7) 70 70 + #define FSMC_TCLR_1 (1) 71 71 + #define FSMC_TCLR_SHIFT (9) 72 72 + #define FSMC_TCLR_MASK (0xF) 73 73 + #define FSMC_TAR_1 (1) 74 74 + #define FSMC_TAR_SHIFT (13) 75 75 + #define FSMC_TAR_MASK (0xF) 76 76 + #define STS 0x04 77 77 + /* sts register definitions */ 78 78 + #define FSMC_CODE_RDY (1 << 15) 79 79 + #define COMM 0x08 80 80 + /* comm register definitions */ 81 81 + #define FSMC_TSET_0 0 82 82 + #define FSMC_TSET_SHIFT 0 83 83 + #define FSMC_TSET_MASK 0xFF 84 84 + #define FSMC_TWAIT_6 6 85 85 + #define FSMC_TWAIT_SHIFT 8 86 86 + #define FSMC_TWAIT_MASK 0xFF 87 87 + #define FSMC_THOLD_4 4 88 88 + #define FSMC_THOLD_SHIFT 16 89 89 + #define FSMC_THOLD_MASK 0xFF 90 90 + #define FSMC_THIZ_1 1 91 91 + #define FSMC_THIZ_SHIFT 24 92 92 + #define FSMC_THIZ_MASK 0xFF 93 93 + #define ATTRIB 0x0C 94 94 + #define IOATA 0x10 95 95 + #define ECC1 0x14 96 96 + #define ECC2 0x18 97 97 + #define ECC3 0x1C 98 98 + #define FSMC_NAND_BANK_SZ 0x20 99 99 + 100 100 + #define FSMC_NAND_REG(base, bank, reg) (base + FSMC_NOR_REG_SIZE + \ 101 101 + (FSMC_NAND_BANK_SZ * (bank)) + \ 102 102 + reg) 93 103 94 104 #define FSMC_BUSY_WAIT_TIMEOUT (1 * HZ) 95 95 - 96 96 - /* pc register definitions */ 97 97 - #define FSMC_RESET (1 << 0) 98 98 - #define FSMC_WAITON (1 << 1) 99 99 - #define FSMC_ENABLE (1 << 2) 100 100 - #define FSMC_DEVTYPE_NAND (1 << 3) 101 101 - #define FSMC_DEVWID_8 (0 << 4) 102 102 - #define FSMC_DEVWID_16 (1 << 4) 103 103 - #define FSMC_ECCEN (1 << 6) 104 104 - #define FSMC_ECCPLEN_512 (0 << 7) 105 105 - #define FSMC_ECCPLEN_256 (1 << 7) 106 106 - #define FSMC_TCLR_1 (1 << 9) 107 107 - #define FSMC_TAR_1 (1 << 13) 108 108 - 109 109 - /* sts register definitions */ 110 110 - #define FSMC_CODE_RDY (1 << 15) 111 111 - 112 112 - /* comm register definitions */ 113 113 - #define FSMC_TSET_0 (0 << 0) 114 114 - #define FSMC_TWAIT_6 (6 << 8) 115 115 - #define FSMC_THOLD_4 (4 << 16) 116 116 - #define FSMC_THIZ_1 (1 << 24) 117 105 118 106 /* 119 107 * There are 13 bytes of ecc for every 512 byte block in FSMC version 8 ··· 121 133 struct fsmc_nand_eccplace eccplace[MAX_ECCPLACE_ENTRIES]; 122 134 }; 123 135 136 136 + struct fsmc_nand_timings { 137 137 + uint8_t tclr; 138 138 + uint8_t tar; 139 139 + uint8_t thiz; 140 140 + uint8_t thold; 141 141 + uint8_t twait; 142 142 + uint8_t tset; 143 143 + }; 144 144 + 145 145 + enum access_mode { 146 146 + USE_DMA_ACCESS = 1, 147 147 + USE_WORD_ACCESS, 148 148 + }; 149 149 + 124 150 /** 125 151 * fsmc_nand_platform_data - platform specific NAND controller config 126 152 * @partitions: partition table for the platform, use a default fallback ··· 148 146 * this may be set to NULL 149 147 */ 150 148 struct fsmc_nand_platform_data { 149 149 + struct fsmc_nand_timings *nand_timings; 151 150 struct mtd_partition *partitions; 152 151 unsigned int nr_partitions; 153 152 unsigned int options; 154 153 unsigned int width; 155 154 unsigned int bank; 155 155 + 156 156 + /* CLE, ALE offsets */ 157 157 + unsigned int cle_off; 158 158 + unsigned int ale_off; 159 159 + enum access_mode mode; 160 160 + 156 161 void (*select_bank)(uint32_t bank, uint32_t busw); 162 162 + 163 163 + /* priv structures for dma accesses */ 164 164 + void *read_dma_priv; 165 165 + void *write_dma_priv; 157 166 }; 158 167 159 168 extern int __init fsmc_nor_init(struct platform_device *pdev,

+84 -220

include/linux/mtd/mtd.h

reviewed

··· 164 164 /* ECC layout structure pointer - read only! */ 165 165 struct nand_ecclayout *ecclayout; 166 166 167 167 + /* max number of correctible bit errors per writesize */ 168 168 + unsigned int ecc_strength; 169 169 + 167 170 /* Data for variable erase regions. If numeraseregions is zero, 168 171 * it means that the whole device has erasesize as given above. 169 172 */ ··· 177 174 * Do not call via these pointers, use corresponding mtd_*() 178 175 * wrappers instead. 179 176 */ 180 180 - int (*erase) (struct mtd_info *mtd, struct erase_info *instr); 181 181 - int (*point) (struct mtd_info *mtd, loff_t from, size_t len, 182 182 - size_t *retlen, void **virt, resource_size_t *phys); 183 183 - void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len); 184 184 - unsigned long (*get_unmapped_area) (struct mtd_info *mtd, 185 185 - unsigned long len, 186 186 - unsigned long offset, 187 187 - unsigned long flags); 188 188 - int (*read) (struct mtd_info *mtd, loff_t from, size_t len, 189 189 - size_t *retlen, u_char *buf); 190 190 - int (*write) (struct mtd_info *mtd, loff_t to, size_t len, 191 191 - size_t *retlen, const u_char *buf); 192 192 - int (*panic_write) (struct mtd_info *mtd, loff_t to, size_t len, 193 193 - size_t *retlen, const u_char *buf); 194 194 - int (*read_oob) (struct mtd_info *mtd, loff_t from, 195 195 - struct mtd_oob_ops *ops); 196 196 - int (*write_oob) (struct mtd_info *mtd, loff_t to, 177 177 + int (*_erase) (struct mtd_info *mtd, struct erase_info *instr); 178 178 + int (*_point) (struct mtd_info *mtd, loff_t from, size_t len, 179 179 + size_t *retlen, void **virt, resource_size_t *phys); 180 180 + int (*_unpoint) (struct mtd_info *mtd, loff_t from, size_t len); 181 181 + unsigned long (*_get_unmapped_area) (struct mtd_info *mtd, 182 182 + unsigned long len, 183 183 + unsigned long offset, 184 184 + unsigned long flags); 185 185 + int (*_read) (struct mtd_info *mtd, loff_t from, size_t len, 186 186 + size_t *retlen, u_char *buf); 187 187 + int (*_write) (struct mtd_info *mtd, loff_t to, size_t len, 188 188 + size_t *retlen, const u_char *buf); 189 189 + int (*_panic_write) (struct mtd_info *mtd, loff_t to, size_t len, 190 190 + size_t *retlen, const u_char *buf); 191 191 + int (*_read_oob) (struct mtd_info *mtd, loff_t from, 197 192 struct mtd_oob_ops *ops); 198 198 - int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, 199 199 - size_t len); 200 200 - int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, 201 201 - size_t len, size_t *retlen, u_char *buf); 202 202 - int (*get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf, 203 203 - size_t len); 204 204 - int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, 205 205 - size_t len, size_t *retlen, u_char *buf); 206 206 - int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t to, size_t len, 207 207 - size_t *retlen, u_char *buf); 208 208 - int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, 209 209 - size_t len); 210 210 - int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, 193 193 + int (*_write_oob) (struct mtd_info *mtd, loff_t to, 194 194 + struct mtd_oob_ops *ops); 195 195 + int (*_get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, 196 196 + size_t len); 197 197 + int (*_read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, 198 198 + size_t len, size_t *retlen, u_char *buf); 199 199 + int (*_get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf, 200 200 + size_t len); 201 201 + int (*_read_user_prot_reg) (struct mtd_info *mtd, loff_t from, 202 202 + size_t len, size_t *retlen, u_char *buf); 203 203 + int (*_write_user_prot_reg) (struct mtd_info *mtd, loff_t to, 204 204 + size_t len, size_t *retlen, u_char *buf); 205 205 + int (*_lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, 206 206 + size_t len); 207 207 + int (*_writev) (struct mtd_info *mtd, const struct kvec *vecs, 211 208 unsigned long count, loff_t to, size_t *retlen); 212 212 - void (*sync) (struct mtd_info *mtd); 213 213 - int (*lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len); 214 214 - int (*unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len); 215 215 - int (*is_locked) (struct mtd_info *mtd, loff_t ofs, uint64_t len); 216 216 - int (*block_isbad) (struct mtd_info *mtd, loff_t ofs); 217 217 - int (*block_markbad) (struct mtd_info *mtd, loff_t ofs); 218 218 - int (*suspend) (struct mtd_info *mtd); 219 219 - void (*resume) (struct mtd_info *mtd); 209 209 + void (*_sync) (struct mtd_info *mtd); 210 210 + int (*_lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len); 211 211 + int (*_unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len); 212 212 + int (*_is_locked) (struct mtd_info *mtd, loff_t ofs, uint64_t len); 213 213 + int (*_block_isbad) (struct mtd_info *mtd, loff_t ofs); 214 214 + int (*_block_markbad) (struct mtd_info *mtd, loff_t ofs); 215 215 + int (*_suspend) (struct mtd_info *mtd); 216 216 + void (*_resume) (struct mtd_info *mtd); 220 217 /* 221 218 * If the driver is something smart, like UBI, it may need to maintain 222 219 * its own reference counting. The below functions are only for driver. 223 220 */ 224 224 - int (*get_device) (struct mtd_info *mtd); 225 225 - void (*put_device) (struct mtd_info *mtd); 221 221 + int (*_get_device) (struct mtd_info *mtd); 222 222 + void (*_put_device) (struct mtd_info *mtd); 226 223 227 224 /* Backing device capabilities for this device 228 225 * - provides mmap capabilities ··· 243 240 int usecount; 244 241 }; 245 242 246 246 - /* 247 247 - * Erase is an asynchronous operation. Device drivers are supposed 248 248 - * to call instr->callback() whenever the operation completes, even 249 249 - * if it completes with a failure. 250 250 - * Callers are supposed to pass a callback function and wait for it 251 251 - * to be called before writing to the block. 252 252 - */ 253 253 - static inline int mtd_erase(struct mtd_info *mtd, struct erase_info *instr) 254 254 - { 255 255 - return mtd->erase(mtd, instr); 256 256 - } 257 257 - 258 258 - /* 259 259 - * This stuff for eXecute-In-Place. phys is optional and may be set to NULL. 260 260 - */ 261 261 - static inline int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, 262 262 - size_t *retlen, void **virt, resource_size_t *phys) 263 263 - { 264 264 - *retlen = 0; 265 265 - if (!mtd->point) 266 266 - return -EOPNOTSUPP; 267 267 - return mtd->point(mtd, from, len, retlen, virt, phys); 268 268 - } 269 269 - 270 270 - /* We probably shouldn't allow XIP if the unpoint isn't a NULL */ 271 271 - static inline void mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 272 272 - { 273 273 - return mtd->unpoint(mtd, from, len); 274 274 - } 275 275 - 276 276 - /* 277 277 - * Allow NOMMU mmap() to directly map the device (if not NULL) 278 278 - * - return the address to which the offset maps 279 279 - * - return -ENOSYS to indicate refusal to do the mapping 280 280 - */ 281 281 - static inline unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, 282 282 - unsigned long len, 283 283 - unsigned long offset, 284 284 - unsigned long flags) 285 285 - { 286 286 - if (!mtd->get_unmapped_area) 287 287 - return -EOPNOTSUPP; 288 288 - return mtd->get_unmapped_area(mtd, len, offset, flags); 289 289 - } 290 290 - 291 291 - static inline int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, 292 292 - size_t *retlen, u_char *buf) 293 293 - { 294 294 - return mtd->read(mtd, from, len, retlen, buf); 295 295 - } 296 296 - 297 297 - static inline int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, 298 298 - size_t *retlen, const u_char *buf) 299 299 - { 300 300 - *retlen = 0; 301 301 - if (!mtd->write) 302 302 - return -EROFS; 303 303 - return mtd->write(mtd, to, len, retlen, buf); 304 304 - } 305 305 - 306 306 - /* 307 307 - * In blackbox flight recorder like scenarios we want to make successful writes 308 308 - * in interrupt context. panic_write() is only intended to be called when its 309 309 - * known the kernel is about to panic and we need the write to succeed. Since 310 310 - * the kernel is not going to be running for much longer, this function can 311 311 - * break locks and delay to ensure the write succeeds (but not sleep). 312 312 - */ 313 313 - static inline int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, 314 314 - size_t *retlen, const u_char *buf) 315 315 - { 316 316 - *retlen = 0; 317 317 - if (!mtd->panic_write) 318 318 - return -EOPNOTSUPP; 319 319 - return mtd->panic_write(mtd, to, len, retlen, buf); 320 320 - } 243 243 + int mtd_erase(struct mtd_info *mtd, struct erase_info *instr); 244 244 + int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 245 245 + void **virt, resource_size_t *phys); 246 246 + int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len); 247 247 + unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len, 248 248 + unsigned long offset, unsigned long flags); 249 249 + int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, 250 250 + u_char *buf); 251 251 + int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 252 252 + const u_char *buf); 253 253 + int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, 254 254 + const u_char *buf); 321 255 322 256 static inline int mtd_read_oob(struct mtd_info *mtd, loff_t from, 323 257 struct mtd_oob_ops *ops) 324 258 { 325 259 ops->retlen = ops->oobretlen = 0; 326 326 - if (!mtd->read_oob) 260 260 + if (!mtd->_read_oob) 327 261 return -EOPNOTSUPP; 328 328 - return mtd->read_oob(mtd, from, ops); 262 262 + return mtd->_read_oob(mtd, from, ops); 329 263 } 330 264 331 265 static inline int mtd_write_oob(struct mtd_info *mtd, loff_t to, 332 266 struct mtd_oob_ops *ops) 333 267 { 334 268 ops->retlen = ops->oobretlen = 0; 335 335 - if (!mtd->write_oob) 269 269 + if (!mtd->_write_oob) 336 270 return -EOPNOTSUPP; 337 337 - return mtd->write_oob(mtd, to, ops); 271 271 + if (!(mtd->flags & MTD_WRITEABLE)) 272 272 + return -EROFS; 273 273 + return mtd->_write_oob(mtd, to, ops); 338 274 } 339 275 340 340 - /* 341 341 - * Method to access the protection register area, present in some flash 342 342 - * devices. The user data is one time programmable but the factory data is read 343 343 - * only. 344 344 - */ 345 345 - static inline int mtd_get_fact_prot_info(struct mtd_info *mtd, 346 346 - struct otp_info *buf, size_t len) 347 347 - { 348 348 - if (!mtd->get_fact_prot_info) 349 349 - return -EOPNOTSUPP; 350 350 - return mtd->get_fact_prot_info(mtd, buf, len); 351 351 - } 352 352 - 353 353 - static inline int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, 354 354 - size_t len, size_t *retlen, 355 355 - u_char *buf) 356 356 - { 357 357 - *retlen = 0; 358 358 - if (!mtd->read_fact_prot_reg) 359 359 - return -EOPNOTSUPP; 360 360 - return mtd->read_fact_prot_reg(mtd, from, len, retlen, buf); 361 361 - } 362 362 - 363 363 - static inline int mtd_get_user_prot_info(struct mtd_info *mtd, 364 364 - struct otp_info *buf, 365 365 - size_t len) 366 366 - { 367 367 - if (!mtd->get_user_prot_info) 368 368 - return -EOPNOTSUPP; 369 369 - return mtd->get_user_prot_info(mtd, buf, len); 370 370 - } 371 371 - 372 372 - static inline int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, 373 373 - size_t len, size_t *retlen, 374 374 - u_char *buf) 375 375 - { 376 376 - *retlen = 0; 377 377 - if (!mtd->read_user_prot_reg) 378 378 - return -EOPNOTSUPP; 379 379 - return mtd->read_user_prot_reg(mtd, from, len, retlen, buf); 380 380 - } 381 381 - 382 382 - static inline int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, 383 383 - size_t len, size_t *retlen, 384 384 - u_char *buf) 385 385 - { 386 386 - *retlen = 0; 387 387 - if (!mtd->write_user_prot_reg) 388 388 - return -EOPNOTSUPP; 389 389 - return mtd->write_user_prot_reg(mtd, to, len, retlen, buf); 390 390 - } 391 391 - 392 392 - static inline int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, 393 393 - size_t len) 394 394 - { 395 395 - if (!mtd->lock_user_prot_reg) 396 396 - return -EOPNOTSUPP; 397 397 - return mtd->lock_user_prot_reg(mtd, from, len); 398 398 - } 276 276 + int mtd_get_fact_prot_info(struct mtd_info *mtd, struct otp_info *buf, 277 277 + size_t len); 278 278 + int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 279 279 + size_t *retlen, u_char *buf); 280 280 + int mtd_get_user_prot_info(struct mtd_info *mtd, struct otp_info *buf, 281 281 + size_t len); 282 282 + int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len, 283 283 + size_t *retlen, u_char *buf); 284 284 + int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len, 285 285 + size_t *retlen, u_char *buf); 286 286 + int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len); 399 287 400 288 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 401 289 unsigned long count, loff_t to, size_t *retlen); 402 290 403 291 static inline void mtd_sync(struct mtd_info *mtd) 404 292 { 405 405 - if (mtd->sync) 406 406 - mtd->sync(mtd); 293 293 + if (mtd->_sync) 294 294 + mtd->_sync(mtd); 407 295 } 408 296 409 409 - /* Chip-supported device locking */ 410 410 - static inline int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 411 411 - { 412 412 - if (!mtd->lock) 413 413 - return -EOPNOTSUPP; 414 414 - return mtd->lock(mtd, ofs, len); 415 415 - } 416 416 - 417 417 - static inline int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 418 418 - { 419 419 - if (!mtd->unlock) 420 420 - return -EOPNOTSUPP; 421 421 - return mtd->unlock(mtd, ofs, len); 422 422 - } 423 423 - 424 424 - static inline int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) 425 425 - { 426 426 - if (!mtd->is_locked) 427 427 - return -EOPNOTSUPP; 428 428 - return mtd->is_locked(mtd, ofs, len); 429 429 - } 297 297 + int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len); 298 298 + int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len); 299 299 + int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len); 300 300 + int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs); 301 301 + int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs); 430 302 431 303 static inline int mtd_suspend(struct mtd_info *mtd) 432 304 { 433 433 - return mtd->suspend ? mtd->suspend(mtd) : 0; 305 305 + return mtd->_suspend ? mtd->_suspend(mtd) : 0; 434 306 } 435 307 436 308 static inline void mtd_resume(struct mtd_info *mtd) 437 309 { 438 438 - if (mtd->resume) 439 439 - mtd->resume(mtd); 440 440 - } 441 441 - 442 442 - static inline int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs) 443 443 - { 444 444 - if (!mtd->block_isbad) 445 445 - return 0; 446 446 - return mtd->block_isbad(mtd, ofs); 447 447 - } 448 448 - 449 449 - static inline int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs) 450 450 - { 451 451 - if (!mtd->block_markbad) 452 452 - return -EOPNOTSUPP; 453 453 - return mtd->block_markbad(mtd, ofs); 310 310 + if (mtd->_resume) 311 311 + mtd->_resume(mtd); 454 312 } 455 313 456 314 static inline uint32_t mtd_div_by_eb(uint64_t sz, struct mtd_info *mtd) ··· 346 482 347 483 static inline int mtd_has_oob(const struct mtd_info *mtd) 348 484 { 349 349 - return mtd->read_oob && mtd->write_oob; 485 485 + return mtd->_read_oob && mtd->_write_oob; 350 486 } 351 487 352 488 static inline int mtd_can_have_bb(const struct mtd_info *mtd) 353 489 { 354 354 - return !!mtd->block_isbad; 490 490 + return !!mtd->_block_isbad; 355 491 } 356 492 357 493 /* Kernel-side ioctl definitions */

+5 -2

include/linux/mtd/nand.h

reviewed

··· 324 324 * @steps: number of ECC steps per page 325 325 * @size: data bytes per ECC step 326 326 * @bytes: ECC bytes per step 327 327 + * @strength: max number of correctible bits per ECC step 327 328 * @total: total number of ECC bytes per page 328 329 * @prepad: padding information for syndrome based ECC generators 329 330 * @postpad: padding information for syndrome based ECC generators ··· 352 351 int size; 353 352 int bytes; 354 353 int total; 354 354 + int strength; 355 355 int prepad; 356 356 int postpad; 357 357 struct nand_ecclayout *layout; ··· 450 448 * will be copied to the appropriate nand_bbt_descr's. 451 449 * @badblockpos: [INTERN] position of the bad block marker in the oob 452 450 * area. 453 453 - * @badblockbits: [INTERN] number of bits to left-shift the bad block 454 454 - * number 451 451 + * @badblockbits: [INTERN] minimum number of set bits in a good block's 452 452 + * bad block marker position; i.e., BBM == 11110111b is 453 453 + * not bad when badblockbits == 7 455 454 * @cellinfo: [INTERN] MLC/multichip data from chip ident 456 455 * @numchips: [INTERN] number of physical chips 457 456 * @chipsize: [INTERN] the size of one chip for multichip arrays

-78

include/linux/mtd/pmc551.h

reviewed

··· 1 1 - /* 2 2 - * PMC551 PCI Mezzanine Ram Device 3 3 - * 4 4 - * Author: 5 5 - * Mark Ferrell 6 6 - * Copyright 1999,2000 Nortel Networks 7 7 - * 8 8 - * License: 9 9 - * As part of this driver was derrived from the slram.c driver it falls 10 10 - * under the same license, which is GNU General Public License v2 11 11 - */ 12 12 - 13 13 - #ifndef __MTD_PMC551_H__ 14 14 - #define __MTD_PMC551_H__ 15 15 - 16 16 - #include <linux/mtd/mtd.h> 17 17 - 18 18 - #define PMC551_VERSION \ 19 19 - "Ramix PMC551 PCI Mezzanine Ram Driver. (C) 1999,2000 Nortel Networks.\n" 20 20 - 21 21 - /* 22 22 - * Our personal and private information 23 23 - */ 24 24 - struct mypriv { 25 25 - struct pci_dev *dev; 26 26 - u_char *start; 27 27 - u32 base_map0; 28 28 - u32 curr_map0; 29 29 - u32 asize; 30 30 - struct mtd_info *nextpmc551; 31 31 - }; 32 32 - 33 33 - /* 34 34 - * Function Prototypes 35 35 - */ 36 36 - static int pmc551_erase(struct mtd_info *, struct erase_info *); 37 37 - static void pmc551_unpoint(struct mtd_info *, loff_t, size_t); 38 38 - static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len, 39 39 - size_t *retlen, void **virt, resource_size_t *phys); 40 40 - static int pmc551_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *); 41 41 - static int pmc551_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *); 42 42 - 43 43 - 44 44 - /* 45 45 - * Define the PCI ID's if the kernel doesn't define them for us 46 46 - */ 47 47 - #ifndef PCI_VENDOR_ID_V3_SEMI 48 48 - #define PCI_VENDOR_ID_V3_SEMI 0x11b0 49 49 - #endif 50 50 - 51 51 - #ifndef PCI_DEVICE_ID_V3_SEMI_V370PDC 52 52 - #define PCI_DEVICE_ID_V3_SEMI_V370PDC 0x0200 53 53 - #endif 54 54 - 55 55 - 56 56 - #define PMC551_PCI_MEM_MAP0 0x50 57 57 - #define PMC551_PCI_MEM_MAP1 0x54 58 58 - #define PMC551_PCI_MEM_MAP_MAP_ADDR_MASK 0x3ff00000 59 59 - #define PMC551_PCI_MEM_MAP_APERTURE_MASK 0x000000f0 60 60 - #define PMC551_PCI_MEM_MAP_REG_EN 0x00000002 61 61 - #define PMC551_PCI_MEM_MAP_ENABLE 0x00000001 62 62 - 63 63 - #define PMC551_SDRAM_MA 0x60 64 64 - #define PMC551_SDRAM_CMD 0x62 65 65 - #define PMC551_DRAM_CFG 0x64 66 66 - #define PMC551_SYS_CTRL_REG 0x78 67 67 - 68 68 - #define PMC551_DRAM_BLK0 0x68 69 69 - #define PMC551_DRAM_BLK1 0x6c 70 70 - #define PMC551_DRAM_BLK2 0x70 71 71 - #define PMC551_DRAM_BLK3 0x74 72 72 - #define PMC551_DRAM_BLK_GET_SIZE(x) (524288<<((x>>4)&0x0f)) 73 73 - #define PMC551_DRAM_BLK_SET_COL_MUX(x,v) (((x) & ~0x00007000) | (((v) & 0x7) << 12)) 74 74 - #define PMC551_DRAM_BLK_SET_ROW_MUX(x,v) (((x) & ~0x00000f00) | (((v) & 0xf) << 8)) 75 75 - 76 76 - 77 77 - #endif /* __MTD_PMC551_H__ */ 78 78 -

+40

include/linux/mtd/sh_flctl.h

reviewed

··· 23 23 #include <linux/mtd/mtd.h> 24 24 #include <linux/mtd/nand.h> 25 25 #include <linux/mtd/partitions.h> 26 26 + #include <linux/pm_qos.h> 26 27 27 28 /* FLCTL registers */ 28 29 #define FLCMNCR(f) (f->reg + 0x0) ··· 39 38 #define FLDTFIFO(f) (f->reg + 0x24) 40 39 #define FLECFIFO(f) (f->reg + 0x28) 41 40 #define FLTRCR(f) (f->reg + 0x2C) 41 41 + #define FLHOLDCR(f) (f->reg + 0x38) 42 42 #define FL4ECCRESULT0(f) (f->reg + 0x80) 43 43 #define FL4ECCRESULT1(f) (f->reg + 0x84) 44 44 #define FL4ECCRESULT2(f) (f->reg + 0x88) ··· 69 67 #define CE0_ENABLE (0x1 << 3) /* Chip Enable 0 */ 70 68 #define TYPESEL_SET (0x1 << 0) 71 69 70 70 + /* 71 71 + * Clock settings using the PULSEx registers from FLCMNCR 72 72 + * 73 73 + * Some hardware uses bits called PULSEx instead of FCKSEL_E and QTSEL_E 74 74 + * to control the clock divider used between the High-Speed Peripheral Clock 75 75 + * and the FLCTL internal clock. If so, use CLK_8_BIT_xxx for connecting 8 bit 76 76 + * and CLK_16_BIT_xxx for connecting 16 bit bus bandwith NAND chips. For the 16 77 77 + * bit version the divider is seperate for the pulse width of high and low 78 78 + * signals. 79 79 + */ 80 80 + #define PULSE3 (0x1 << 27) 81 81 + #define PULSE2 (0x1 << 17) 82 82 + #define PULSE1 (0x1 << 15) 83 83 + #define PULSE0 (0x1 << 9) 84 84 + #define CLK_8B_0_5 PULSE1 85 85 + #define CLK_8B_1 0x0 86 86 + #define CLK_8B_1_5 (PULSE1 | PULSE2) 87 87 + #define CLK_8B_2 PULSE0 88 88 + #define CLK_8B_3 (PULSE0 | PULSE1 | PULSE2) 89 89 + #define CLK_8B_4 (PULSE0 | PULSE2) 90 90 + #define CLK_16B_6L_2H PULSE0 91 91 + #define CLK_16B_9L_3H (PULSE0 | PULSE1 | PULSE2) 92 92 + #define CLK_16B_12L_4H (PULSE0 | PULSE2) 93 93 + 72 94 /* FLCMDCR control bits */ 73 95 #define ADRCNT2_E (0x1 << 31) /* 5byte address enable */ 74 96 #define ADRMD_E (0x1 << 26) /* Sector address access */ ··· 111 85 #define TRSTRT (0x1 << 0) /* translation start */ 112 86 #define TREND (0x1 << 1) /* translation end */ 113 87 88 88 + /* 89 89 + * FLHOLDCR control bits 90 90 + * 91 91 + * HOLDEN: Bus Occupancy Enable (inverted) 92 92 + * Enable this bit when the external bus might be used in between transfers. 93 93 + * If not set and the bus gets used by other modules, a deadlock occurs. 94 94 + */ 95 95 + #define HOLDEN (0x1 << 0) 96 96 + 114 97 /* FL4ECCCR control bits */ 115 98 #define _4ECCFA (0x1 << 2) /* 4 symbols correct fault */ 116 99 #define _4ECCEND (0x1 << 1) /* 4 symbols end */ ··· 132 97 struct mtd_info mtd; 133 98 struct nand_chip chip; 134 99 struct platform_device *pdev; 100 100 + struct dev_pm_qos_request pm_qos; 135 101 void __iomem *reg; 136 102 137 103 uint8_t done_buff[2048 + 64]; /* max size 2048 + 64 */ ··· 144 108 int erase1_page_addr; /* page_addr in ERASE1 cmd */ 145 109 uint32_t erase_ADRCNT; /* bits of FLCMDCR in ERASE1 cmd */ 146 110 uint32_t rw_ADRCNT; /* bits of FLCMDCR in READ WRITE cmd */ 111 111 + uint32_t flcmncr_base; /* base value of FLCMNCR */ 147 112 148 113 int hwecc_cant_correct[4]; 149 114 150 115 unsigned page_size:1; /* NAND page size (0 = 512, 1 = 2048) */ 151 116 unsigned hwecc:1; /* Hardware ECC (0 = disabled, 1 = enabled) */ 117 117 + unsigned holden:1; /* Hardware has FLHOLDCR and HOLDEN is set */ 118 118 + unsigned qos_request:1; /* QoS request to prevent deep power shutdown */ 152 119 }; 153 120 154 121 struct sh_flctl_platform_data { ··· 160 121 unsigned long flcmncr_val; 161 122 162 123 unsigned has_hwecc:1; 124 124 + unsigned use_holden:1; 163 125 }; 164 126 165 127 static inline struct sh_flctl *mtd_to_flctl(struct mtd_info *mtdinfo)

+65

include/linux/mtd/spear_smi.h

reviewed

··· 1 1 + /* 2 2 + * Copyright © 2010 ST Microelectronics 3 3 + * Shiraz Hashim <shiraz.hashim@st.com> 4 4 + * 5 5 + * This file is licensed under the terms of the GNU General Public 6 6 + * License version 2. This program is licensed "as is" without any 7 7 + * warranty of any kind, whether express or implied. 8 8 + */ 9 9 + 10 10 + #ifndef __MTD_SPEAR_SMI_H 11 11 + #define __MTD_SPEAR_SMI_H 12 12 + 13 13 + #include <linux/types.h> 14 14 + #include <linux/mtd/mtd.h> 15 15 + #include <linux/mtd/partitions.h> 16 16 + #include <linux/platform_device.h> 17 17 + #include <linux/of.h> 18 18 + 19 19 + /* max possible slots for serial-nor flash chip in the SMI controller */ 20 20 + #define MAX_NUM_FLASH_CHIP 4 21 21 + 22 22 + /* macro to define partitions for flash devices */ 23 23 + #define DEFINE_PARTS(n, of, s) \ 24 24 + { \ 25 25 + .name = n, \ 26 26 + .offset = of, \ 27 27 + .size = s, \ 28 28 + } 29 29 + 30 30 + /** 31 31 + * struct spear_smi_flash_info - platform structure for passing flash 32 32 + * information 33 33 + * 34 34 + * name: name of the serial nor flash for identification 35 35 + * mem_base: the memory base on which the flash is mapped 36 36 + * size: size of the flash in bytes 37 37 + * partitions: parition details 38 38 + * nr_partitions: number of partitions 39 39 + * fast_mode: whether flash supports fast mode 40 40 + */ 41 41 + 42 42 + struct spear_smi_flash_info { 43 43 + char *name; 44 44 + unsigned long mem_base; 45 45 + unsigned long size; 46 46 + struct mtd_partition *partitions; 47 47 + int nr_partitions; 48 48 + u8 fast_mode; 49 49 + }; 50 50 + 51 51 + /** 52 52 + * struct spear_smi_plat_data - platform structure for configuring smi 53 53 + * 54 54 + * clk_rate: clk rate at which SMI must operate 55 55 + * num_flashes: number of flashes present on board 56 56 + * board_flash_info: specific details of each flash present on board 57 57 + */ 58 58 + struct spear_smi_plat_data { 59 59 + unsigned long clk_rate; 60 60 + int num_flashes; 61 61 + struct spear_smi_flash_info *board_flash_info; 62 62 + struct device_node *np[MAX_NUM_FLASH_CHIP]; 63 63 + }; 64 64 + 65 65 + #endif /* __MTD_SPEAR_SMI_H */

+1 -1

sound/soc/mxs/mxs-pcm.c

reviewed

··· 28 28 #include <linux/platform_device.h> 29 29 #include <linux/slab.h> 30 30 #include <linux/dmaengine.h> 31 31 + #include <linux/fsl/mxs-dma.h> 31 32 32 33 #include <sound/core.h> 33 34 #include <sound/initval.h> ··· 37 36 #include <sound/soc.h> 38 37 #include <sound/dmaengine_pcm.h> 39 38 40 40 - #include <mach/dma.h> 41 39 #include "mxs-pcm.h" 42 40 43 41 struct mxs_pcm_dma_data {

+1 -1

sound/soc/mxs/mxs-saif.c

reviewed

··· 24 24 #include <linux/clk.h> 25 25 #include <linux/delay.h> 26 26 #include <linux/time.h> 27 27 + #include <linux/fsl/mxs-dma.h> 27 28 #include <sound/core.h> 28 29 #include <sound/pcm.h> 29 30 #include <sound/pcm_params.h> 30 31 #include <sound/soc.h> 31 32 #include <sound/saif.h> 32 32 - #include <mach/dma.h> 33 33 #include <asm/mach-types.h> 34 34 #include <mach/hardware.h> 35 35 #include <mach/mxs.h>