February 2021 - U-Boot

[PATCH] ARM: imx: Add OCRAM_S into iMX8M MMU tables
by Marek Vasut 08 Apr '21

08 Apr '21

The OCRAM_S is regular memory, just like the OCRAM, add it to the MMU tables so it can be used and cached. Signed-off-by: Marek Vasut <marex(a)denx.de> Cc: Fabio Estevam <festevam(a)gmail.com> Cc: Peng Fan <peng.fan(a)nxp.com> Cc: Stefano Babic <sbabic(a)denx.de> --- arch/arm/mach-imx/imx8m/soc.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/arch/arm/mach-imx/imx8m/soc.c b/arch/arm/mach-imx/imx8m/soc.c index 5456c10fb17..225e4e12500 100644 --- a/arch/arm/mach-imx/imx8m/soc.c +++ b/arch/arm/mach-imx/imx8m/soc.c @@ -104,6 +104,13 @@ static struct mm_region imx8m_mem_map[] = { .attrs = PTE_BLOCK_MEMTYPE(MT_DEVICE_NGNRNE) | PTE_BLOCK_NON_SHARE | PTE_BLOCK_PXN | PTE_BLOCK_UXN + }, { + /* OCRAM_S */ + .virt = 0x180000UL, + .phys = 0x180000UL, + .size = 0x8000UL, + .attrs = PTE_BLOCK_MEMTYPE(MT_NORMAL) | + PTE_BLOCK_OUTER_SHARE }, { /* TCM */ .virt = 0x7C0000UL, -- 2.30.0

3 5

[PATCH u-boot-marvell v2 1/4] rtc: add armada38x driver
by Marek Behún 08 Apr '21

08 Apr '21

Add RTC driver for Armada 38x, based on Linux' driver. For now implement only `marvell,armada-380-rtc` compatible. Signed-off-by: Marek Behún <marek.behun(a)nic.cz> Reviewed-by: Stefan Roese <sr(a)denx.de> Cc: Pali Rohár <pali(a)kernel.org> Cc: Baruch Siach <baruch(a)tkos.co.il> Cc: Chris Packham <judge.packham(a)gmail.com> Cc: Simon Glass <sjg(a)chromium.org> --- drivers/rtc/Kconfig | 7 ++ drivers/rtc/Makefile | 1 + drivers/rtc/armada38x.c | 184 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 192 insertions(+) create mode 100644 drivers/rtc/armada38x.c diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig index aa6d90158c..dafba35279 100644 --- a/drivers/rtc/Kconfig +++ b/drivers/rtc/Kconfig @@ -38,6 +38,13 @@ config RTC_ENABLE_32KHZ_OUTPUT Some real-time clocks support the output of 32kHz square waves (such as ds3231), the config symbol choose Real Time Clock device 32Khz output feature. +config RTC_ARMADA38X + bool "Enable Armada 38x Marvell SoC RTC" + depends on DM_RTC && ARCH_MVEBU + help + This adds support for the in-chip RTC that can be found in the + Armada 38x Marvell's SoC devices. + config RTC_PCF2127 bool "Enable PCF2127 driver" depends on DM_RTC diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile index 6a45a9c874..15609e7b18 100644 --- a/drivers/rtc/Makefile +++ b/drivers/rtc/Makefile @@ -8,6 +8,7 @@ obj-$(CONFIG_$(SPL_TPL_)DM_RTC) += rtc-uclass.o obj-$(CONFIG_RTC_AT91SAM9_RTT) += at91sam9_rtt.o obj-y += rtc-lib.o +obj-$(CONFIG_RTC_ARMADA38X) += armada38x.o obj-$(CONFIG_RTC_DAVINCI) += davinci.o obj-$(CONFIG_RTC_DS1302) += ds1302.o obj-$(CONFIG_RTC_DS1306) += ds1306.o diff --git a/drivers/rtc/armada38x.c b/drivers/rtc/armada38x.c new file mode 100644 index 0000000000..2d264acf77 --- /dev/null +++ b/drivers/rtc/armada38x.c @@ -0,0 +1,184 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * RTC driver for the Armada 38x Marvell SoCs + * + * Copyright (C) 2021 Marek Behun <marek.behun(a)nic.cz> + * + * Based on Linux' driver by Gregory Clement and Marvell + */ + +#include <asm/io.h> +#include <dm.h> +#include <linux/delay.h> +#include <rtc.h> + +#define RTC_STATUS 0x0 +#define RTC_TIME 0xC +#define RTC_CONF_TEST 0x1C + +/* Armada38x SoC registers */ +#define RTC_38X_BRIDGE_TIMING_CTL 0x0 +#define RTC_38X_PERIOD_OFFS 0 +#define RTC_38X_PERIOD_MASK (0x3FF << RTC_38X_PERIOD_OFFS) +#define RTC_38X_READ_DELAY_OFFS 26 +#define RTC_38X_READ_DELAY_MASK (0x1F << RTC_38X_READ_DELAY_OFFS) + +#define SAMPLE_NR 100 + +struct armada38x_rtc { + void __iomem *regs; + void __iomem *regs_soc; +}; + +/* + * According to Erratum RES-3124064 we have to do some configuration in MBUS. + * To read an RTC register we need to read it 100 times and return the most + * frequent value. + * To write an RTC register we need to write 2x zero into STATUS register, + * followed by the proper write. Linux adds an 5 us delay after this, so we do + * it here as well. + */ +static void update_38x_mbus_timing_params(struct armada38x_rtc *rtc) +{ + u32 reg; + + reg = readl(rtc->regs_soc + RTC_38X_BRIDGE_TIMING_CTL); + reg &= ~RTC_38X_PERIOD_MASK; + reg |= 0x3FF << RTC_38X_PERIOD_OFFS; /* Maximum value */ + reg &= ~RTC_38X_READ_DELAY_MASK; + reg |= 0x1F << RTC_38X_READ_DELAY_OFFS; /* Maximum value */ + writel(reg, rtc->regs_soc + RTC_38X_BRIDGE_TIMING_CTL); +} + +static void armada38x_rtc_write(u32 val, struct armada38x_rtc *rtc, u8 reg) +{ + writel(0, rtc->regs + RTC_STATUS); + writel(0, rtc->regs + RTC_STATUS); + writel(val, rtc->regs + reg); + udelay(5); +} + +static u32 armada38x_rtc_read(struct armada38x_rtc *rtc, u8 reg) +{ + u8 counts[SAMPLE_NR], max_idx; + u32 samples[SAMPLE_NR], max; + int i, j, last; + + for (i = 0, last = 0; i < SAMPLE_NR; ++i) { + u32 sample = readl(rtc->regs + reg); + + /* find if this value was already read */ + for (j = 0; j < last; ++j) { + if (samples[j] == sample) + break; + } + + if (j < last) { + /* if yes, increment count */ + ++counts[j]; + } else { + /* if not, add */ + samples[last] = sample; + counts[last] = 1; + ++last; + } + } + + /* finally find the sample that was read the most */ + max = 0; + max_idx = 0; + + for (i = 0; i < last; ++i) { + if (counts[i] > max) { + max = counts[i]; + max_idx = i; + } + } + + return samples[max_idx]; +} + +static int armada38x_rtc_get(struct udevice *dev, struct rtc_time *tm) +{ + struct armada38x_rtc *rtc = dev_get_priv(dev); + u32 time; + + time = armada38x_rtc_read(rtc, RTC_TIME); + + rtc_to_tm(time, tm); + + return 0; +} + +static int armada38x_rtc_reset(struct udevice *dev) +{ + struct armada38x_rtc *rtc = dev_get_priv(dev); + u32 reg; + + reg = armada38x_rtc_read(rtc, RTC_CONF_TEST); + + if (reg & 0xff) { + armada38x_rtc_write(0, rtc, RTC_CONF_TEST); + mdelay(500); + armada38x_rtc_write(0, rtc, RTC_TIME); + armada38x_rtc_write(BIT(0) | BIT(1), 0, RTC_STATUS); + } + + return 0; +} + +static int armada38x_rtc_set(struct udevice *dev, const struct rtc_time *tm) +{ + struct armada38x_rtc *rtc = dev_get_priv(dev); + unsigned long time; + + time = rtc_mktime(tm); + + if (time > U32_MAX) + printf("%s: requested time to set will overflow\n", dev->name); + + armada38x_rtc_reset(dev); + armada38x_rtc_write(time, rtc, RTC_TIME); + + return 0; +} + +static int armada38x_probe(struct udevice *dev) +{ + struct armada38x_rtc *rtc = dev_get_priv(dev); + + rtc->regs = dev_remap_addr_name(dev, "rtc"); + if (!rtc->regs) + goto err; + + rtc->regs_soc = dev_remap_addr_name(dev, "rtc-soc"); + if (!rtc->regs_soc) + goto err; + + update_38x_mbus_timing_params(rtc); + + return 0; +err: + printf("%s: io address missing\n", dev->name); + return -ENODEV; +} + +static const struct rtc_ops armada38x_rtc_ops = { + .get = armada38x_rtc_get, + .set = armada38x_rtc_set, + .reset = armada38x_rtc_reset, +}; + +static const struct udevice_id armada38x_rtc_ids[] = { + { .compatible = "marvell,armada-380-rtc", .data = 0 }, + { } +}; + +U_BOOT_DRIVER(rtc_armada38x) = { + .name = "rtc-armada38x", + .id = UCLASS_RTC, + .of_match = armada38x_rtc_ids, + .probe = armada38x_probe, + .priv_auto = sizeof(struct armada38x_rtc), + .ops = &armada38x_rtc_ops, +}; -- 2.26.2

3 8

[PATCH] Azure: Rework SH / Renesas job
by Tom Rini 08 Apr '21

08 Apr '21

Now that there is a single SuperH platform, rework the Azure job slightly. Azure build time limits mean that we need to split the world build up still. Make a single build job for the single Renesas SuperH platform as well as all of the ARM platforms from Renesas. Cc: Marek Vasut <marek.vasut+renesas(a)gmail.com> Signed-off-by: Tom Rini <trini(a)konsulko.com> --- .azure-pipelines.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.azure-pipelines.yml b/.azure-pipelines.yml index a6279427e138..42a89324aaf1 100644 --- a/.azure-pipelines.yml +++ b/.azure-pipelines.yml @@ -398,7 +398,7 @@ jobs: sun50i: BUILDMAN: "sun50i" arm_catch_all: - BUILDMAN: "arm -x arm11,arm7,arm9,aarch64,at91,bcm,freescale,kirkwood,mvebu,siemens,tegra,uniphier,mx,samsung,sunxi,am33xx,omap,rk,toradex,socfpga,k2,k3,zynq" + BUILDMAN: "arm -x arm11,arm7,arm9,aarch64,at91,bcm,freescale,kirkwood,mvebu,renesas,siemens,tegra,uniphier,mx,samsung,sunxi,am33xx,omap,rk,toradex,socfpga,k2,k3,zynq" sandbox_x86: BUILDMAN: "sandbox x86" technexion: @@ -436,11 +436,11 @@ jobs: uniphier: BUILDMAN: "uniphier" aarch64_catch_all: - BUILDMAN: "aarch64 -x bcm,k3,tegra,ls1,ls2,lx216,mvebu,uniphier,sunxi,samsung,socfpga,rk,versal,zynq" + BUILDMAN: "aarch64 -x bcm,k3,tegra,ls1,ls2,lx216,mvebu,uniphier,renesas,sunxi,samsung,socfpga,rk,versal,zynq" rockchip: BUILDMAN: "rk" - sh: - BUILDMAN: "sh -x arm" + renesas: + BUILDMAN: "renesas" zynq: BUILDMAN: "zynq&armv7" zynqmp_versal: -- 2.17.1

1 1

[PATCH] JFFS2: fix jffs2 summary datacrc status uninitialized
by Wagner Popov dos Santos 08 Apr '21

08 Apr '21

The function jffs2_1pass_read_inode() was discarding the summary inodes and dirent because the value in datacrc flag wasn't initialized in function jffs2_sum_process_sum_data(). This fix initializes the status of all summary records to indicate that the CRC needs to be verified when they are loaded. Before this fix, the behaviors produced by the undefined value of datacrc was: - Summary's registries were discarded when 'b->datacrc' is equal as 'CRC_BAD'. - Summary's registries were not checked when b->datacrc differs of 'CRC_BAD' and 'CRC_UNKNOWN' So, almost all of the time the crc just isn't checked, and in some cases the registries are discarded. Signed-off-by: Wagner Popov dos Santos <wpopov(a)gmail.com> --- fs/jffs2/jffs2_1pass.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/fs/jffs2/jffs2_1pass.c b/fs/jffs2/jffs2_1pass.c index a98745c50e..c9eda54cdb 100644 --- a/fs/jffs2/jffs2_1pass.c +++ b/fs/jffs2/jffs2_1pass.c @@ -1276,6 +1276,7 @@ static int jffs2_sum_process_sum_data(struct part_info *part, uint32_t offset, &spi->version); b->ino = sum_get_unaligned32( &spi->inode); + b->datacrc = CRC_UNKNOWN; } sp += JFFS2_SUMMARY_INODE_SIZE; @@ -1297,6 +1298,7 @@ static int jffs2_sum_process_sum_data(struct part_info *part, uint32_t offset, &spd->version); b->pino = sum_get_unaligned32( &spd->pino); + b->datacrc = CRC_UNKNOWN; } sp += JFFS2_SUMMARY_DIRENT_SIZE( -- 2.20.1

2 2

[PATCH] JFFS2: fix the reading address over nand's limit
by Wagner Popov dos Santos 08 Apr '21

08 Apr '21

Fixes address violation in functions read_nand_cached() and read_onenand_cached(). This happens because these functions try to read a fixed amount of data even when the offset+length is above the nand's limit. Signed-off-by: Wagner Popov dos Santos <wpopov(a)gmail.com> --- fs/jffs2/jffs2_1pass.c | 37 +++++++++++++++++++++++++++---------- 1 file changed, 27 insertions(+), 10 deletions(-) diff --git a/fs/jffs2/jffs2_1pass.c b/fs/jffs2/jffs2_1pass.c index a98745c50e..b39943671c 100644 --- a/fs/jffs2/jffs2_1pass.c +++ b/fs/jffs2/jffs2_1pass.c @@ -180,6 +180,7 @@ static int read_nand_cached(u32 off, u32 size, u_char *buf) struct mtd_info *mtd; u32 bytes_read = 0; size_t retlen; + size_t toread; int cpy_bytes; mtd = get_nand_dev_by_index(id->num); @@ -187,8 +188,12 @@ static int read_nand_cached(u32 off, u32 size, u_char *buf) return -1; while (bytes_read < size) { + retlen = NAND_CACHE_SIZE; + if( nand_cache_off + retlen > mtd->size ) + retlen = mtd->size - nand_cache_off; + if ((off + bytes_read < nand_cache_off) || - (off + bytes_read >= nand_cache_off+NAND_CACHE_SIZE)) { + (off + bytes_read >= nand_cache_off + retlen)) { nand_cache_off = (off + bytes_read) & NAND_PAGE_MASK; if (!nand_cache) { /* This memory never gets freed but 'cause @@ -201,16 +206,20 @@ static int read_nand_cached(u32 off, u32 size, u_char *buf) } } - retlen = NAND_CACHE_SIZE; + toread = NAND_CACHE_SIZE; + if( nand_cache_off + toread > mtd->size ) + toread = mtd->size - nand_cache_off; + + retlen = toread; if (nand_read(mtd, nand_cache_off, &retlen, nand_cache) < 0 || - retlen != NAND_CACHE_SIZE) { + retlen != toread) { printf("read_nand_cached: error reading nand off %#x size %d bytes\n", - nand_cache_off, NAND_CACHE_SIZE); + nand_cache_off, toread); return -1; } } - cpy_bytes = nand_cache_off + NAND_CACHE_SIZE - (off + bytes_read); + cpy_bytes = nand_cache_off + retlen - (off + bytes_read); if (cpy_bytes > size - bytes_read) cpy_bytes = size - bytes_read; memcpy(buf + bytes_read, @@ -283,11 +292,16 @@ static int read_onenand_cached(u32 off, u32 size, u_char *buf) { u32 bytes_read = 0; size_t retlen; + size_t toread; int cpy_bytes; while (bytes_read < size) { + retlen = ONENAND_CACHE_SIZE; + if( onenand_cache_off + retlen > onenand_mtd.size ) + retlen = onenand_mtd.size - onenand_cache_off; + if ((off + bytes_read < onenand_cache_off) || - (off + bytes_read >= onenand_cache_off + ONENAND_CACHE_SIZE)) { + (off + bytes_read >= onenand_cache_off + retlen)) { onenand_cache_off = (off + bytes_read) & ONENAND_PAGE_MASK; if (!onenand_cache) { /* This memory never gets freed but 'cause @@ -300,16 +314,19 @@ static int read_onenand_cached(u32 off, u32 size, u_char *buf) } } - retlen = ONENAND_CACHE_SIZE; + toread = ONENAND_CACHE_SIZE; + if( onenand_cache_off + toread > onenand_mtd.size ) + toread = onenand_mtd.size - onenand_cache_off; + retlen = toread; if (onenand_read(&onenand_mtd, onenand_cache_off, retlen, &retlen, onenand_cache) < 0 || - retlen != ONENAND_CACHE_SIZE) { + retlen != toread) { printf("read_onenand_cached: error reading nand off %#x size %d bytes\n", - onenand_cache_off, ONENAND_CACHE_SIZE); + onenand_cache_off, toread); return -1; } } - cpy_bytes = onenand_cache_off + ONENAND_CACHE_SIZE - (off + bytes_read); + cpy_bytes = onenand_cache_off + retlen - (off + bytes_read); if (cpy_bytes > size - bytes_read) cpy_bytes = size - bytes_read; memcpy(buf + bytes_read, -- 2.20.1

2 2

[PATCH 1/2] of: addr: Abort address translation for parent nodes missing 'ranges'
by Bin Meng 07 Apr '21

07 Apr '21

The implementation of of_translate_one() was taken from the one in Linux kernel drivers/of/address.c, and the Linux one added a quirk for Apple Macs that don't have the <ranges> property in the parent node. Since U-Boot does not support Apple Macs, remove the comment block and adhere to the spec to abort the translation. Signed-off-by: Bin Meng <bmeng.cn(a)gmail.com> --- drivers/core/of_addr.c | 24 ++++++------------------ 1 file changed, 6 insertions(+), 18 deletions(-) diff --git a/drivers/core/of_addr.c b/drivers/core/of_addr.c index 5bc6ca1..36cdfd3 100644 --- a/drivers/core/of_addr.c +++ b/drivers/core/of_addr.c @@ -173,25 +173,13 @@ static int of_translate_one(const struct device_node *parent, int rone; u64 offset = OF_BAD_ADDR; - /* - * Normally, an absence of a "ranges" property means we are - * crossing a non-translatable boundary, and thus the addresses - * below the current cannot be converted to CPU physical ones. - * Unfortunately, while this is very clear in the spec, it's not - * what Apple understood, and they do have things like /uni-n or - * /ht nodes with no "ranges" property and a lot of perfectly - * useable mapped devices below them. Thus we treat the absence of - * "ranges" as equivalent to an empty "ranges" property which means - * a 1:1 translation at that level. It's up to the caller not to try - * to translate addresses that aren't supposed to be translated in - * the first place. --BenH. - * - * As far as we know, this damage only exists on Apple machines, so - * This code is only enabled on powerpc. --gcl - */ - ranges = of_get_property(parent, rprop, &rlen); - if (ranges == NULL || rlen == 0) { + if (ranges == NULL) { + debug("no ranges; cannot translate\n"); + return 1; + } + + if (rlen == 0) { offset = of_read_number(addr, na); memset(addr, 0, pna * 4); debug("empty ranges; 1:1 translation\n"); -- 2.7.4

5 21

[PATCH] fs: ext4: Add metadata checksums support
by Fredrik Hallenberg 07 Apr '21

07 Apr '21

Support crc32c checksums in ext4 filesystems with metadata_csum flag active. This includes superblock, inodes, inode and block group tables, directory blocks and journal. Signed-off-by: Fredrik Hallenberg <megahallon(a)gmail.com> --- fs/ext4/Kconfig | 1 + fs/ext4/ext4_common.c | 91 ++++++++++------- fs/ext4/ext4_common.h | 7 +- fs/ext4/ext4_journal.c | 135 ++++++++++++++++++++----- fs/ext4/ext4_journal.h | 40 +++++++- fs/ext4/ext4_write.c | 162 ++++++++++++++++++++++++++++-- include/ext4fs.h | 7 ++ include/ext_common.h | 77 +++++++++++++- test/py/tests/test_env.py | 3 - test/py/tests/test_fs/conftest.py | 4 - 10 files changed, 441 insertions(+), 86 deletions(-) diff --git a/fs/ext4/Kconfig b/fs/ext4/Kconfig index 1a913d2b6d..da033428b2 100644 --- a/fs/ext4/Kconfig +++ b/fs/ext4/Kconfig @@ -8,6 +8,7 @@ config FS_EXT4 config EXT4_WRITE bool "Enable ext4 filesystem write support" depends on FS_EXT4 + select CRC32C help This provides support for creating and writing new files to an existing ext4 filesystem partition. diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c index c52cc400e1..6e23e47c97 100644 --- a/fs/ext4/ext4_common.c +++ b/fs/ext4/ext4_common.c @@ -45,6 +45,8 @@ __le32 *ext4fs_indir3_block; int ext4fs_indir3_size; int ext4fs_indir3_blkno = -1; struct ext2_inode *g_parent_inode; +int g_parent_inode_no; + static int symlinknest; #if defined(CONFIG_EXT4_WRITE) @@ -416,32 +418,6 @@ void ext4fs_reset_inode_bmap(int inode_no, unsigned char *buffer, int index) *ptr = *ptr & ~(operand); } -uint16_t ext4fs_checksum_update(uint32_t i) -{ - struct ext2_block_group *desc; - struct ext_filesystem *fs = get_fs(); - uint16_t crc = 0; - __le32 le32_i = cpu_to_le32(i); - - desc = ext4fs_get_group_descriptor(fs, i); - if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { - int offset = offsetof(struct ext2_block_group, bg_checksum); - - crc = ext2fs_crc16(~0, fs->sb->unique_id, - sizeof(fs->sb->unique_id)); - crc = ext2fs_crc16(crc, &le32_i, sizeof(le32_i)); - crc = ext2fs_crc16(crc, desc, offset); - offset += sizeof(desc->bg_checksum); /* skip checksum */ - assert(offset == sizeof(*desc)); - if (offset < fs->gdsize) { - crc = ext2fs_crc16(crc, (__u8 *)desc + offset, - fs->gdsize - offset); - } - } - - return crc; -} - static int check_void_in_dentry(struct ext2_dirent *dir, char *filename) { int dentry_length; @@ -472,6 +448,33 @@ static int check_void_in_dentry(struct ext2_dirent *dir, char *filename) return 0; } +static void ext4fs_set_dirent_tail_csum(struct ext_filesystem *fs, uint8_t *block) +{ + struct ext4_dir_entry_tail *tail; + uint32_t crc32; + uint32_t inode_seed; + __le32 inum = cpu_to_le32(g_parent_inode_no); + __le32 gen = g_parent_inode->generation; + int size; + + if (!(le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) + return; + + tail = (struct ext4_dir_entry_tail *)(block + fs->blksz + - sizeof(struct ext4_dir_entry_tail)); + if (tail->det_reserved_ft != 0xde) { + printf("Bad dirent tail\n"); + return; + } + + inode_seed = ext4_csum(fs->csum_seed, (uint8_t *)&inum, sizeof(inum)); + inode_seed = ext4_csum(inode_seed, (uint8_t *)&gen, sizeof(gen)); + + size = (uint8_t *)tail - block; + crc32 = ext4_csum(inode_seed, block, size); + tail->det_checksum = cpu_to_le32(crc32); +} + int ext4fs_update_parent_dentry(char *filename, int file_type) { unsigned int *zero_buffer = NULL; @@ -492,6 +495,10 @@ int ext4fs_update_parent_dentry(char *filename, int file_type) uint32_t new_size; uint32_t new_blockcnt; uint32_t directory_blocks; + struct ext4_dir_entry_tail *tail; + int has_metadata_chksum = le32_to_cpu(fs->sb->feature_ro_compat) & + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM ? 1 : 0; + uint32_t max_size = fs->blksz; zero_buffer = zalloc(fs->blksz); if (!zero_buffer) { @@ -529,12 +536,20 @@ restart_read: dir = (struct ext2_dirent *)root_first_block_buffer; totalbytes = 0; + if (has_metadata_chksum) { + tail = (struct ext4_dir_entry_tail *)(root_first_block_buffer + fs->blksz + - sizeof(struct ext4_dir_entry_tail)); + if (tail->det_reserved_ft != 0xde) + printf("Bad dirent tail\n"); + max_size -= sizeof(struct ext4_dir_entry_tail); + } + while (le16_to_cpu(dir->direntlen) > 0) { unsigned short used_len = ROUND(dir->namelen + sizeof(struct ext2_dirent), 4); /* last entry of block */ - if (fs->blksz - totalbytes == le16_to_cpu(dir->direntlen)) { + if (max_size - totalbytes == le16_to_cpu(dir->direntlen)) { /* check if new entry fits */ if ((used_len + new_entry_byte_reqd) <= @@ -608,7 +623,7 @@ restart_read: if (sizeof_void_space) dir->direntlen = cpu_to_le16(sizeof_void_space); else - dir->direntlen = cpu_to_le16(fs->blksz - totalbytes); + dir->direntlen = cpu_to_le16(max_size - totalbytes); dir->namelen = strlen(filename); dir->filetype = file_type; @@ -616,7 +631,8 @@ restart_read: temp_dir = temp_dir + sizeof(struct ext2_dirent); memcpy(temp_dir, filename, strlen(filename)); - /* update or write the 1st block of root inode */ + /* update or write the 1st block of root inode */ + ext4fs_set_dirent_tail_csum(fs, (uint8_t *)root_first_block_buffer); if (ext4fs_put_metadata(root_first_block_buffer, first_block_no_of_root)) goto fail; @@ -925,6 +941,7 @@ static int unlink_filename(char *filename, unsigned int blknr) /* invalidate dir entry */ dir->inode = 0; } + ext4fs_set_dirent_tail_csum(fs, (uint8_t *)block_buffer); if (ext4fs_put_metadata(block_buffer, blknr)) goto fail; ret = inodeno; @@ -1101,6 +1118,8 @@ int ext4fs_get_new_inode_no(void) goto fail; int has_gdt_chksum = le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_GDT_CSUM ? 1 : 0; + int has_metadata_chksum = le32_to_cpu(fs->sb->feature_ro_compat) & + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM ? 1 : 0; if (fs->first_pass_ibmap == 0) { for (i = 0; i < fs->no_blkgrp; i++) { @@ -1112,7 +1131,7 @@ int ext4fs_get_new_inode_no(void) uint16_t bg_flags = ext4fs_bg_get_flags(bgd); uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs); - if (has_gdt_chksum) + if (has_gdt_chksum || has_metadata_chksum) bgd->bg_itable_unused = free_inodes; if (bg_flags & EXT4_BG_INODE_UNINIT) { put_ext4(i_bitmap_blk * fs->blksz, @@ -1131,7 +1150,7 @@ int ext4fs_get_new_inode_no(void) (i * inodes_per_grp); fs->first_pass_ibmap++; ext4fs_bg_free_inodes_dec(bgd, fs); - if (has_gdt_chksum) + if (has_gdt_chksum || has_metadata_chksum) ext4fs_bg_itable_unused_dec(bgd, fs); ext4fs_sb_free_inodes_dec(fs->sb); status = ext4fs_devread(i_bitmap_blk * @@ -1187,7 +1206,7 @@ restart: prev_inode_bitmap_index = ibmap_idx; } ext4fs_bg_free_inodes_dec(bgd, fs); - if (has_gdt_chksum) + if (has_gdt_chksum || has_metadata_chksum) bgd->bg_itable_unused = bgd->free_inodes; ext4fs_sb_free_inodes_dec(fs->sb); goto success; @@ -1598,7 +1617,7 @@ int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode) struct ext2_sblock *sblock = &data->sblock; struct ext_filesystem *fs = get_fs(); int log2blksz = get_fs()->dev_desc->log2blksz; - int inodes_per_block, status; + int inodes_per_block, status, size; long int blkno; unsigned int blkoff; @@ -1633,9 +1652,9 @@ int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode) free(blkgrp); /* Read the inode. */ + size = min(sizeof(struct ext2_inode), fs->inodesz); status = ext4fs_devread((lbaint_t)blkno << (LOG2_BLOCK_SIZE(data) - - log2blksz), blkoff, - sizeof(struct ext2_inode), (char *)inode); + log2blksz), blkoff, size, (char *)inode); if (status == 0) return 0; @@ -2368,7 +2387,7 @@ int ext4fs_mount(unsigned part_length) struct ext2_data *data; int status; struct ext_filesystem *fs = get_fs(); - data = zalloc(SUPERBLOCK_SIZE); + data = zalloc(sizeof(struct ext2_data)); if (!data) return 0; diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h index beaee9c80b..afcd9a072d 100644 --- a/fs/ext4/ext4_common.h +++ b/fs/ext4/ext4_common.h @@ -41,6 +41,8 @@ #define SUPERBLOCK_SIZE 1024 #define F_FILE 1 +#define EXT4_OLD_INODE_SIZE 128 + static inline void *zalloc(size_t size) { void *p = memalign(ARCH_DMA_MINALIGN, size); @@ -59,7 +61,6 @@ int ext4fs_iterate_dir(struct ext2fs_node *dir, char *name, #if defined(CONFIG_EXT4_WRITE) uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n); -uint16_t ext4fs_checksum_update(unsigned int i); int ext4fs_get_parent_inode_num(const char *dirname, char *dname, int flags); int ext4fs_update_parent_dentry(char *filename, int file_type); uint32_t ext4fs_get_new_blk_no(void); @@ -86,5 +87,9 @@ uint64_t ext4fs_sb_get_free_blocks(const struct ext2_sblock *sb); void ext4fs_sb_set_free_blocks(struct ext2_sblock *sb, uint64_t free_blocks); uint32_t ext4fs_bg_get_free_blocks(const struct ext2_block_group *bg, const struct ext_filesystem *fs); +void ext4fs_set_superblock_csum(struct ext2_sblock *sb); +uint32_t ext4_csum(uint32_t crc, const uint8_t *data, unsigned int length); +void ext4fs_set_journal_superblock_csum(struct journal_superblock_t *sb); + #endif #endif diff --git a/fs/ext4/ext4_journal.c b/fs/ext4/ext4_journal.c index 1a340b4764..aace78a795 100644 --- a/fs/ext4/ext4_journal.c +++ b/fs/ext4/ext4_journal.c @@ -184,6 +184,7 @@ int ext4fs_log_journal(char *journal_buffer, uint32_t blknr) int ext4fs_put_metadata(char *metadata_buffer, uint32_t blknr) { struct ext_filesystem *fs = get_fs(); + if (!metadata_buffer) { printf("Invalid input arguments %s\n", __func__); return -EINVAL; @@ -336,6 +337,7 @@ void recover_transaction(int prev_desc_logical_no) int ofs, flags; int i; struct ext3_journal_block_tag *tag; + int tag_size = fs->journal_tag_size; char *temp_buff = zalloc(fs->blksz); char *metadata_buff = zalloc(fs->blksz); if (!temp_buff || !metadata_buff) @@ -353,12 +355,14 @@ void recover_transaction(int prev_desc_logical_no) do { tag = (struct ext3_journal_block_tag *)(p_jdb + ofs); - ofs += sizeof(struct ext3_journal_block_tag); + ofs += tag_size; if (ofs > fs->blksz) break; - flags = be32_to_cpu(tag->flags); + flags = be16_to_cpu(tag->flags); + + /* skip uuid */ if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) ofs += 16; @@ -388,6 +392,15 @@ void print_jrnl_status(int recovery_flag) printf("Journal Scan Completed\n"); } +void ext4fs_set_journal_superblock_csum(struct journal_superblock_t *sb) +{ + uint32_t csum; + + sb->s_checksum = 0; + csum = ext4_csum(~0, (uint8_t *)sb, sizeof(struct journal_superblock_t)); + sb->s_checksum = cpu_to_be32(csum); +} + int ext4fs_check_journal_state(int recovery_flag) { int i; @@ -405,9 +418,7 @@ int ext4fs_check_journal_state(int recovery_flag) char *temp_buff = NULL; char *temp_buff1 = NULL; struct ext_filesystem *fs = get_fs(); - - if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) - return 0; + int tag_size = sizeof(struct ext3_journal_block_tag3); temp_buff = zalloc(fs->blksz); if (!temp_buff) @@ -425,6 +436,11 @@ int ext4fs_check_journal_state(int recovery_flag) temp_buff); jsb = (struct journal_superblock_t *) temp_buff; + if (be32_to_cpu(jsb->s_header.h_magic) != EXT3_JOURNAL_MAGIC_NUMBER) { + printf("Bad ext4 journal magic number\n"); + return -ENODEV; + } + if (le32_to_cpu(fs->sb->feature_incompat) & EXT3_FEATURE_INCOMPAT_RECOVER) { if (recovery_flag == RECOVER) printf("Recovery required\n"); @@ -437,10 +453,23 @@ int ext4fs_check_journal_state(int recovery_flag) if (be32_to_cpu(jsb->s_start) == 0) goto end; - if (!(jsb->s_feature_compat & - cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM))) - jsb->s_feature_compat |= - cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM); + fs->journal_csum_seed = ext4_csum(~0, jsb->s_uuid, sizeof(jsb->s_uuid)); + + if (be32_to_cpu(jsb->s_feature_incompat) & JBD2_FEATURE_INCOMPAT_CSUM_V3) { + fs->journal_tag_size = sizeof(struct ext3_journal_block_tag3); + fs->journal_csum_version = 3; + } else { + fs->journal_tag_size = sizeof(struct ext3_journal_block_tag); + fs->journal_csum_version = 0; + if (be32_to_cpu(jsb->s_feature_compat) & JBD2_FEATURE_COMPAT_CHECKSUM) + fs->journal_csum_version = 1; + if (be32_to_cpu(jsb->s_feature_incompat) & JBD2_FEATURE_INCOMPAT_CSUM_V2) { + fs->journal_tag_size += sizeof(uint16_t); + fs->journal_csum_version = 2; + } + if (!(be32_to_cpu(jsb->s_feature_incompat) & JBD2_FEATURE_INCOMPAT_64BIT)) + fs->journal_tag_size -= sizeof(uint32_t); + } i = be32_to_cpu(jsb->s_first); while (1) { @@ -468,10 +497,11 @@ int ext4fs_check_journal_state(int recovery_flag) do { tag = (struct ext3_journal_block_tag *) (p_jdb + ofs); - ofs += sizeof(struct ext3_journal_block_tag); + ofs += tag_size; if (ofs > fs->blksz) break; - flags = be32_to_cpu(tag->flags); + flags = be16_to_cpu(tag->flags); + /* skip uuid */ if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) ofs += 16; i++; @@ -532,16 +562,15 @@ end: fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat); /* Update the super block */ - put_ext4((uint64_t) (SUPERBLOCK_SIZE), - (struct ext2_sblock *)fs->sb, - (uint32_t) SUPERBLOCK_SIZE); + ext4fs_set_superblock_csum(fs->sb); + put_ext4(SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE); ext4_read_superblock((char *)fs->sb); blknr = read_allocated_block(&inode_journal, EXT2_JOURNAL_SUPERBLOCK, NULL); + ext4fs_set_journal_superblock_csum(jsb); put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), - (struct journal_superblock_t *)temp_buff, - (uint32_t) fs->blksz); + jsb, (uint32_t)fs->blksz); ext4fs_free_revoke_blks(); } free(temp_buff); @@ -550,18 +579,58 @@ end: return 0; } +static void descriptor_block_csum_set(const uint8_t *block) +{ + struct ext_filesystem *fs = get_fs(); + struct ext3_journal_block_tail *tail; + __u32 csum; + + if (fs->journal_csum_version < 2) + return; + + tail = (struct ext3_journal_block_tail *)(block + fs->blksz - + sizeof(struct ext3_journal_block_tail)); + tail->t_checksum = 0; + csum = ext4_csum(fs->journal_csum_seed, block, fs->blksz); + tail->t_checksum = cpu_to_be32(csum); +} + +static void block_tag_csum_set(struct ext3_journal_block_tag3 *tag, const uint8_t *data, + uint32_t sequence) +{ + struct ext_filesystem *fs = get_fs(); + struct ext3_journal_block_tag *tag2 = (struct ext3_journal_block_tag *)tag; + uint32_t crc32; + __be32 seq; + + if (fs->journal_csum_version < 2) + return; + + seq = cpu_to_be32(sequence); + crc32 = ext4_csum(fs->journal_csum_seed, (uint8_t *)&seq, sizeof(seq)); + crc32 = ext4_csum(crc32, data, fs->blksz); + + if (fs->journal_csum_version == 3) + tag->checksum = cpu_to_be32(crc32); + else + tag2->checksum = cpu_to_be16(crc32 & 0xffff); +} + static void update_descriptor_block(long int blknr) { int i; long int jsb_blknr; struct journal_header_t jdb; - struct ext3_journal_block_tag tag; + struct ext3_journal_block_tag3 tag; struct ext2_inode inode_journal; struct journal_superblock_t *jsb = NULL; char *buf = NULL; char *temp = NULL; struct ext_filesystem *fs = get_fs(); char *temp_buff = zalloc(fs->blksz); + int tag_size = fs->journal_tag_size; + uint32_t sequence; + if (!temp_buff) return; @@ -575,6 +644,9 @@ static void update_descriptor_block(long int blknr) jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_DESCRIPTOR_BLOCK); jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER); jdb.h_sequence = jsb->s_sequence; + + sequence = be32_to_cpu(jsb->s_sequence); + buf = zalloc(fs->blksz); if (!buf) { free(temp_buff); @@ -589,16 +661,19 @@ static void update_descriptor_block(long int blknr) break; tag.block = cpu_to_be32(journal_ptr[i]->blknr); - tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_SAME_UUID); - memcpy(temp, &tag, sizeof(struct ext3_journal_block_tag)); - temp = temp + sizeof(struct ext3_journal_block_tag); + tag.flags = cpu_to_be16(EXT3_JOURNAL_FLAG_SAME_UUID); + block_tag_csum_set(&tag, (uint8_t *)journal_ptr[i]->buf, sequence); + memcpy(temp, &tag, tag_size); + temp = temp + tag_size; } tag.block = cpu_to_be32(journal_ptr[--i]->blknr); - tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_LAST_TAG); - memcpy(temp - sizeof(struct ext3_journal_block_tag), &tag, - sizeof(struct ext3_journal_block_tag)); - put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz); + tag.flags = cpu_to_be16(EXT3_JOURNAL_FLAG_LAST_TAG); + block_tag_csum_set(&tag, (uint8_t *)journal_ptr[i]->buf, sequence); + memcpy(temp - tag_size, &tag, tag_size); + + descriptor_block_csum_set((uint8_t *)buf); + put_ext4((uint64_t)((uint64_t)blknr * (uint64_t)fs->blksz), buf, fs->blksz); free(temp_buff); free(buf); @@ -606,7 +681,7 @@ static void update_descriptor_block(long int blknr) static void update_commit_block(long int blknr) { - struct journal_header_t jdb; + struct ext3_journal_commit_header jdb; struct ext_filesystem *fs = get_fs(); char *buf = NULL; struct ext2_inode inode_journal; @@ -632,7 +707,15 @@ static void update_commit_block(long int blknr) free(temp_buff); return; } - memcpy(buf, &jdb, sizeof(struct journal_header_t)); + + if (fs->journal_csum_version > 1) { + uint32_t csum = ext4_csum(fs->journal_csum_seed, (uint8_t *)temp_buff, fs->blksz); + + jdb.h_chksum[0] = cpu_to_be32(csum); + } + + memcpy(buf, &jdb, sizeof(struct ext3_journal_commit_header)); + put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz); free(temp_buff); diff --git a/fs/ext4/ext4_journal.h b/fs/ext4/ext4_journal.h index 43fb8e7664..9bdbf66971 100644 --- a/fs/ext4/ext4_journal.h +++ b/fs/ext4/ext4_journal.h @@ -22,7 +22,6 @@ #define EXT2_JOURNAL_INO 8 /* Journal inode */ #define EXT2_JOURNAL_SUPERBLOCK 0 /* Journal Superblock number */ -#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001 #define EXT3_JOURNAL_MAGIC_NUMBER 0xc03b3998U #define TRANSACTION_RUNNING 1 #define TRANSACTION_COMPLETE 0 @@ -37,6 +36,14 @@ #define EXT3_JOURNAL_FLAG_DELETED 4 #define EXT3_JOURNAL_FLAG_LAST_TAG 8 +#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001 + +#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001 +#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002 +#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004 +#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008 +#define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010 + /* Maximum entries in 1 journal transaction */ #define MAX_JOURNAL_ENTRIES 100 struct journal_log { @@ -90,16 +97,45 @@ struct journal_superblock_t { __be32 s_max_trans_data; /* Limit of data blocks per trans. */ /* 0x0050 */ - __be32 s_padding[44]; + __u8 s_checksum_type; /* checksum type */ + __u8 s_padding2[3]; + __u32 s_padding[42]; + __be32 s_checksum; /* crc32c(superblock) */ /* 0x0100 */ __u8 s_users[16 * 48]; /* ids of all fs'es sharing the log */ /* 0x0400 */ } ; +struct ext3_journal_commit_header { + __be32 h_magic; + __be32 h_blocktype; + __be32 h_sequence; + unsigned char h_chksum_type; + unsigned char h_chksum_size; + unsigned char h_padding[2]; + __be32 h_chksum[8]; + __be64 h_commit_sec; + __be32 h_commit_nsec; +}; + struct ext3_journal_block_tag { + __be32 block; + __be16 checksum; /* truncated crc32c(uuid+seq+block) */ + __be16 flags; + __be32 blocknr_high; /* only used when INCOMPAT_64BIT is set */ +}; + +/* Use if FEATURE_INCOMPAT_CSUM_V3 is set */ +struct ext3_journal_block_tag3 { __be32 block; __be32 flags; + __be32 blocknr_high; + __be32 checksum; /* crc32c(uuid+seq+block) */ +}; + +struct ext3_journal_block_tail { + __be32 t_checksum; /* crc32c(uuid+descr_block) */ }; struct journal_revoke_header_t { diff --git a/fs/ext4/ext4_write.c b/fs/ext4/ext4_write.c index f22af45d1b..fc248c0bc2 100644 --- a/fs/ext4/ext4_write.c +++ b/fs/ext4/ext4_write.c @@ -30,6 +30,7 @@ #include <linux/stat.h> #include <div64.h> #include "ext4_common.h" +#include <u-boot/crc.h> static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb) { @@ -67,6 +68,139 @@ static inline void ext4fs_bg_free_blocks_inc bg->free_blocks_high = cpu_to_le16(free_blocks >> 16); } +uint32_t ext4_csum(uint32_t crc, const uint8_t *data, unsigned int length) +{ + static uint32_t table[256]; + static int init; + + if (!init) { + crc32c_init(table, 0x82f63b78); + init = 1; + } + + return crc32c_cal(crc, (const char *)data, length, table); +} + +void ext4fs_set_superblock_csum(struct ext2_sblock *sb) +{ + int offset; + + if (!(le32_to_cpu(sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) + return; + + offset = offsetof(struct ext2_sblock, checksum); + sb->checksum = cpu_to_le32(ext4_csum(~0, (uint8_t *)sb, offset)); +} + +static uint32_t ext4_inode_csum(struct ext2_inode *inode, unsigned int inode_no) +{ + struct ext_filesystem *fs = get_fs(); + uint32_t crc32; + uint16_t dummy_csum = 0; + unsigned int dummy_size = sizeof(dummy_csum); + int offset = offsetof(struct ext2_inode, checksum_lo); + __le32 inum = cpu_to_le32(inode_no); + __le32 gen = inode->generation; + uint32_t inode_seed; + + inode_seed = ext4_csum(fs->csum_seed, (uint8_t *)&inum, sizeof(inum)); + inode_seed = ext4_csum(inode_seed, (uint8_t *)&gen, sizeof(gen)); + + crc32 = ext4_csum(inode_seed, (uint8_t *)inode, offset); + crc32 = ext4_csum(crc32, (uint8_t *)&dummy_csum, dummy_size); + offset += dummy_size; + crc32 = ext4_csum(crc32, (uint8_t *)inode + offset, EXT4_OLD_INODE_SIZE - offset); + + if (fs->inodesz > EXT4_OLD_INODE_SIZE) { + uint16_t extra_size; + + offset = offsetof(struct ext2_inode, checksum_hi); + crc32 = ext4_csum(crc32, (uint8_t *)inode + EXT4_OLD_INODE_SIZE, + offset - EXT4_OLD_INODE_SIZE); + extra_size = le16_to_cpu(inode->extra_isize); + if (extra_size + EXT4_OLD_INODE_SIZE >= + offsetof(struct ext2_inode, checksum_hi) + sizeof(inode->checksum_hi)) { + crc32 = ext4_csum(crc32, (uint8_t *)&dummy_csum, dummy_size); + offset += dummy_size; + } + crc32 = ext4_csum(crc32, (uint8_t *)inode + offset, fs->inodesz - offset); + } + + return crc32; +} + +static void ext4fs_set_inode_csum(struct ext2_inode *inode, unsigned int inode_no) + +{ + struct ext_filesystem *fs = get_fs(); + uint32_t crc32; + + if (!(le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) + return; + + crc32 = ext4_inode_csum(inode, inode_no); + inode->checksum_lo = cpu_to_le16(crc32 & 0xffff); + + if (fs->inodesz > EXT4_OLD_INODE_SIZE) { + uint16_t extra_size = le16_to_cpu(inode->extra_isize); + + if (extra_size + EXT4_OLD_INODE_SIZE >= + offsetof(struct ext2_inode, checksum_hi) + sizeof(inode->checksum_hi)) + inode->checksum_hi = cpu_to_le16(crc32 >> 16); + } +} + +static void ext4fs_set_group_descriptor_csum(uint32_t i) +{ + struct ext_filesystem *fs = get_fs(); + struct ext2_block_group *desc = ext4fs_get_group_descriptor(fs, i); + __le32 le32_i = cpu_to_le32(i); + int offset = offsetof(struct ext2_block_group, bg_checksum); + uint16_t crc = 0; + + if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) { + uint32_t crc32; + uint16_t dummy_csum = 0; + int sz; + + /* inode bitmap */ + sz = fs->sb->inodes_per_group / 8; + crc32 = ext4_csum(fs->csum_seed, fs->inode_bmaps[i], sz); + desc->bg_inode_id_csum = cpu_to_le16(crc32 & 0xFFFF); + if (fs->gdsize >= EXT4_BG_INODE_BITMAP_CSUM_HI_END) + desc->bg_inode_id_csum_high = cpu_to_le16(crc32 >> 16); + + /* block bitmap */ + sz = fs->sb->fragments_per_group / 8; + crc32 = ext4_csum(fs->csum_seed, fs->blk_bmaps[i], sz); + desc->bg_block_id_csum = cpu_to_le16(crc32 & 0xFFFF); + if (fs->gdsize >= EXT4_BG_BLOCK_BITMAP_CSUM_HI_END) + desc->bg_block_id_csum_high = cpu_to_le16(crc32 >> 16); + + crc32 = ext4_csum(fs->csum_seed, (uint8_t *)&le32_i, sizeof(le32_i)); + crc32 = ext4_csum(crc32, (uint8_t *)desc, offset); + crc32 = ext4_csum(crc32, (uint8_t *)&dummy_csum, sizeof(dummy_csum)); + offset += sizeof(dummy_csum); + if (offset < fs->gdsize) { + crc32 = ext4_csum(crc32, (uint8_t *)desc + offset, + fs->gdsize - offset); + } + crc = crc32 & 0xffff; + } else if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { + crc = ext2fs_crc16(~0, fs->sb->unique_id, + sizeof(fs->sb->unique_id)); + crc = ext2fs_crc16(crc, &le32_i, sizeof(le32_i)); + crc = ext2fs_crc16(crc, desc, offset); + offset += sizeof(desc->bg_checksum); /* skip checksum */ + assert(offset == sizeof(*desc)); + if (offset < fs->gdsize) { + crc = ext2fs_crc16(crc, (__u8 *)desc + offset, + fs->gdsize - offset); + } + } + desc->bg_checksum = cpu_to_le16(crc); +} + static void ext4fs_update(void) { short i; @@ -74,14 +208,14 @@ static void ext4fs_update(void) struct ext_filesystem *fs = get_fs(); struct ext2_block_group *bgd = NULL; - /* update super block */ - put_ext4((uint64_t)(SUPERBLOCK_SIZE), - (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); + /* update super block */ + ext4fs_set_superblock_csum(fs->sb); + put_ext4(SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE); /* update block bitmaps */ for (i = 0; i < fs->no_blkgrp; i++) { bgd = ext4fs_get_group_descriptor(fs, i); - bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i)); + ext4fs_set_group_descriptor_csum(i); uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); put_ext4(b_bitmap_blk * fs->blksz, fs->blk_bmaps[i], fs->blksz); @@ -613,6 +747,11 @@ int ext4fs_init(void) if (!ext4_read_superblock((char *)fs->sb)) goto fail; + if (le32_to_cpu(fs->sb->feature_incompat) & EXT4_FEATURE_INCOMPAT_CSUM_SEED) + fs->csum_seed = le32_to_cpu(fs->sb->checksum_seed); + else if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) + fs->csum_seed = ext4_csum(~0, fs->sb->unique_id, sizeof(fs->sb->unique_id)); + /* init journal */ if (ext4fs_init_journal()) goto fail; @@ -713,6 +852,7 @@ void ext4fs_deinit(void) temp_buff); jsb = (struct journal_superblock_t *)temp_buff; jsb->s_start = 0; + ext4fs_set_journal_superblock_csum(jsb); put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), (struct journal_superblock_t *)temp_buff, fs->blksz); free(temp_buff); @@ -724,8 +864,8 @@ void ext4fs_deinit(void) new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat); new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat); - put_ext4((uint64_t)(SUPERBLOCK_SIZE), - (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); + ext4fs_set_superblock_csum(fs->sb); + put_ext4(SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE); free(fs->sb); fs->sb = NULL; @@ -881,17 +1021,15 @@ int ext4fs_write(const char *fname, const char *buffer, return -1; } - if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) { - printf("Unsupported feature metadata_csum found, not writing.\n"); - return -1; - } - inodes_per_block = fs->blksz / fs->inodesz; parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE); if (parent_inodeno == -1) goto fail; if (ext4fs_iget(parent_inodeno, g_parent_inode)) goto fail; + + g_parent_inode_no = parent_inodeno; + /* do not mess up a directory using hash trees */ if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) { printf("hash tree directory\n"); @@ -963,6 +1101,8 @@ int ext4fs_write(const char *fname, const char *buffer, file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >> LOG2_SECTOR_SIZE); + ext4fs_set_inode_csum(file_inode, inodeno); + temp_ptr = zalloc(fs->blksz); if (!temp_ptr) goto fail; diff --git a/include/ext4fs.h b/include/ext4fs.h index cb5d9cc0a5..5485388166 100644 --- a/include/ext4fs.h +++ b/include/ext4fs.h @@ -37,6 +37,7 @@ struct disk_partition; #define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM 0x0400 #define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 #define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 +#define EXT4_FEATURE_INCOMPAT_CSUM_SEED 0x2000 #define EXT4_INDIRECT_BLOCKS 12 #define EXT4_BG_INODE_UNINIT 0x0001 @@ -117,6 +118,11 @@ struct ext_filesystem { /* Block Device Descriptor */ struct blk_desc *dev_desc; + + uint32_t csum_seed; + uint32_t journal_csum_seed; + uint32_t journal_tag_size; + int journal_csum_version; }; struct ext_block_cache { @@ -130,6 +136,7 @@ extern struct ext2fs_node *ext4fs_file; #if defined(CONFIG_EXT4_WRITE) extern struct ext2_inode *g_parent_inode; +extern int g_parent_inode_no; extern int gd_index; extern int gindex; diff --git a/include/ext_common.h b/include/ext_common.h index bc3324172a..c024b33e56 100644 --- a/include/ext_common.h +++ b/include/ext_common.h @@ -97,7 +97,7 @@ struct ext2_sblock { __le32 feature_compatibility; __le32 feature_incompat; __le32 feature_ro_compat; - __le32 unique_id[4]; + uint8_t unique_id[16]; char volume_name[16]; char last_mounted_on[64]; __le32 compression_info; @@ -116,6 +116,8 @@ struct ext2_sblock { __le32 first_meta_block_group; __le32 mkfs_time; __le32 journal_blocks[17]; + + /* 64 bit support */ __le32 total_blocks_high; __le32 reserved_blocks_high; __le32 free_blocks_high; @@ -128,6 +130,43 @@ struct ext2_sblock { __le32 raid_stripe_width; uint8_t log2_groups_per_flex; uint8_t checksum_type; + uint8_t encryption_level; + uint8_t reserved_pad; + __le64 kbytes_written; + __le32 snapshot_inum; + __le32 snapshot_id; + __le64 snapshot_r_blocks_count; + __le32 snapshot_list; + __le32 error_count; + __le32 first_error_time; + __le32 first_error_ino; + __le64 first_error_block; + uint8_t first_error_func[32]; + __le32 first_error_line; + __le32 last_error_time; + __le32 last_error_ino; + __le32 last_error_line; + __le64 last_error_block; + uint8_t last_error_func[32]; + uint8_t mount_opts[64]; + __le32 usr_quota_inum; + __le32 grp_quota_inum; + __le32 overhead_clusters; + __le32 backup_bgs[2]; + uint8_t encrypt_algos[4]; + uint8_t encrypt_pw_salt[16]; + __le32 lpf_ino; + __le32 prj_quota_inum; + __le32 checksum_seed; + uint8_t wtime_hi; + uint8_t mtime_hi; + uint8_t mkfs_time_hi; + uint8_t lastcheck_hi; + uint8_t first_error_time_hi; + uint8_t last_error_time_hi; + uint8_t pad[2]; + __le32 reserved[96]; + __le32 checksum; }; struct ext2_block_group { @@ -157,6 +196,13 @@ struct ext2_block_group { __le32 bg_reserved; }; +#define EXT4_BG_INODE_BITMAP_CSUM_HI_END \ + (offsetof(struct ext2_block_group, bg_inode_id_csum_high) + \ + sizeof(__le16)) +#define EXT4_BG_BLOCK_BITMAP_CSUM_HI_END \ + (offsetof(struct ext2_block_group, bg_block_id_csum_high) + \ + sizeof(__le16)) + /* The ext2 inode. */ struct ext2_inode { __le16 mode; @@ -181,11 +227,28 @@ struct ext2_inode { char symlink[60]; char inline_data[60]; } b; - __le32 version; + __le32 generation; __le32 acl; __le32 size_high; /* previously dir_acl, but never used */ __le32 fragment_addr; - __le32 osd2[3]; + + __le16 blocks_high; /* were l_i_reserved1 */ + __le16 file_acl_high; + __le16 uid_high; + __le16 gid_high; + __le16 checksum_lo; /* crc32c(uuid+inum+inode) LE */ + __le16 reserved; + + /* optional part */ + __le16 extra_isize; + __le16 checksum_hi; /* crc32c(uuid+inum+inode) BE */ + __le32 ctime_extra; + __le32 mtime_extra; + __le32 atime_extra; + __le32 crtime; + __le32 crtime_extra; + __le32 version_hi; + __le32 projid; }; /* The header of an ext2 directory entry. */ @@ -196,6 +259,14 @@ struct ext2_dirent { __u8 filetype; }; +struct ext4_dir_entry_tail { + __le32 det_reserved_zero1; /* Pretend to be unused */ + __le16 det_rec_len; /* 12 */ + __u8 det_reserved_zero2; /* Zero name length */ + __u8 det_reserved_ft; /* 0xDE, fake file type */ + __le32 det_checksum; /* crc32c(uuid+inum+dirblock) */ +}; + struct ext2fs_node { struct ext2_data *data; struct ext2_inode inode; diff --git a/test/py/tests/test_env.py b/test/py/tests/test_env.py index 940279651d..847b4fbcdd 100644 --- a/test/py/tests/test_env.py +++ b/test/py/tests/test_env.py @@ -417,9 +417,6 @@ def mk_env_ext4(state_test_env): try: u_boot_utils.run_and_log(c, 'dd if=/dev/zero of=%s bs=1M count=16' % persistent) u_boot_utils.run_and_log(c, 'mkfs.ext4 %s' % persistent) - sb_content = u_boot_utils.run_and_log(c, 'tune2fs -l %s' % persistent) - if 'metadata_csum' in sb_content: - u_boot_utils.run_and_log(c, 'tune2fs -O ^metadata_csum %s' % persistent) except CalledProcessError: call('rm -f %s' % persistent, shell=True) raise diff --git a/test/py/tests/test_fs/conftest.py b/test/py/tests/test_fs/conftest.py index ec70e8c4ef..272cbb639c 100644 --- a/test/py/tests/test_fs/conftest.py +++ b/test/py/tests/test_fs/conftest.py @@ -165,10 +165,6 @@ def mk_fs(config, fs_type, size, id): % (fs_img, count), shell=True) check_call('mkfs.%s %s %s' % (fs_lnxtype, mkfs_opt, fs_img), shell=True) - if fs_type == 'ext4': - sb_content = check_output('tune2fs -l %s' % fs_img, shell=True).decode() - if 'metadata_csum' in sb_content: - check_call('tune2fs -O ^metadata_csum %s' % fs_img, shell=True) return fs_img except CalledProcessError: call('rm -f %s' % fs_img, shell=True) -- 2.27.0

2 5

[PATCH v2] cfi_flash: Fix detection of 8-bit bus flash devices via address shift
by Stefan Roese 06 Apr '21

06 Apr '21

From: Jagannadha Sutradharudu Teki <jagannadha.sutradharudu-teki(a)xilinx.com> We had a problem detecting 8/16bit flash devices connected only via 8bits to the SoC for quite a while. Commit 239cb9d9 [mtd: cfi_flash: Fix CFI flash driver for 8-bit bus support] finally fixed this 8-bit bus support. But also broke some other boards using this cfi driver. So this patch had to be reverted. I spotted a different, simpler approach for this 8-bit bus support on the barebox mailing list posted by Oleksij Rempel <bug-track(a)fisher-privat.net>: http://www.spinics.net/lists/u-boot-v2/msg14687.html Here the commit text: " Many cfi chips support 16 and 8 bit modes. Most important difference is use of so called "Q15/A-1" pin. In 16bit mode this pin is used for data IO. In 8bit mode, it is an address input which add one more least significant bit (LSB). In this case we should shift all adresses by one: For example 0xaa << 1 = 0x154 " This patch now is a port of this barebox patch to U-Boot. Along with the change w.r.t from barebox, Some flash chips can support multiple bus widths, override the interface width and limit it to the port width. Tested on 16-bit Spansion flash on sequoia. Tested 8-bit flashes like 256M29EW, 512M29EW. Signed-off-by: Stefan Roese <sr(a)denx.de> Tested-by: Jagannadha Sutradharudu Teki <jaganna(a)xilinx.com> Cc: Jagannadha Sutradharudu Teki <jaganna(a)xilinx.com> Cc: Aaron Williams <awilliams(a)marvell.com> Cc: Chandrakala Chavva <cchavva(a)marvell.com> Cc: Andre Przywara <andre.przywara(a)arm.com> Cc: Vignesh Raghavendra <vigneshr(a)ti.com> Cc: Simon Glass <sjg(a)chromium.org> Cc: Mario Six <mario.six(a)gdsys.cc> Cc: York Sun <york.sun(a)nxp.com> Cc: Marek Vasut <marek.vasut+renesas(a)gmail.com> --- v2: - Rebase on current mainline I've run into problems with CFI flash on the MIPS Octeon EBB7304, where the CFI detection did not work. While testing and digging through the very old CFI related patches, I stumbled over this patch which fixes the problems on the EBB7304. I would really like to see some further testing of this patch on other boards using CFI parallel flash though. That's why I added some developers who did send CFI related patches in the last few years. So please test with this patch applied if possible. Thanks, Stefan drivers/mtd/cfi_flash.c | 37 +++++++++++++++++++++++++++++++++---- include/flash.h | 2 ++ 2 files changed, 35 insertions(+), 4 deletions(-) diff --git a/drivers/mtd/cfi_flash.c b/drivers/mtd/cfi_flash.c index b4512e3a5f..9642d7c7dc 100644 --- a/drivers/mtd/cfi_flash.c +++ b/drivers/mtd/cfi_flash.c @@ -218,7 +218,7 @@ flash_map(flash_info_t *info, flash_sect_t sect, uint offset) { unsigned int byte_offset = offset * info->portwidth; - return (void *)(info->start[sect] + byte_offset); + return (void *)(info->start[sect] + (byte_offset << info->chip_lsb)); } static inline void flash_unmap(flash_info_t *info, flash_sect_t sect, @@ -1918,12 +1918,27 @@ static int __flash_detect_cfi(flash_info_t *info, struct cfi_qry *qry) flash_read_cfi(info, qry, FLASH_OFFSET_CFI_RESP, sizeof(struct cfi_qry)); info->interface = le16_to_cpu(qry->interface_desc); + /* Some flash chips can support multiple bus widths. + * In this case, override the interface width and + * limit it to the port width. + */ + if ((info->interface == FLASH_CFI_X8X16) && + (info->portwidth == FLASH_CFI_8BIT)) { + debug("Overriding 16-bit interface width to" + " 8-bit port width\n"); + info->interface = FLASH_CFI_X8; + } else if ((info->interface == FLASH_CFI_X16X32) && + (info->portwidth == FLASH_CFI_16BIT)) { + debug("Overriding 16-bit interface width to" + " 16-bit port width\n"); + info->interface = FLASH_CFI_X16; + } info->cfi_offset = flash_offset_cfi[cfi_offset]; debug("device interface is %d\n", info->interface); - debug("found port %d chip %d ", - info->portwidth, info->chipwidth); + debug("found port %d chip %d chip_lsb %d ", + info->portwidth, info->chipwidth, info->chip_lsb); debug("port %d bits chip %d bits\n", info->portwidth << CFI_FLASH_SHIFT_WIDTH, info->chipwidth << CFI_FLASH_SHIFT_WIDTH); @@ -1962,9 +1977,23 @@ static int flash_detect_cfi(flash_info_t *info, struct cfi_qry *qry) info->portwidth <= FLASH_CFI_64BIT; info->portwidth <<= 1) { for (info->chipwidth = FLASH_CFI_BY8; info->chipwidth <= info->portwidth; - info->chipwidth <<= 1) + info->chipwidth <<= 1) { + /* + * First, try detection without shifting the addresses + * for 8bit devices (16bit wide connection) + */ + info->chip_lsb = 0; + if (__flash_detect_cfi(info, qry)) + return 1; + + /* + * Not detected, so let's try with shifting + * for 8bit devices + */ + info->chip_lsb = 1; if (__flash_detect_cfi(info, qry)) return 1; + } } debug("not found\n"); return 0; diff --git a/include/flash.h b/include/flash.h index 3bf6b22399..42b18a6047 100644 --- a/include/flash.h +++ b/include/flash.h @@ -24,6 +24,8 @@ typedef struct { #ifdef CONFIG_SYS_FLASH_CFI uchar portwidth; /* the width of the port */ uchar chipwidth; /* the width of the chip */ + uchar chip_lsb; /* extra Least Significant Bit in the */ + /* address of chip */ ushort buffer_size; /* # of bytes in write buffer */ ulong erase_blk_tout; /* maximum block erase timeout */ ulong write_tout; /* maximum write timeout */ -- 2.30.1

1 1

[PATCH v5 00/10] mtd: spi-nor: Add support for Cypress s25hl-t/s25hs-t
by tkuw584924＠gmail.com 06 Apr '21

06 Apr '21

From: Takahiro Kuwano <Takahiro.Kuwano(a)infineon.com> The S25HL-T/S25HS-T family is the Cypress Semper Flash with Quad SPI. The summary datasheets can be found in the following links. https://www.cypress.com/file/424146/download (256Mb/512Mb/1Gb, single die) https://www.cypress.com/file/499246/download (2Gb/4Gb, dual/quad die) The full version can be found in the following links (registration required). https://community.cypress.com/t5/Semper-Flash-Access-Program/Datasheet-Semp… https://community.cypress.com/t5/Semper-Flash-Access-Program/Datasheet-2Gb-… Tested on Xilinx Zynq-7000 FPGA board. Changes since v5: - Removed 256Mb and 4Gb parts support - Fixed register offset issue in spansion_quad_enable_volatile() - Added spi_nor_default_ready() and moved existing code into it - Separated spansion_sr_read() to new patch - Renamed spansion_overlaid_erase() to spansion_non_uniform_erase() and changed the implementation to issue the proper erase command based on the address - Added s25hx_t_erase_non_uniform() - Changed mtd.writesize and mtd.flags in s25hx_t_setup() - Fixed page size and erase size issues in s25hx_t_post_bfpt_fixup() Changes since v4: - Added Read/Write Any Register support - Added the ->ready() hook to support multi-die package parts - Added S25HL02GT/S25HL04GT/S25HS02GT/S25HS04GT support Changes since v3: - Split into multiple patches Changes since v2: - Fixed typo in comment for spansion_overlaid_erase() - Fixed expressions for addr and len check in spansion_overlaid_erase() - Added device ID check to make the changes effective for S25 only - Added nor->setup() and fixup hooks based on the following patches https://patchwork.ozlabs.org/project/uboot/patch/20200904153500.3569-7-p.ya… https://patchwork.ozlabs.org/project/uboot/patch/20200904153500.3569-8-p.ya… https://patchwork.ozlabs.org/project/uboot/patch/20200904153500.3569-9-p.ya… Takahiro Kuwano (10): mtd: spi-nor: Add Cypress manufacturer ID mtd: spi-nor-ids: Add Cypress s25hl-t/s25hs-t mtd: spi-nor-core: Add support for Read/Write Any Register mtd: spi-nor-core: Add support for volatile QE bit mtd: spi-nor-core: Add the ->ready() hook mtd: spi-nor-core: Read status by Read Any Register mtd: spi-nor-core: Add non-uniform erase for Spansion/Cypress mtd: spi-nor-core: Add Cypress manufacturer ID in set_4byte mtd: spi-nor-core: Add fixups for Cypress s25hl-t/s25hs-t mtd: spi-nor-tiny: Add fixups for Cypress s25hl-t/s25hs-t drivers/mtd/spi/spi-nor-core.c | 345 ++++++++++++++++++++++++++++++++- drivers/mtd/spi/spi-nor-ids.c | 27 +++ drivers/mtd/spi/spi-nor-tiny.c | 90 +++++++++ include/linux/mtd/spi-nor.h | 10 + 4 files changed, 471 insertions(+), 1 deletion(-) -- 2.25.1

4 30

Chromium OS verified boot 2018 with U-Boot
by Simon Glass 06 Apr '21

06 Apr '21

Hi, Just a note that the U-Boot / vboot integration has been updated with the 2018 version of vboot and it makes full use of driver model. If it available at [1] Documentation for running it on coral (2018 Intel Apollo Lake Chromebook) is available [2] as well as running it on sandbox [3]. The earlier release for 2015's samus (Chromebook Pixel 2) and 2012's link is still available at [4]. Regards, Simon [1] https://github.com/sjg20/u-boot/tree/cros-2021.01 [2] https://github.com/sjg20/u-boot/blob/cros-2021.01/cros/doc/cros_coral.rst [3] https://github.com/sjg20/u-boot/blob/cros-2021.01/cros/doc/cros_sandbox.rst [4] https://github.com/sjg20/u-boot/tree/cros-2019.01

2 3