src/arm/linux/midr.c

#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include <arm/linux/api.h>
#include <cpuinfo.h>
#if defined(__ANDROID__)
#include <arm/android/api.h>
#endif
#include <arm/api.h>
#include <arm/midr.h>
#include <cpuinfo/common.h>
#include <cpuinfo/internal-api.h>
#include <cpuinfo/log.h>
#include <linux/api.h>

#define CLUSTERS_MAX 3

static inline bool bitmask_all(uint32_t bitfield, uint32_t mask) {
	return (bitfield & mask) == mask;
}

/* Description of core clusters configuration in a chipset (identified by series
 * and model number) */
struct cluster_config {
	/* Number of cores (logical processors) */
	uint8_t cores;
	/* ARM chipset series (see cpuinfo_arm_chipset_series enum) */
	uint8_t series;
	/* Chipset model number (see cpuinfo_arm_chipset struct) */
	uint16_t model;
	/* Number of heterogenous clusters in the CPU package */
	uint8_t clusters;
	/*
	 * Number of cores in each cluster:
	 # - Symmetric configurations: [0] = # cores
	 * - big.LITTLE configurations: [0] = # LITTLE cores, [1] = # big cores
	 * - Max.Med.Min configurations: [0] = # Min cores, [1] = # Med cores,
	 [2] = # Max cores
	 */
	uint8_t cluster_cores[CLUSTERS_MAX];
	/*
	 * MIDR of cores in each cluster:
	 * - Symmetric configurations: [0] = core MIDR
	 * - big.LITTLE configurations: [0] = LITTLE core MIDR, [1] = big core
	 * MIDR
	 * - Max.Med.Min configurations: [0] = Min core MIDR, [1] = Med core
	 * MIDR, [2] = Max core MIDR
	 */
	uint32_t cluster_midr[CLUSTERS_MAX];
};

/*
 * The list of chipsets where MIDR may not be unambigiously decoded at least on
 * some devices. The typical reasons for impossibility to decoded MIDRs are
 * buggy kernels, which either do not report all MIDR information (e.g. on
 * ATM7029 kernel doesn't report CPU Part), or chipsets have more than one type
 * of cores (i.e. 4x Cortex-A53 + 4x Cortex-A53 is out) and buggy kernels report
 * MIDR information only about some cores in /proc/cpuinfo (either only online
 * cores, or only the core that reads /proc/cpuinfo). On these kernels/chipsets,
 * it is not possible to detect all core types by just parsing /proc/cpuinfo, so
 * we use chipset name and this table to find their MIDR (and thus
 * microarchitecture, cache, etc).
 *
 * Note: not all chipsets with heterogeneous multiprocessing need an entry in
 * this table. The following HMP chipsets always list information about all
 * cores in /proc/cpuinfo:
 *
 * - Snapdragon 660
 * - Snapdragon 820 (MSM8996)
 * - Snapdragon 821 (MSM8996PRO)
 * - Snapdragon 835 (MSM8998)
 * - Exynos 8895
 * - Kirin 960
 *
 * As these are all new processors, there is hope that this table won't
 * uncontrollably grow over time.
 */
static const struct cluster_config
	cluster_configs[] =
		{
#if CPUINFO_ARCH_ARM
			{
				/*
				 * MSM8916 (Snapdragon 410): 4x Cortex-A53
				 * Some AArch32 phones use non-standard /proc/cpuinfo format.
				 */
				.cores = 4,
				.series = cpuinfo_arm_chipset_series_qualcomm_msm,
				.model = UINT16_C(8916),
				.clusters = 1,
				.cluster_cores =
					{
						[0] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD030),
					},
			},
			{
				/*
				 * MSM8939 (Snapdragon 615): 4x Cortex-A53 + 4x Cortex-A53
				 * Some AArch32 phones use non-standard /proc/cpuinfo format.
				 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_qualcomm_msm,
				.model = UINT16_C(8939),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x410FD034),
					},
			},
#endif
			{
				/* MSM8956 (Snapdragon 650): 2x Cortex-A72 + 4x Cortex-A53 */
				.cores = 6,
				.series = cpuinfo_arm_chipset_series_qualcomm_msm,
				.model = UINT16_C(8956),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x410FD080),
					},
			},
			{
				/* MSM8976/MSM8976PRO (Snapdragon 652/653): 4x Cortex-A72 + 4x
				   Cortex-A53 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_qualcomm_msm,
				.model = UINT16_C(8976),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x410FD080),
					},
			},
			{
				/* MSM8992 (Snapdragon 808): 2x Cortex-A57 + 4x Cortex-A53 */
				.cores = 6,
				.series = cpuinfo_arm_chipset_series_qualcomm_msm,
				.model = UINT16_C(8992),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD033),
						[1] = UINT32_C(0x411FD072),
					},
			},
			{
				/* MSM8994/MSM8994V (Snapdragon 810): 4x Cortex-A57 + 4x
				   Cortex-A53 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_qualcomm_msm,
				.model = UINT16_C(8994),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD032),
						[1] = UINT32_C(0x411FD071),
					},
			},
#if CPUINFO_ARCH_ARM
			{
				/* Exynos 5422: 4x Cortex-A15 + 4x Cortex-A7 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_samsung_exynos,
				.model = UINT16_C(5422),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC073),
						[1] = UINT32_C(0x412FC0F3),
					},
			},
			{
				/* Exynos 5430: 4x Cortex-A15 + 4x Cortex-A7 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_samsung_exynos,
				.model = UINT16_C(5430),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC074),
						[1] = UINT32_C(0x413FC0F3),
					},
			},
#endif /* CPUINFO_ARCH_ARM */
			{
				/* Exynos 5433: 4x Cortex-A57 + 4x Cortex-A53 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_samsung_exynos,
				.model = UINT16_C(5433),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD031),
						[1] = UINT32_C(0x411FD070),
					},
			},
			{
				/* Exynos 7420: 4x Cortex-A57 + 4x Cortex-A53 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_samsung_exynos,
				.model = UINT16_C(7420),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD032),
						[1] = UINT32_C(0x411FD070),
					},
			},
			{
				/* Exynos 8890: 4x Exynos M1 + 4x Cortex-A53 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_samsung_exynos,
				.model = UINT16_C(8890),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x531F0011),
					},
			},
#if CPUINFO_ARCH_ARM
			{
				/* Kirin 920: 4x Cortex-A15 + 4x Cortex-A7 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_hisilicon_kirin,
				.model = UINT16_C(920),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC075),
						[1] = UINT32_C(0x413FC0F3),
					},
			},
			{
				/* Kirin 925: 4x Cortex-A15 + 4x Cortex-A7 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_hisilicon_kirin,
				.model = UINT16_C(925),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC075),
						[1] = UINT32_C(0x413FC0F3),
					},
			},
			{
				/* Kirin 928: 4x Cortex-A15 + 4x Cortex-A7 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_hisilicon_kirin,
				.model = UINT16_C(928),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC075),
						[1] = UINT32_C(0x413FC0F3),
					},
			},
#endif /* CPUINFO_ARCH_ARM */
			{
				/* Kirin 950: 4x Cortex-A72 + 4x Cortex-A53 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_hisilicon_kirin,
				.model = UINT16_C(950),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x410FD080),
					},
			},
			{
				/* Kirin 955: 4x Cortex-A72 + 4x Cortex-A53 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_hisilicon_kirin,
				.model = UINT16_C(955),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x410FD080),
					},
			},
#if CPUINFO_ARCH_ARM
			{
				/* MediaTek MT8135: 2x Cortex-A7 + 2x Cortex-A15 */
				.cores = 4,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(8135),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 2,
						[1] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC073),
						[1] = UINT32_C(0x413FC0F2),
					},
			},
#endif
			{
				/* MediaTek MT8173: 2x Cortex-A72 + 2x Cortex-A53 */
				.cores = 4,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(8173),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 2,
						[1] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD032),
						[1] = UINT32_C(0x410FD080),
					},
			},
			{
				/* MediaTek MT8176: 2x Cortex-A72 + 4x Cortex-A53 */
				.cores = 6,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(8176),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD032),
						[1] = UINT32_C(0x410FD080),
					},
			},
#if CPUINFO_ARCH_ARM64
			{
				/*
				 * MediaTek MT8735: 4x Cortex-A53
				 * Some AArch64 phones use non-standard /proc/cpuinfo format.
				 */
				.cores = 4,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(8735),
				.clusters = 1,
				.cluster_cores =
					{
						[0] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
					},
			},
#endif
#if CPUINFO_ARCH_ARM
			{
				/*
				 * MediaTek MT6592: 4x Cortex-A7 + 4x Cortex-A7
				 * Some phones use non-standard /proc/cpuinfo format.
				 */
				.cores = 4,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(6592),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC074),
						[1] = UINT32_C(0x410FC074),
					},
			},
			{
				/* MediaTek MT6595: 4x Cortex-A17 + 4x Cortex-A7 */
				.cores = 8,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(6595),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC075),
						[1] = UINT32_C(0x410FC0E0),
					},
			},
#endif
			{
				/* MediaTek MT6797: 2x Cortex-A72 + 4x Cortex-A53 + 4x
				   Cortex-A53 */
				.cores = 10,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(6797),
				.clusters = 3,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
						[2] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x410FD034),
						[2] = UINT32_C(0x410FD081),
					},
			},
			{
				/* MediaTek MT6799: 2x Cortex-A73 + 4x Cortex-A53 + 4x
				   Cortex-A35 */
				.cores = 10,
				.series = cpuinfo_arm_chipset_series_mediatek_mt,
				.model = UINT16_C(6799),
				.clusters = 3,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 4,
						[2] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD041),
						[1] = UINT32_C(0x410FD034),
						[2] = UINT32_C(0x410FD092),
					},
			},
			{
				/* Rockchip RK3399: 2x Cortex-A72 + 4x Cortex-A53 */
				.cores = 6,
				.series = cpuinfo_arm_chipset_series_rockchip_rk,
				.model = UINT16_C(3399),
				.clusters = 2,
				.cluster_cores =
					{
						[0] = 4,
						[1] = 2,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FD034),
						[1] = UINT32_C(0x410FD082),
					},
			},
#if CPUINFO_ARCH_ARM
			{
				/* Actions ATM8029: 4x Cortex-A5
				 * Most devices use non-standard /proc/cpuinfo format.
				 */
				.cores = 4,
				.series = cpuinfo_arm_chipset_series_actions_atm,
				.model = UINT16_C(7029),
				.clusters = 1,
				.cluster_cores =
					{
						[0] = 4,
					},
				.cluster_midr =
					{
						[0] = UINT32_C(0x410FC051),
					},
			},
#endif
};

/*
 * Searches chipset name in mapping of chipset name to cores' MIDR values. If
 * match is successful, initializes MIDR for all clusters' leaders with
 * tabulated values.
 *
 * @param[in] chipset - chipset (SoC) name information.
 * @param clusters_count - number of CPU core clusters detected in the SoC.
 * @param cluster_leaders - indices of core clusters' leaders in the @p
 * processors array.
 * @param processors_count - number of usable logical processors in the system.
 * @param[in,out] processors - array of logical processor descriptions with
 * pre-parsed MIDR, maximum frequency, and decoded core cluster
 * (package_leader_id) information. Upon successful return, processors[i].midr
 * for all clusters' leaders contains the tabulated MIDR values.
 * @param verify_midr - indicated whether the function should check that the
 * MIDR values to be assigned to leaders of core clusters are consistent with
 * known parts of their parsed values. Set if to false if the only MIDR value
 * parsed from /proc/cpuinfo is for the last processor reported in /proc/cpuinfo
 * and thus can't be unambiguously attributed to that processor.
 *
 * @retval true if the chipset was found in the mapping and core clusters'
 * leaders initialized with MIDR values.
 * @retval false if the chipset was not found in the mapping, or any consistency
 * check failed.
 */
static bool cpuinfo_arm_linux_detect_cluster_midr_by_chipset(
	const struct cpuinfo_arm_chipset chipset[restrict static 1],
	uint32_t clusters_count,
	const uint32_t cluster_leaders[restrict static CLUSTERS_MAX],
	uint32_t processors_count,
	struct cpuinfo_arm_linux_processor processors[restrict static processors_count],
	bool verify_midr) {
	if (clusters_count <= CLUSTERS_MAX) {
		for (uint32_t c = 0; c < CPUINFO_COUNT_OF(cluster_configs); c++) {
			if (cluster_configs[c].model == chipset->model &&
			    cluster_configs[c].series == chipset->series) {
				/* Verify that the total number of cores and
				 * clusters of cores matches expectation */
				if (cluster_configs[c].cores != processors_count ||
				    cluster_configs[c].clusters != clusters_count) {
					return false;
				}

				/* Verify that core cluster configuration
				 * matches expectation */
				for (uint32_t cluster = 0; cluster < clusters_count; cluster++) {
					const uint32_t cluster_leader = cluster_leaders[cluster];
					if (cluster_configs[c].cluster_cores[cluster] !=
					    processors[cluster_leader].package_processor_count) {
						return false;
					}
				}

				if (verify_midr) {
					/* Verify known parts of MIDR */
					for (uint32_t cluster = 0; cluster < clusters_count; cluster++) {
						const uint32_t cluster_leader = cluster_leaders[cluster];

						/* Create a mask of known midr
						 * bits */
						uint32_t midr_mask = 0;
						if (processors[cluster_leader].flags &
						    CPUINFO_ARM_LINUX_VALID_IMPLEMENTER) {
							midr_mask |= CPUINFO_ARM_MIDR_IMPLEMENTER_MASK;
						}
						if (processors[cluster_leader].flags &
						    CPUINFO_ARM_LINUX_VALID_VARIANT) {
							midr_mask |= CPUINFO_ARM_MIDR_VARIANT_MASK;
						}
						if (processors[cluster_leader].flags & CPUINFO_ARM_LINUX_VALID_PART) {
							midr_mask |= CPUINFO_ARM_MIDR_PART_MASK;
						}
						if (processors[cluster_leader].flags &
						    CPUINFO_ARM_LINUX_VALID_REVISION) {
							midr_mask |= CPUINFO_ARM_MIDR_REVISION_MASK;
						}

						/* Verify the bits under the
						 * mask */
						if ((processors[cluster_leader].midr ^
						     cluster_configs[c].cluster_midr[cluster]) &
						    midr_mask) {
							cpuinfo_log_debug(
								"parsed MIDR of cluster %08" PRIu32
								" does not match tabulated value %08" PRIu32,
								processors[cluster_leader].midr,
								cluster_configs[c].cluster_midr[cluster]);
							return false;
						}
					}
				}

				/* Assign MIDRs according to tabulated
				 * configurations */
				for (uint32_t cluster = 0; cluster < clusters_count; cluster++) {
					const uint32_t cluster_leader = cluster_leaders[cluster];
					processors[cluster_leader].midr = cluster_configs[c].cluster_midr[cluster];
					processors[cluster_leader].flags |= CPUINFO_ARM_LINUX_VALID_MIDR;
					cpuinfo_log_debug(
						"cluster %" PRIu32 " MIDR = 0x%08" PRIx32,
						cluster,
						cluster_configs[c].cluster_midr[cluster]);
				}
				return true;
			}
		}
	}
	return false;
}

/*
 * Initializes MIDR for leaders of core clusters using a heuristic for
 * big.LITTLE systems:
 * - If the only known MIDR is for the big core cluster, guess the matching MIDR
 * for the LITTLE cluster.
 * - Estimate which of the clusters is big using maximum frequency, if known,
 * otherwise using system processor ID.
 * - Initialize the MIDR for big and LITTLE core clusters using the guesstimates
 * values.
 *
 * @param clusters_count - number of CPU core clusters detected in the SoC.
 * @param cluster_with_midr_count - number of CPU core clusters in the SoC with
 * known MIDR values.
 * @param last_processor_with_midr - index of the last logical processor with
 * known MIDR in the @p processors array.
 * @param cluster_leaders - indices of core clusters' leaders in the @p
 * processors array.
 * @param[in,out] processors - array of logical processor descriptions with
 * pre-parsed MIDR, maximum frequency, and decoded core cluster
 * (package_leader_id) information. Upon successful return, processors[i].midr
 * for all core clusters' leaders contains the heuristically detected MIDR
 * value.
 * @param verify_midr - indicated whether the function should check that the
 * MIDR values to be assigned to leaders of core clusters are consistent with
 * known parts of their parsed values. Set if to false if the only MIDR value
 * parsed from /proc/cpuinfo is for the last processor reported in /proc/cpuinfo
 * and thus can't be unambiguously attributed to that processor.
 *
 * @retval true if this is a big.LITTLE system with only one known MIDR and the
 * CPU core clusters' leaders were initialized with MIDR values.
 * @retval false if this is not a big.LITTLE system.
 */
static bool cpuinfo_arm_linux_detect_cluster_midr_by_big_little_heuristic(
	uint32_t clusters_count,
	uint32_t cluster_with_midr_count,
	uint32_t last_processor_with_midr,
	const uint32_t cluster_leaders[restrict static CLUSTERS_MAX],
	struct cpuinfo_arm_linux_processor processors[restrict static last_processor_with_midr],
	bool verify_midr) {
	if (clusters_count != 2 || cluster_with_midr_count != 1) {
		/* Not a big.LITTLE system, or MIDR is known for both/neither
		 * clusters */
		return false;
	}

	const uint32_t midr_flags =
		(processors[processors[last_processor_with_midr].package_leader_id].flags &
		 CPUINFO_ARM_LINUX_VALID_MIDR);
	const uint32_t big_midr = processors[processors[last_processor_with_midr].package_leader_id].midr;
	const uint32_t little_midr = midr_little_core_for_big(big_midr);

	/* Default assumption: the first reported cluster is LITTLE cluster
	 * (this holds on most Linux kernels) */
	uint32_t little_cluster_leader = cluster_leaders[0];
	const uint32_t other_cluster_leader = cluster_leaders[1];
	/* If maximum frequency is known for both clusters, assume LITTLE
	 * cluster is the one with lower frequency */
	if (processors[little_cluster_leader].flags & processors[other_cluster_leader].flags &
	    CPUINFO_LINUX_FLAG_MAX_FREQUENCY) {
		if (processors[little_cluster_leader].max_frequency > processors[other_cluster_leader].max_frequency) {
			little_cluster_leader = other_cluster_leader;
		}
	}

	if (verify_midr) {
		/* Verify known parts of MIDR */
		for (uint32_t cluster = 0; cluster < clusters_count; cluster++) {
			const uint32_t cluster_leader = cluster_leaders[cluster];

			/* Create a mask of known midr bits */
			uint32_t midr_mask = 0;
			if (processors[cluster_leader].flags & CPUINFO_ARM_LINUX_VALID_IMPLEMENTER) {
				midr_mask |= CPUINFO_ARM_MIDR_IMPLEMENTER_MASK;
			}
			if (processors[cluster_leader].flags & CPUINFO_ARM_LINUX_VALID_VARIANT) {
				midr_mask |= CPUINFO_ARM_MIDR_VARIANT_MASK;
			}
			if (processors[cluster_leader].flags & CPUINFO_ARM_LINUX_VALID_PART) {
				midr_mask |= CPUINFO_ARM_MIDR_PART_MASK;
			}
			if (processors[cluster_leader].flags & CPUINFO_ARM_LINUX_VALID_REVISION) {
				midr_mask |= CPUINFO_ARM_MIDR_REVISION_MASK;
			}

			/* Verify the bits under the mask */
			const uint32_t midr = (cluster_leader == little_cluster_leader) ? little_midr : big_midr;
			if ((processors[cluster_leader].midr ^ midr) & midr_mask) {
				cpuinfo_log_debug(
					"parsed MIDR %08" PRIu32 " of cluster leader %" PRIu32
					" is inconsistent with expected value %08" PRIu32,
					processors[cluster_leader].midr,
					cluster_leader,
					midr);
				return false;
			}
		}
	}

	for (uint32_t c = 0; c < clusters_count; c++) {
		/* Skip cluster with already assigned MIDR */
		const uint32_t cluster_leader = cluster_leaders[c];
		if (bitmask_all(processors[cluster_leader].flags, CPUINFO_ARM_LINUX_VALID_MIDR)) {
			continue;
		}

		const uint32_t midr = (cluster_leader == little_cluster_leader) ? little_midr : big_midr;
		cpuinfo_log_info("assume processor %" PRIu32 " to have MIDR %08" PRIx32, cluster_leader, midr);
		/* To be consistent, we copy the MIDR entirely, rather than by
		 * parts */
		processors[cluster_leader].midr = midr;
		processors[cluster_leader].flags |= midr_flags;
	}
	return true;
}

/*
 * Initializes MIDR for leaders of core clusters in a single sequential scan:
 *  - Clusters preceding the first reported MIDR value are assumed to have
 * default MIDR value.
 *  - Clusters following any reported MIDR value to have that MIDR value.
 *
 * @param default_midr - MIDR value that will be assigned to cluster leaders
 * preceding any reported MIDR value.
 * @param processors_count - number of logical processor descriptions in the @p
 * processors array.
 * @param[in,out] processors - array of logical processor descriptions with
 * pre-parsed MIDR, maximum frequency, and decoded core cluster
 * (package_leader_id) information. Upon successful return, processors[i].midr
 * for all core clusters' leaders contains the assigned MIDR value.
 */
static void cpuinfo_arm_linux_detect_cluster_midr_by_sequential_scan(
	uint32_t default_midr,
	uint32_t processors_count,
	struct cpuinfo_arm_linux_processor processors[restrict static processors_count]) {
	uint32_t midr = default_midr;
	for (uint32_t i = 0; i < processors_count; i++) {
		if (bitmask_all(processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) {
			if (processors[i].package_leader_id == i) {
				if (bitmask_all(processors[i].flags, CPUINFO_ARM_LINUX_VALID_MIDR)) {
					midr = processors[i].midr;
				} else {
					cpuinfo_log_info(
						"assume processor %" PRIu32 " to have MIDR %08" PRIx32, i, midr);
					/* To be consistent, we copy the MIDR
					 * entirely, rather than by parts
					 */
					processors[i].midr = midr;
					processors[i].flags |= CPUINFO_ARM_LINUX_VALID_MIDR;
				}
			}
		}
	}
}

/*
 * Detects MIDR of each CPU core clusters' leader.
 *
 * @param[in] chipset - chipset (SoC) name information.
 * @param max_processors - number of processor descriptions in the @p processors
 * array.
 * @param usable_processors - number of processor descriptions in the @p
 * processors array with both POSSIBLE and PRESENT flags.
 * @param[in,out] processors - array of logical processor descriptions with
 * pre-parsed MIDR, maximum frequency, and decoded core cluster
 * (package_leader_id) information. Upon return, processors[i].midr for all
 * clusters' leaders contains the MIDR value.
 *
 * @returns The number of core clusters
 */
uint32_t cpuinfo_arm_linux_detect_cluster_midr(
	const struct cpuinfo_arm_chipset chipset[restrict static 1],
	uint32_t max_processors,
	uint32_t usable_processors,
	struct cpuinfo_arm_linux_processor processors[restrict static max_processors]) {
	uint32_t clusters_count = 0;
	uint32_t cluster_leaders[CLUSTERS_MAX];
	uint32_t last_processor_in_cpuinfo = max_processors;
	uint32_t last_processor_with_midr = max_processors;
	uint32_t processors_with_midr_count = 0;
	for (uint32_t i = 0; i < max_processors; i++) {
		if (bitmask_all(processors[i].flags, CPUINFO_LINUX_FLAG_VALID)) {
			if (processors[i].flags & CPUINFO_ARM_LINUX_VALID_PROCESSOR) {
				last_processor_in_cpuinfo = i;
			}
			if (bitmask_all(
				    processors[i].flags,
				    CPUINFO_ARM_LINUX_VALID_IMPLEMENTER | CPUINFO_ARM_LINUX_VALID_PART)) {
				last_processor_with_midr = i;
				processors_with_midr_count += 1;
			}
			const uint32_t group_leader = processors[i].package_leader_id;
			if (group_leader == i) {
				if (clusters_count < CLUSTERS_MAX) {
					cluster_leaders[clusters_count] = i;
				}
				clusters_count += 1;
			} else {
				/* Copy known bits of information to cluster
				 * leader */

				if ((processors[i].flags & ~processors[group_leader].flags) &
				    CPUINFO_LINUX_FLAG_MAX_FREQUENCY) {
					processors[group_leader].max_frequency = processors[i].max_frequency;
					processors[group_leader].flags |= CPUINFO_LINUX_FLAG_MAX_FREQUENCY;
				}
				if (!bitmask_all(processors[group_leader].flags, CPUINFO_ARM_LINUX_VALID_MIDR) &&
				    bitmask_all(processors[i].flags, CPUINFO_ARM_LINUX_VALID_MIDR)) {
					processors[group_leader].midr = processors[i].midr;
					processors[group_leader].flags |= CPUINFO_ARM_LINUX_VALID_MIDR;
				}
			}
		}
	}
	cpuinfo_log_debug("detected %" PRIu32 " core clusters", clusters_count);

	/*
	 * Two relations between reported /proc/cpuinfo information, and cores
	 * is possible:
	 * - /proc/cpuinfo reports information for all or some of the cores
	 * below the corresponding "processor : <number>" lines. Information on
	 * offline cores may be missing.
	 * - /proc/cpuinfo reports information only once, after all "processor :
	 * <number>" lines. The reported information may relate to processor #0
	 * or to the processor which executed the system calls to read
	 * /proc/cpuinfo. It is also indistinguishable from /proc/cpuinfo
	 * reporting information only for the last core (e.g. if all other cores
	 * are offline).
	 *
	 * We detect the second case by checking if /proc/cpuinfo contains valid
	 * MIDR only for one, last reported, processor. Note, that the last
	 * reported core may be not the last present & possible processor, as
	 * /proc/cpuinfo may non-report high-index offline cores.
	 */
	if (processors_with_midr_count == 1 && last_processor_in_cpuinfo == last_processor_with_midr &&
	    clusters_count > 1) {
		/*
		 * There are multiple core clusters, but /proc/cpuinfo reported
		 * MIDR only for one processor, and we don't even know which
		 * logical processor this information refers to.
		 *
		 * We make three attempts to detect MIDR for all clusters:
		 * 1. Search tabulated MIDR values for chipsets which have
		 * heterogeneous clusters and ship with Linux kernels which do
		 * not always report all cores in /proc/cpuinfo. If found, use
		 * the tabulated values.
		 * 2. For systems with 2 clusters and MIDR known for one
		 * cluster, assume big.LITTLE configuration, and estimate MIDR
		 * for the other cluster under assumption that MIDR for the big
		 * cluster is known.
		 * 3. Initialize MIDRs for all core clusters to the only parsed
		 * MIDR value.
		 */
		cpuinfo_log_debug("the only reported MIDR can not be attributed to a particular processor");

		if (cpuinfo_arm_linux_detect_cluster_midr_by_chipset(
			    chipset, clusters_count, cluster_leaders, usable_processors, processors, false)) {
			return clusters_count;
		}

		/* Try big.LITTLE heuristic */
		if (cpuinfo_arm_linux_detect_cluster_midr_by_big_little_heuristic(
			    clusters_count, 1, last_processor_with_midr, cluster_leaders, processors, false)) {
			return clusters_count;
		}

		/* Fall back to sequential initialization of MIDR values for
		 * core clusters
		 */
		cpuinfo_arm_linux_detect_cluster_midr_by_sequential_scan(
			processors[processors[last_processor_with_midr].package_leader_id].midr,
			max_processors,
			processors);
	} else if (processors_with_midr_count < usable_processors) {
		/*
		 * /proc/cpuinfo reported MIDR only for some processors, and
		 * probably some core clusters do not have MIDR for any of the
		 * cores. Check if this is the case.
		 */
		uint32_t clusters_with_midr_count = 0;
		for (uint32_t i = 0; i < max_processors; i++) {
			if (bitmask_all(processors[i].flags, CPUINFO_LINUX_FLAG_VALID | CPUINFO_ARM_LINUX_VALID_MIDR)) {
				if (processors[i].package_leader_id == i) {
					clusters_with_midr_count += 1;
				}
			}
		}

		if (clusters_with_midr_count < clusters_count) {
			/*
			 * /proc/cpuinfo reported MIDR only for some clusters,
			 * need to reconstruct others. We make three attempts to
			 * detect MIDR for clusters without it:
			 * 1. Search tabulated MIDR values for chipsets which
			 * have heterogeneous clusters and ship with Linux
			 * kernels which do not always report all cores in
			 * /proc/cpuinfo. If found, use the tabulated values.
			 * 2. For systems with 2 clusters and MIDR known for one
			 * cluster, assume big.LITTLE configuration, and
			 * estimate MIDR for the other cluster under assumption
			 * that MIDR for the big cluster is known.
			 * 3. Initialize MIDRs for core clusters in a single
			 * sequential scan:
			 *    - Clusters preceding the first reported MIDR value
			 * are assumed to have the last reported MIDR value.
			 *    - Clusters following any reported MIDR value to
			 * have that MIDR value.
			 */

			if (cpuinfo_arm_linux_detect_cluster_midr_by_chipset(
				    chipset, clusters_count, cluster_leaders, usable_processors, processors, true)) {
				return clusters_count;
			}

			if (last_processor_with_midr != max_processors) {
				/* Try big.LITTLE heuristic */
				if (cpuinfo_arm_linux_detect_cluster_midr_by_big_little_heuristic(
					    clusters_count,
					    processors_with_midr_count,
					    last_processor_with_midr,
					    cluster_leaders,
					    processors,
					    true)) {
					return clusters_count;
				}

				/* Fall back to sequential initialization of
				 * MIDR values for core clusters */
				cpuinfo_arm_linux_detect_cluster_midr_by_sequential_scan(
					processors[processors[last_processor_with_midr].package_leader_id].midr,
					max_processors,
					processors);
			}
		}
	}
	return clusters_count;
}