Introduce NVIDIA Tegra Partition Table
Subsystems (7)
v4 cover Introduce NVIDIA Tegra Partition Table
Hello,
This series adds support for the NVIDIA Tegra Partition Table format, which is needed in order to support consumer-grade Tegra-based devices by the upstream kernel. These devices have Secure Boot enabled and it can't be disabled, and thus, it's not possible to easily modify bootloader and eMMC storage partitioning.
Big thanks to everyone who helped with figuring out the TegraPT format and with testing!
Changelog:
v4: - Scanning of the eMMC boot partitions has been dropped because it
requires a bit too messy hacks in the kernel. We can live without this feature, at least for now it's not really needed.
- Instead of the dropped boot partitions scanning, the "gpt_sector=" command line option has been brought back [1]. But now it's done in a different way, not bothering platforms other than Tegra and not touching block devices other than eMMC, which was requested during of the [1] review. The "gpt_sector=" usage is needed when partition table is inaccessible by kernel, which is the case for the Ouya game console device for example. Please note that "gpt_sector=" is not available on all devices, such devices will fall back to the TegraPT, Samsung Galaxy Tab 10.1 is an example of a such device.
- We got a bit more broad testing and discovered that Samsung Galaxy Tab 10.1 uses 2K logical sectors instead of 4K. So the 2K sectors are supported now by the TegraPT parser. Thanks to Nils Östlund for the testing!
- TegraPT parser now utilizes "tegraboot=" cmdline option which is passed to kernel by the NVIDIA's bootloader. It's used for verifying that SDMMC device is *the* boot source.
- Added patch that exposes Boot Configuration Table to userspace via sysfs. Thanks to Michał Mirosław for the suggestion!
- Misc changes:
- The EB2 (second bootloader) partition is added to the list of known partitions. Used by the Galaxy Tab 10.
- The blkdev logical sector size is checked now, for consistency. It always should be 512 bytes on the supported/tested devices.
- Verbose error messages are replaced with pr_debug().
v3: - Fixed "BUG: KASAN: slab-out-of-bounds in tegra_partition". Thanks to
Peter Geis for noticing the problem.
- The MMC boot partitions scanning is now opt-in. See this patch:
mmc: block: Support partition-table scanning on boot partitions
- The found MMC boot partitions won't be assigned to the MMC boot block device ever due to the new GENHD_FL_PART_SCAN_ONCE flag.
This makes us to ensure that the old behavior of the MMC core is preserved for a non-Tegra MMC-block users.
New patches in v3:
block: Introduce GENHD_FL_PART_SCAN_ONCE
mmc: sdhci-tegra: Enable boot partitions scanning on Tegra20 and Tegra30
v2: - Addressed v1 review comments from Stephen Warren by using BIT for
locating BCT position in IRAM.
- Added more validations to the TegraPT parser: partition type is verified, eMMC instance ID is verified.
- TegraPT parser now doesn't touch any devices other than eMMC.
- EKS (encrypted keys) partition is blacklisted now.
- Implemented eMMC boot partitions scanning. These new patches are added in a result:
mmc: block: Add mmc_bdev_to_part_type() helper
mmc: block: Add mmc_bdev_to_area_type() helper
mmc: block: Add MMC_QUIRK_RESCAN_MAIN_BLKDEV
mmc: block: Enable partition-table scanning for boot partitions partitions/tegra: Implement eMMC boot partitions scanning
Dmitry Osipenko (6):
mmc: core: Add raw_boot_mult field to mmc_ext_csd
mmc: block: Add mmc_bdev_to_card() helper
partitions: Introduce NVIDIA Tegra Partition Table partitions/efi: Support GPT entry lookup at a non-standard location partitions/tegra: Support gpt_sector= command line option soc/tegra: Expose Boot Configuration Table via sysfs
arch/arm/mach-tegra/tegra.c | 58 ++++ block/partitions/Kconfig | 8 + block/partitions/Makefile | 1 + block/partitions/check.h | 2 + block/partitions/core.c | 4 + block/partitions/efi.c | 16 + block/partitions/efi.h | 2 + block/partitions/tegra.c | 603 ++++++++++++++++++++++++++++++++++ drivers/mmc/core/block.c | 15 + drivers/mmc/core/mmc.c | 2 + drivers/soc/tegra/Makefile | 1 + drivers/soc/tegra/bootdata.c | 51 +++ drivers/soc/tegra/common.c | 17 + include/linux/mmc/blkdev.h | 13 + include/linux/mmc/card.h | 1 + include/soc/tegra/bootdata.h | 48 +++ include/soc/tegra/common.h | 12 + include/soc/tegra/partition.h | 83 +++++ 18 files changed, 937 insertions(+) create mode 100644 block/partitions/tegra.c create mode 100644 drivers/soc/tegra/bootdata.c create mode 100644 include/linux/mmc/blkdev.h create mode 100644 include/soc/tegra/bootdata.h create mode 100644 include/soc/tegra/partition.h
Signature · 1 line
2.26.0
PATCH v4 1/6 mmc: core: Add raw_boot_mult field to mmc_ext_csd
In order to support parsing of NVIDIA Tegra Partition Table format, we need to know the BOOT_SIZE_MULT value of the Extended CSD register because NVIDIA's bootloader linearizes the boot0/boot1/main partitions into a single virtual space, and thus, all partition addresses are shifted by the size of boot0 + boot1 partitions.
--- drivers/mmc/core/mmc.c | 2 ++ include/linux/mmc/card.h | 1 + 2 files changed, 3 insertions(+)
drivers/mmc/core/mmc.c +2 -0
@@ -417,6 +417,8 @@ static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd) ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT ]; card->ext_csd.raw_hc_erase_grp_size = ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE ]; + card->ext_csd.raw_boot_mult = + ext_csd[EXT_CSD_BOOT_MULT ];if (card->ext_csd.rev >=3 ) {u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT ]; card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG ];
include/linux/mmc/card.h +1 -0
@@ -109,6 +109,7 @@ struct mmc_ext_csd {u8 raw_hc_erase_gap_size;/* 221 */ u8 raw_erase_timeout_mult;/* 223 */ u8 raw_hc_erase_grp_size;/* 224 */ +u8 raw_boot_mult;/* 226 */ u8 raw_sec_trim_mult;/* 229 */ u8 raw_sec_erase_mult;/* 230 */ u8 raw_sec_feature_support;/* 231 */
Signature · 1 line
2.26.0
PATCH v4 2/6 mmc: block: Add mmc_bdev_to_card() helper
In reply to Dmitry OsipenkoNVIDIA Tegra Partition Table takes into account MMC card's BOOT_SIZE_MULT parameter, and thus, the partition parser needs to retrieve that EXT_CSD value from the block device. There are also some other parts of struct mmc_card that are needed for the partition parser in order to calculate the eMMC offset and verify different things. This patch introduces new helper which takes block device for the input argument and returns the corresponding MMC card.
--- drivers/mmc/core/block.c | 15 +++++++++++++++ include/linux/mmc/blkdev.h | 13 +++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 include/linux/mmc/blkdev.h
drivers/mmc/core/block.c +15 -0
@@ -40,6 +40,7 @@#include <linux/debugfs.h> #include <linux/mmc/ioctl.h> +#include <linux/mmc/blkdev.h> #include <linux/mmc/card.h> #include <linux/mmc/host.h> #include <linux/mmc/mmc.h>
@@ -305,6 +306,20 @@ static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,return ret; } +struct mmc_card *mmc_bdev_to_card (struct block_device *bdev) +{ +struct mmc_blk_data *md; + +if (bdev->bd_disk->major !=MMC_BLOCK_MAJOR ) +return NULL ; + + md =mmc_blk_get (bdev->bd_disk); +if (!md) +return NULL ; + +return md->queue.card; +} +static int mmc_blk_open (struct block_device *bdev,fmode_t mode) {struct mmc_blk_data *md =mmc_blk_get (bdev->bd_disk);
include/linux/mmc/blkdev.h new file +13 -0
@@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* linux/include/linux/mmc/blkdev.h +*/ +#ifndef LINUX_MMC_BLOCK_DEVICE_H +#define LINUX_MMC_BLOCK_DEVICE_H + +struct block_device ; +struct mmc_card ; + +struct mmc_card *mmc_bdev_to_card (struct block_device *bdev); + +#endif /* LINUX_MMC_BLOCK_DEVICE_H */
Signature · 1 line
2.26.0
PATCH v4 3/6 partitions: Introduce NVIDIA Tegra Partition Table
In reply to Dmitry OsipenkoAll NVIDIA Tegra devices use a special partition table format for the internal storage partitioning. Most of Tegra devices have GPT partition in addition to TegraPT, but some older Android consumer-grade devices do not or GPT is placed in a wrong sector, and thus, the TegraPT is needed in order to support these devices properly by the upstream kernel. This patch adds support for NVIDIA Tegra Partition Table format that is used at least by all NVIDIA Tegra20 and Tegra30 devices.
--- arch/arm/mach-tegra/tegra.c | 54 ++++ block/partitions/Kconfig | 8 + block/partitions/Makefile | 1 + block/partitions/check.h | 1 + block/partitions/core.c | 3 + block/partitions/tegra.c | 565 ++++++++++++++++++++++++++++++++++ include/soc/tegra/bootdata.h | 46 +++ include/soc/tegra/common.h | 9 + include/soc/tegra/partition.h | 83 +++++ 9 files changed, 770 insertions(+) create mode 100644 block/partitions/tegra.c create mode 100644 include/soc/tegra/bootdata.h create mode 100644 include/soc/tegra/partition.h
arch/arm/mach-tegra/tegra.c +54 -0
@@ -28,7 +28,9 @@#include <linux/firmware/trusted_foundations.h> +#include <soc/tegra/bootdata.h> #include <soc/tegra/fuse.h> +#include <soc/tegra/partition.h> #include <soc/tegra/pmc.h> #include <asm/firmware.h>
@@ -62,9 +64,61 @@ u32 tegra_uart_config[3] = { 0, }; +static void __init tegra_boot_config_table_init (void ) +{ +struct tegra30_boot_config_table __iomem *t30_bct; +struct tegra20_boot_config_table __iomem *t20_bct; +struct tegra20_boot_info_table __iomem *t20_bit; +u32 iram_end =TEGRA_IRAM_BASE +TEGRA_IRAM_SIZE ; +u32 iram_start =TEGRA_IRAM_BASE ; +u32 pt_addr, pt_size, bct_size; + + t20_bit =IO_ADDRESS (TEGRA_IRAM_BASE ); + +if (of_machine_is_compatible ("nvidia,tegra20" )) { + bct_size =sizeof (*t20_bct); + +if (t20_bit->bct_size != bct_size || + t20_bit->bct_ptr < iram_start || + t20_bit->bct_ptr > iram_end - bct_size) +return ; + + t20_bct =IO_ADDRESS (t20_bit->bct_ptr); + +if (t20_bct->boot_data_version !=TEGRA_BOOTDATA_VERSION_T20 ) +return ; + + pt_addr = t20_bct->partition_table_logical_sector_address; + pt_size = t20_bct->partition_table_num_logical_sectors; + + }else if (of_machine_is_compatible ("nvidia,tegra30" )) { + bct_size =sizeof (*t30_bct); + +if (t20_bit->bct_size != bct_size || + t20_bit->bct_ptr < iram_start || + t20_bit->bct_ptr > iram_end - bct_size) +return ; + + t30_bct =IO_ADDRESS (t20_bit->bct_ptr); + +if (t30_bct->boot_data_version !=TEGRA_BOOTDATA_VERSION_T30 ) +return ; + + pt_addr = t30_bct->partition_table_logical_sector_address; + pt_size = t30_bct->partition_table_num_logical_sectors; + }else { +return ; + } + +pr_info ("%s: BCT found in IRAM\n" , __func__); + +tegra_partition_table_setup (pt_addr, pt_size); +} +static void __init tegra_init_early (void ) {of_register_trusted_foundations (); +tegra_boot_config_table_init ();tegra_cpu_reset_handler_init ();call_firmware_op (l2x0_init); }
block/partitions/Kconfig +8 -0
@@ -268,3 +268,11 @@ config CMDLINE_PARTITION help Say Y here if you want to read the partition table from bootargs. The format for the command line is just like mtdparts. + +config TEGRA_PARTITION + bool "NVIDIA Tegra Partition support" if PARTITION_ADVANCED + default y if ARCH_TEGRA + depends on (ARCH_TEGRA && MMC_BLOCK) || COMPILE_TEST + help + Say Y here if you would like to be able to read the hard disk + partition table format used by NVIDIA Tegra machines.
block/partitions/Makefile +1 -0
@@ -20,3 +20,4 @@ obj-$(CONFIG_IBM_PARTITION) += ibm.o obj-$(CONFIG_EFI_PARTITION) += efi.o obj-$(CONFIG_KARMA_PARTITION) += karma.o obj-$(CONFIG_SYSV68_PARTITION) += sysv68.o +obj-$(CONFIG_TEGRA_PARTITION) += tegra.o
block/partitions/check.h +1 -0
@@ -67,4 +67,5 @@ int osf_partition(struct parsed_partitions *state);int sgi_partition (struct parsed_partitions *state);int sun_partition (struct parsed_partitions *state);int sysv68_partition (struct parsed_partitions *state); +int tegra_partition (struct parsed_partitions *state);int ultrix_partition (struct parsed_partitions *state);
block/partitions/core.c +3 -0
@@ -81,6 +81,9 @@ static int (*check_part[])(struct parsed_partitions *) = {#endif #ifdef CONFIG_SYSV68_PARTITION sysv68_partition, +#endif +#ifdef CONFIG_TEGRA_PARTITION + tegra_partition, #endifNULL };
block/partitions/tegra.c new file +565 -0
565 lines not on this page · raw message
include/soc/tegra/bootdata.h new file +46 -0
46 lines not on this page · raw message
include/soc/tegra/common.h +9 -0
@@ -6,6 +6,15 @@#ifndef __SOC_TEGRA_COMMON_H__#define __SOC_TEGRA_COMMON_H__ +#include <linux/types.h> + +#ifdef CONFIG_ARCH_TEGRA bool soc_is_tegra (void ); +#else +static inline bool soc_is_tegra (void ) +{ +return false; +} +#endif #endif /* __SOC_TEGRA_COMMON_H__ */
include/soc/tegra/partition.h new file +83 -0
83 lines not on this page · raw message
Signature · 1 line
2.26.0
PATCH v4 4/6 partitions/efi: Support GPT entry lookup at a non-standard location
In reply to Dmitry OsipenkoMost of consumer-grade NVIDIA Tegra devices use a proprietary bootloader that can't be easily replaced because it's locked down using Secure Boot cryptography singing and the crypto keys aren't given to a device owner. These devices usually have eMMC storage that is partitioned using a custom NVIDIA Tegra partition table format. Of course bootloader and other "special things" are stored on the eMMC storage, and thus, the partition format can't be changed.
The Tegra partition format has been reverse-engineered, but NVIDIA did another odd thing by merging "boot" and "main" eMMC HW partitions into a single virtual partition in theirs bootloader. This is not supported by Linux kernel and can't be easily implemented. Hence partition table entry isn't accessible by kernel if it's located at the "boot" eMMC partition. Luckily this is a rare case in practice and even if it's the case, likely that the proprietary bootloader will supply kernel with a non-standard gpt_sector= cmdline option. This gpt_sector= argument points at a GPT entry that is placed at a non-standard location on the eMMC storage.
This patch allows to support the non-standard cmdline option for NVIDIA Tegra devices without bothering any other platforms. The force_gpt_sector variable should be set before invoking efi_partition() and be unset after the invocation completion. This variable, if set, instructs GPT parser to look up GPT entry at the given sector in addition to the standard GPT locations.
This patch is based on the original work done by Colin Cross for the downstream Android kernel.
--- block/partitions/efi.c | 10 ++++++++++ block/partitions/efi.h | 2 ++ 2 files changed, 12 insertions(+)
block/partitions/efi.c +10 -0
@@ -103,6 +103,12 @@ force_gpt_fn(char *str) }__setup ("gpt" , force_gpt_fn); +/* Used by NVIDIA Tegra partition parser in order to convey a non-standard +* location of the GPT entry for lookup. This variable should be set before +* efi_partition() invocation for instructing parser to look up GPT entry at +* the given sector, and it should be unset after completion of the invocation. +*/ +sector_t force_gpt_sector;/** * efi_crc32() - EFI version of crc32 function
@@ -621,6 +627,10 @@ static int find_valid_gpt(struct parsed_partitions *state, gpt_header **gpt,if (!good_agpt && force_gpt) good_agpt =is_gpt_valid (state, lastlba, &agpt, &aptes); +if (!good_agpt && force_gpt && force_gpt_sector) + good_agpt =is_gpt_valid (state, force_gpt_sector, + &agpt, &aptes); +/* The obviously unsuccessful case */ if (!good_pgpt && !good_agpt) goto fail;
block/partitions/efi.h +2 -0
@@ -113,4 +113,6 @@ typedef struct _legacy_mbr { __le16 signature; }__packed legacy_mbr; +extern sector_t force_gpt_sector; +#endif
Signature · 1 line
2.26.0
PATCH v4 5/6 partitions/tegra: Support gpt_sector= command line option
In reply to Dmitry OsipenkoThe gpt_sector=<sector> causes the GPT partition parser to look at the specified sector for a valid GPT header if the GPT is not found at the beginning or the end of a block device. This is needed by Tegra-based devices that have TegraPT and GPT placed in inaccessible by kernel locations. The GPT entry duplicates TegraPT partitions.
--- block/partitions/check.h | 1 + block/partitions/core.c | 1 + block/partitions/efi.c | 6 ++++++ block/partitions/tegra.c | 38 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 46 insertions(+)
block/partitions/check.h +1 -0
@@ -67,5 +67,6 @@ int osf_partition(struct parsed_partitions *state);int sgi_partition (struct parsed_partitions *state);int sun_partition (struct parsed_partitions *state);int sysv68_partition (struct parsed_partitions *state); +int tegra_partition_gpt (struct parsed_partitions *state);int tegra_partition (struct parsed_partitions *state);int ultrix_partition (struct parsed_partitions *state);
block/partitions/core.c +1 -0
@@ -83,6 +83,7 @@ static int (*check_part[])(struct parsed_partitions *) = { sysv68_partition,#endif #ifdef CONFIG_TEGRA_PARTITION + tegra_partition_gpt, tegra_partition, #endifNULL
block/partitions/efi.c +6 -0
@@ -98,6 +98,12 @@ static int force_gpt;static int __init force_gpt_fn (char *str) { +/* This check allows to parse "gpt gpt_sector=" properly since +* "gpt" overlaps with "gpt_sector", see tegra_gpt_sector_fn(). +*/ +if (force_gpt) +return 0 ; + force_gpt =1 ;return 1 ; }
block/partitions/tegra.c +38 -0
@@ -30,6 +30,7 @@#include <soc/tegra/common.h> #include <soc/tegra/partition.h> +#include "efi.h" #include "check.h" #define TEGRA_PT_SECTOR_SIZE (ptp) ((ptp)->logical_sector_size / SZ_512)
@@ -563,3 +564,40 @@ int tegra_partition(struct parsed_partitions *state)return ret; } + +/* +* This allows a kernel command line option 'gpt_sector=<sector>' to +* enable GPT header lookup at a non-standard location. This option +* is given to kernel by a proprietary bootloader, which is used by +* *most* (but not all) of NVIDIA Tegra-based devices. +*/ +static sector_t tegra_gpt_sector; +static int __init tegra_gpt_sector_fn (char *str) +{ +WARN_ON (kstrtoull (str,10 , &tegra_gpt_sector) <0 ); +return 1 ; +} +__setup ("gpt_sector=" , tegra_gpt_sector_fn); + +int tegra_partition_gpt (struct parsed_partitions *state) +{ +int ret =0 ; + +#ifdef CONFIG_EFI_PARTITION +struct tegra_partition_table_parser ptp = {}; + +if (!soc_is_tegra () || !tegra_boot_sdmmc || !tegra_gpt_sector) +return 0 ; + + ptp.state = state; + + ptp.boot_offset =tegra_partition_table_emmc_boot_offset (&ptp); +if (ptp.boot_offset <0 ) +return 0 ; + + force_gpt_sector = tegra_gpt_sector; + ret =efi_partition (ptp.state); + force_gpt_sector =0 ; +#endif +return ret; +}
Signature · 1 line
2.26.0
PATCH v4 6/6 soc/tegra: Expose Boot Configuration Table via sysfs
In reply to Dmitry OsipenkoIt's quite useful to have unencrypted BCT exposed to userspace for debugging purposes, so let's expose it via sysfs. The BCT data will present in /sys/tegra/boot_config_table binary file if BCT is available.
--- arch/arm/mach-tegra/tegra.c | 4 +++ drivers/soc/tegra/Makefile | 1 + drivers/soc/tegra/bootdata.c | 51 ++++++++++++++++++++++++++++++++++++ drivers/soc/tegra/common.c | 17 ++++++++++++ include/soc/tegra/bootdata.h | 2 ++ include/soc/tegra/common.h | 3 +++ 6 files changed, 78 insertions(+) create mode 100644 drivers/soc/tegra/bootdata.c
arch/arm/mach-tegra/tegra.c +4 -0
@@ -72,6 +72,7 @@ static void __init tegra_boot_config_table_init(void)u32 iram_end =TEGRA_IRAM_BASE +TEGRA_IRAM_SIZE ;u32 iram_start =TEGRA_IRAM_BASE ;u32 pt_addr, pt_size, bct_size; +void __iomem *bct_ptr; t20_bit =IO_ADDRESS (TEGRA_IRAM_BASE );
@@ -90,6 +91,7 @@ static void __init tegra_boot_config_table_init(void) pt_addr = t20_bct->partition_table_logical_sector_address; pt_size = t20_bct->partition_table_num_logical_sectors; + bct_ptr = t20_bct; }else if (of_machine_is_compatible ("nvidia,tegra30" )) { bct_size =sizeof (*t30_bct);
@@ -106,12 +108,14 @@ static void __init tegra_boot_config_table_init(void) pt_addr = t30_bct->partition_table_logical_sector_address; pt_size = t30_bct->partition_table_num_logical_sectors; + bct_ptr = t30_bct; }else {return ; }pr_info ("%s: BCT found in IRAM\n" , __func__); +tegra_bootdata_bct_setup (bct_ptr, bct_size);tegra_partition_table_setup (pt_addr, pt_size); }
drivers/soc/tegra/Makefile +1 -0
@@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 obj-y += fuse/ +obj-y += bootdata.o obj-y += common.o obj-$(CONFIG_SOC_TEGRA_FLOWCTRL) += flowctrl.o obj-$(CONFIG_SOC_TEGRA_PMC) += pmc.o
drivers/soc/tegra/bootdata.c new file +51 -0
51 lines not on this page · raw message
drivers/soc/tegra/common.c +17 -0
@@ -3,10 +3,15 @@* Copyright (C) 2014 NVIDIA CORPORATION. All rights reserved. */ +#include <linux/init.h> +#include <linux/kernel.h> #include <linux/of.h> +#include <linux/sysfs.h> #include <soc/tegra/common.h> +struct kobject *tegra_soc_kobj; +static const struct of_device_id tegra_machine_match[] = { { .compatible ="nvidia,tegra20" , }, { .compatible ="nvidia,tegra30" , },
@@ -31,3 +36,15 @@ bool soc_is_tegra(void)return match !=NULL ; } + +static int __init tegra_soc_sysfs_init (void ) +{ +if (!soc_is_tegra ()) +return 0 ; + + tegra_soc_kobj =kobject_create_and_add ("tegra" ,NULL ); +WARN_ON (!tegra_soc_kobj); + +return 0 ; +} +arch_initcall (tegra_soc_sysfs_init)
include/soc/tegra/bootdata.h +2 -0
@@ -43,4 +43,6 @@ struct tegra30_boot_config_table { u32 unused_data[3]; } __packed; +void tegra_bootdata_bct_setup (void __iomem *bct_ptr,size_t bct_size); +#endif /* __SOC_TEGRA_BOOTDATA_H__ */
include/soc/tegra/common.h +3 -0
@@ -7,8 +7,11 @@#define __SOC_TEGRA_COMMON_H__#include <linux/types.h> +#include <linux/sysfs.h> #ifdef CONFIG_ARCH_TEGRA +extern struct kobject *tegra_soc_kobj; +bool soc_is_tegra (void );#else static inline bool soc_is_tegra (void )
Signature · 1 line
2.26.0
Re: [PATCH v4 3/6] partitions: Introduce NVIDIA Tegra Partition Table
In reply to Dmitry Osipenkoblock/partitions/Kconfig config CMDLINE_PARTITION · line 275
Quoted 13 lines · Dmitry Osipenko
block/partitions/Kconfig +5
-0@@ -268,3 +268,11 @@ config CMDLINE_PARTITION help Say Y here if you want to read the partition table from bootargs. The format for the command line is just like mtdparts. + +config TEGRA_PARTITION + bool "NVIDIA Tegra Partition support" if PARTITION_ADVANCED + default y if ARCH_TEGRA + depends on (ARCH_TEGRA && MMC_BLOCK) || COMPILE_TEST
That looks odd. Such depends are more often like:
depends on MMC_BLOCK && (ARCH_TEGRA || COMPILE_TEST)
but that's just my experience. If this works when ARCH_TEGRA and MMC_BLOCK are not set and COMPILE_TEST is set, that's fine.
block/partitions/Kconfig config CMDLINE_PARTITION · line 278
Quoted 3 lines
block/partitions/Kconfig +3
-0+ help + Say Y here if you would like to be able to read the hard disk + partition table format used by NVIDIA Tegra machines.
thanks.
Signature · 1 line
~Randy
Re: [PATCH v4 3/6] partitions: Introduce NVIDIA Tegra Partition Table
15.05.2020 04:58, Randy Dunlap пишет:
Quoted 16 lines · Dmitry Osipenko
block/partitions/Kconfig config CMDLINE_PARTITION · line 275
Quoted 13 lines
block/partitions/Kconfig +5
-0@@ -268,3 +268,11 @@ config CMDLINE_PARTITION help Say Y here if you want to read the partition table from bootargs. The format for the command line is just like mtdparts. + +config TEGRA_PARTITION + bool "NVIDIA Tegra Partition support" if PARTITION_ADVANCED + default y if ARCH_TEGRA + depends on (ARCH_TEGRA && MMC_BLOCK) || COMPILE_TESTThat looks odd. Such depends are more often like:
Quoted 4 lines
depends on MMC_BLOCK && (ARCH_TEGRA || COMPILE_TEST)but that's just my experience. If this works when
ARCH_TEGRAandMMC_BLOCKare not set andCOMPILE_TESTis set, that's fine.
Ah, right! It shouldn't work since mmc_bdev_to_card() will be undefined if MMC_BLOCK=n. Good catch, thank you! :)
Re: [PATCH v4 4/6] partitions/efi: Support GPT entry lookup at a non-standard location
In reply to Dmitry OsipenkoQuoted 3 lines · Dmitry Osipenko
Most of consumer-grade NVIDIA Tegra devices use a proprietary bootloader that can't be easily replaced because it's locked down using Secure Boot cryptography singing and the crypto keys aren't given to a device owner.
^^^^^^^ typo
Quoted 4 lines
These devices usually have eMMC storage that is partitioned using a custom NVIDIA Tegra partition table format. Of course bootloader and other "special things" are stored on the eMMC storage, and thus, the partition format can't be changed.
...
Signature · 4 lines
Steve McIntyre, Cambridge, UK. [email protected] "Further comment on how I feel about IBM will appear once I've worked out whether they're being malicious or incompetent. Capital letters are forecast." Matthew Garrett, http://www.livejournal.com/users/mjg59/30675.html
Re: [PATCH v4 4/6] partitions/efi: Support GPT entry lookup at a non-standard location
15.05.2020 13:03, Steve McIntyre пишет:
Quoted 12 lines · Dmitry Osipenko
Quoted 3 lines
Most of consumer-grade NVIDIA Tegra devices use a proprietary bootloader that can't be easily replaced because it's locked down using Secure Boot cryptography singing and the crypto keys aren't given to a device owner.
^^^^^^^ typoQuoted 4 lines
These devices usually have eMMC storage that is partitioned using a custom NVIDIA Tegra partition table format. Of course bootloader and other "special things" are stored on the eMMC storage, and thus, the partition format can't be changed.
...
Thanks! I'll correct it in v5.