| #include <stdbool.h> | |
| #include <stdint.h> | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <arm/linux/api.h> | |
| #ifdef __ANDROID__ | |
| #include <arm/android/api.h> | |
| #endif | |
| #include <cpuinfo/common.h> | |
| #include <cpuinfo/log.h> | |
| static inline bool is_ascii_whitespace(char c) { | |
| switch (c) { | |
| case ' ': | |
| case '\t': | |
| case '\r': | |
| case '\n': | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| static inline bool is_ascii_alphabetic(char c) { | |
| const char lower_c = c | '\x20'; | |
| return (uint8_t)(lower_c - 'a') <= (uint8_t)('z' - 'a'); | |
| } | |
| static inline bool is_ascii_alphabetic_uppercase(char c) { | |
| return (uint8_t)(c - 'A') <= (uint8_t)('Z' - 'A'); | |
| } | |
| static inline bool is_ascii_numeric(char c) { | |
| return (uint8_t)(c - '0') < 10; | |
| } | |
| static inline uint16_t load_u16le(const void* ptr) { | |
| const uint8_t* byte_ptr = (const uint8_t*)ptr; | |
| return ((uint16_t)byte_ptr[1] << 8) | (uint16_t)byte_ptr[0]; | |
| } | |
| static inline uint32_t load_u24le(const void* ptr) { | |
| return ((uint32_t)((const uint8_t*)ptr)[2] << 16) | (uint32_t)load_u16le(ptr); | |
| } | |
| static inline uint32_t load_u32le(const void* ptr) { | |
| const uint8_t* byte_ptr = (const uint8_t*)ptr; | |
| return ((uint32_t)byte_ptr[3] << 24) | ((uint32_t)byte_ptr[2] << 16) | ((uint32_t)byte_ptr[1] << 8) | | |
| (uint32_t)byte_ptr[0]; | |
| } | |
| /* | |
| * Map from ARM chipset series ID to ARM chipset vendor ID. | |
| * This map is used to avoid storing vendor IDs in tables. | |
| */ | |
| static enum cpuinfo_arm_chipset_vendor chipset_series_vendor[cpuinfo_arm_chipset_series_max] = { | |
| [cpuinfo_arm_chipset_series_unknown] = cpuinfo_arm_chipset_vendor_unknown, | |
| [cpuinfo_arm_chipset_series_qualcomm_qsd] = cpuinfo_arm_chipset_vendor_qualcomm, | |
| [cpuinfo_arm_chipset_series_qualcomm_msm] = cpuinfo_arm_chipset_vendor_qualcomm, | |
| [cpuinfo_arm_chipset_series_qualcomm_apq] = cpuinfo_arm_chipset_vendor_qualcomm, | |
| [cpuinfo_arm_chipset_series_qualcomm_snapdragon] = cpuinfo_arm_chipset_vendor_qualcomm, | |
| [cpuinfo_arm_chipset_series_mediatek_mt] = cpuinfo_arm_chipset_vendor_mediatek, | |
| [cpuinfo_arm_chipset_series_samsung_exynos] = cpuinfo_arm_chipset_vendor_samsung, | |
| [cpuinfo_arm_chipset_series_hisilicon_k3v] = cpuinfo_arm_chipset_vendor_hisilicon, | |
| [cpuinfo_arm_chipset_series_hisilicon_hi] = cpuinfo_arm_chipset_vendor_hisilicon, | |
| [cpuinfo_arm_chipset_series_hisilicon_kirin] = cpuinfo_arm_chipset_vendor_hisilicon, | |
| [cpuinfo_arm_chipset_series_actions_atm] = cpuinfo_arm_chipset_vendor_actions, | |
| [cpuinfo_arm_chipset_series_allwinner_a] = cpuinfo_arm_chipset_vendor_allwinner, | |
| [cpuinfo_arm_chipset_series_amlogic_aml] = cpuinfo_arm_chipset_vendor_amlogic, | |
| [cpuinfo_arm_chipset_series_amlogic_s] = cpuinfo_arm_chipset_vendor_amlogic, | |
| [cpuinfo_arm_chipset_series_broadcom_bcm] = cpuinfo_arm_chipset_vendor_broadcom, | |
| [cpuinfo_arm_chipset_series_lg_nuclun] = cpuinfo_arm_chipset_vendor_lg, | |
| [cpuinfo_arm_chipset_series_leadcore_lc] = cpuinfo_arm_chipset_vendor_leadcore, | |
| [cpuinfo_arm_chipset_series_marvell_pxa] = cpuinfo_arm_chipset_vendor_marvell, | |
| [cpuinfo_arm_chipset_series_mstar_6a] = cpuinfo_arm_chipset_vendor_mstar, | |
| [cpuinfo_arm_chipset_series_novathor_u] = cpuinfo_arm_chipset_vendor_novathor, | |
| [cpuinfo_arm_chipset_series_nvidia_tegra_t] = cpuinfo_arm_chipset_vendor_nvidia, | |
| [cpuinfo_arm_chipset_series_nvidia_tegra_ap] = cpuinfo_arm_chipset_vendor_nvidia, | |
| [cpuinfo_arm_chipset_series_nvidia_tegra_sl] = cpuinfo_arm_chipset_vendor_nvidia, | |
| [cpuinfo_arm_chipset_series_pinecone_surge_s] = cpuinfo_arm_chipset_vendor_pinecone, | |
| [cpuinfo_arm_chipset_series_renesas_mp] = cpuinfo_arm_chipset_vendor_renesas, | |
| [cpuinfo_arm_chipset_series_rockchip_rk] = cpuinfo_arm_chipset_vendor_rockchip, | |
| [cpuinfo_arm_chipset_series_spreadtrum_sc] = cpuinfo_arm_chipset_vendor_spreadtrum, | |
| [cpuinfo_arm_chipset_series_telechips_tcc] = cpuinfo_arm_chipset_vendor_telechips, | |
| [cpuinfo_arm_chipset_series_texas_instruments_omap] = cpuinfo_arm_chipset_vendor_texas_instruments, | |
| [cpuinfo_arm_chipset_series_unisoc_t] = cpuinfo_arm_chipset_vendor_unisoc, | |
| [cpuinfo_arm_chipset_series_unisoc_ums] = cpuinfo_arm_chipset_vendor_unisoc, | |
| [cpuinfo_arm_chipset_series_wondermedia_wm] = cpuinfo_arm_chipset_vendor_wondermedia, | |
| }; | |
| /** | |
| * Tries to match /(MSM|APQ)\d{4}([A-Z\-]*)/ signature (case-insensitive) for | |
| * Qualcomm MSM and APQ chipsets. If match successful, extracts model | |
| * information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string, ro.product.board, ro.board.platform or ro.chipname) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string, | |
| * ro.product.board, ro.board.platform or ro.chipname) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_msm_apq(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect at least 7 symbols: 3 symbols "MSM" or "APQ" + 4 digits */ | |
| if (start + 7 > end) { | |
| return false; | |
| } | |
| /* Check that string starts with "MSM" or "APQ", case-insensitive. | |
| * The first three characters are loaded as 24-bit little endian word, | |
| * binary ORed with 0x20 to convert to lower case, and compared to "MSM" | |
| * and "APQ" strings as integers. | |
| */ | |
| const uint32_t series_signature = UINT32_C(0x00202020) | load_u24le(start); | |
| enum cpuinfo_arm_chipset_series series; | |
| switch (series_signature) { | |
| case UINT32_C(0x6D736D): /* "msm" = reverse("msm") */ | |
| series = cpuinfo_arm_chipset_series_qualcomm_msm; | |
| break; | |
| case UINT32_C(0x717061): /* "qpa" = reverse("apq") */ | |
| series = cpuinfo_arm_chipset_series_qualcomm_apq; | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Sometimes there is a space ' ' following the MSM/APQ series */ | |
| const char* pos = start + 3; | |
| if (*pos == ' ') { | |
| pos++; | |
| /* Expect at least 4 more symbols (4-digit model number) */ | |
| if (pos + 4 > end) { | |
| return false; | |
| } | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 0; i < 4; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)(*pos++) - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Suffix is optional, so if we got to this point, parsing is | |
| * successful. Commit parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_qualcomm, | |
| .series = series, | |
| .model = model, | |
| }; | |
| /* Parse as many suffix characters as match the pattern [A-Za-z\-] */ | |
| for (uint32_t i = 0; i < CPUINFO_ARM_CHIPSET_SUFFIX_MAX; i++) { | |
| if (pos + i == end) { | |
| break; | |
| } | |
| const char c = pos[i]; | |
| if (is_ascii_alphabetic(c)) { | |
| /* Matched a letter [A-Za-z] */ | |
| chipset->suffix[i] = c & '\xDF'; | |
| } else if (c == '-') { | |
| /* Matched a dash '-' */ | |
| chipset->suffix[i] = c; | |
| } else { | |
| /* Neither of [A-Za-z\-] */ | |
| break; | |
| } | |
| } | |
| return true; | |
| } | |
| /** | |
| * Tries to match /SDM\d{3}$/ signature for Qualcomm Snapdragon chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_sdm(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 6 symbols: 3 symbols "SDM" + 3 digits */ | |
| if (start + 6 != end) { | |
| return false; | |
| } | |
| /* Check that string starts with "SDM". | |
| * The first three characters are loaded and compared as 24-bit little | |
| * endian word. | |
| */ | |
| const uint32_t expected_sdm = load_u24le(start); | |
| if (expected_sdm != UINT32_C(0x004D4453) /* "MDS" = reverse("SDM") */) { | |
| return false; | |
| } | |
| /* Validate and parse 3-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 3; i < 6; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_qualcomm, | |
| .series = cpuinfo_arm_chipset_series_qualcomm_snapdragon, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /SM\d{4}$/ signature for Qualcomm Snapdragon chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_sm(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 6 symbols: 2 symbols "SM" + 4 digits */ | |
| if (start + 6 != end) { | |
| return false; | |
| } | |
| /* Check that string starts with "SM". | |
| * The first three characters are loaded and compared as 16-bit little | |
| * endian word. | |
| */ | |
| const uint32_t expected_sm = load_u16le(start); | |
| if (expected_sm != UINT16_C(0x4D53) /* "MS" = reverse("SM") */) { | |
| return false; | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 2; i < 6; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_qualcomm, | |
| .series = cpuinfo_arm_chipset_series_qualcomm_sm, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /Samsung Exynos\d{4}$/ signature (case-insensitive) for | |
| * Samsung Exynos chipsets. If match successful, extracts model information into | |
| * \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_samsung_exynos( | |
| const char* start, | |
| const char* end, | |
| struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* | |
| * Expect at 18-19 symbols: | |
| * - "Samsung" (7 symbols) + space + "Exynos" (6 symbols) + optional | |
| * space 4-digit model number | |
| */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 18: | |
| case 19: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* | |
| * Check that the string starts with "samsung exynos", case-insensitive. | |
| * Blocks of 4 characters are loaded and compared as little-endian | |
| * 32-bit word. Case-insensitive characters are binary ORed with 0x20 to | |
| * convert them to lowercase. | |
| */ | |
| const uint32_t expected_sams = UINT32_C(0x20202000) | load_u32le(start); | |
| if (expected_sams != UINT32_C(0x736D6153) /* "smaS" = reverse("Sams") */) { | |
| return false; | |
| } | |
| const uint32_t expected_ung = UINT32_C(0x00202020) | load_u32le(start + 4); | |
| if (expected_ung != UINT32_C(0x20676E75) /* " ung" = reverse("ung ") */) { | |
| return false; | |
| } | |
| const uint32_t expected_exyn = UINT32_C(0x20202000) | load_u32le(start + 8); | |
| if (expected_exyn != UINT32_C(0x6E797845) /* "nyxE" = reverse("Exyn") */) { | |
| return false; | |
| } | |
| const uint16_t expected_os = UINT16_C(0x2020) | load_u16le(start + 12); | |
| if (expected_os != UINT16_C(0x736F) /* "so" = reverse("os") */) { | |
| return false; | |
| } | |
| const char* pos = start + 14; | |
| /* There can be a space ' ' following the "Exynos" string */ | |
| if (*pos == ' ') { | |
| pos++; | |
| /* If optional space if present, we expect exactly 19 characters | |
| */ | |
| if (length != 19) { | |
| return false; | |
| } | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 0; i < 4; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)(*pos++) - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_samsung, | |
| .series = cpuinfo_arm_chipset_series_samsung_exynos, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /exynos\d{4}$/ signature for Samsung Exynos chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (ro.board.platform or | |
| * ro.chipname) to match. | |
| * @param end - end of the platform identifier (ro.board.platform or | |
| * ro.chipname) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_exynos(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 10 symbols: "exynos" (6 symbols) + 4-digit model | |
| * number */ | |
| if (start + 10 != end) { | |
| return false; | |
| } | |
| /* Load first 4 bytes as little endian 32-bit word */ | |
| const uint32_t expected_exyn = load_u32le(start); | |
| if (expected_exyn != UINT32_C(0x6E797865) /* "nyxe" = reverse("exyn") */) { | |
| return false; | |
| } | |
| /* Load next 2 bytes as little endian 16-bit word */ | |
| const uint16_t expected_os = load_u16le(start + 4); | |
| if (expected_os != UINT16_C(0x736F) /* "so" = reverse("os") */) { | |
| return false; | |
| } | |
| /* Check and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 6; i < 10; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_samsung, | |
| .series = cpuinfo_arm_chipset_series_samsung_exynos, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /universal\d{4}$/ signature for Samsung Exynos chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string, ro.product.board or ro.chipname) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string, | |
| * ro.product.board or ro.chipname) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_universal(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 13 symbols: "universal" (9 symbols) + 4-digit model | |
| * number | |
| */ | |
| if (start + 13 != end) { | |
| return false; | |
| } | |
| /* | |
| * Check that the string starts with "universal". | |
| * Blocks of 4 characters are loaded and compared as little-endian | |
| * 32-bit word. Case-insensitive characters are binary ORed with 0x20 to | |
| * convert them to lowercase. | |
| */ | |
| const uint8_t expected_u = UINT8_C(0x20) | (uint8_t)start[0]; | |
| if (expected_u != UINT8_C(0x75) /* "u" */) { | |
| return false; | |
| } | |
| const uint32_t expected_nive = UINT32_C(0x20202020) | load_u32le(start + 1); | |
| if (expected_nive != UINT32_C(0x6576696E) /* "evin" = reverse("nive") */) { | |
| return false; | |
| } | |
| const uint32_t expected_ersa = UINT32_C(0x20202020) | load_u32le(start + 5); | |
| if (expected_ersa != UINT32_C(0x6C617372) /* "lasr" = reverse("rsal") */) { | |
| return false; | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 9; i < 13; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_samsung, | |
| .series = cpuinfo_arm_chipset_series_samsung_exynos, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /s5e\d{4}$/ signature for Samsung Exynos chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (ro.product.board or | |
| * ro.board.platform) to match. | |
| * @param end - end of the platform identifier (ro.product.board or | |
| * ro.board.platform) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_s5e(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 7 symbols: "s5e" (3 symbols) + 4-digit model number */ | |
| if (start + 7 != end) { | |
| return false; | |
| } | |
| /* Check that string starts with "s5e" */ | |
| if (start[0] != 's') { | |
| return false; | |
| } | |
| /* Load next 2 bytes as little endian 16-bit word */ | |
| const uint16_t expected_5e = load_u16le(start + 1); | |
| if (expected_5e != UINT16_C(0x6535) /* "e5" = reverse("5e") */) { | |
| return false; | |
| } | |
| /* Check and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 3; i < 7; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_samsung, | |
| .series = cpuinfo_arm_chipset_series_samsung_exynos, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Compares, case insensitively, a string to known values "SMDK4210" and | |
| * "SMDK4x12" for Samsung Exynos chipsets. If platform identifier matches one of | |
| * the SMDK* values, extracts model information into \p chipset argument. For | |
| * "SMDK4x12" match, decodes the chipset name using number of cores. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string or ro.product.board) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string or | |
| * ro.product.board) to match. | |
| * @param cores - number of cores in the chipset. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_and_parse_smdk( | |
| const char* start, | |
| const char* end, | |
| uint32_t cores, | |
| struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 8 symbols: "SMDK" (4 symbols) + 4-digit model number | |
| */ | |
| if (start + 8 != end) { | |
| return false; | |
| } | |
| /* | |
| * Check that string starts with "MT" (case-insensitive). | |
| * The first four characters are loaded as a 32-bit little endian word | |
| * and converted to lowercase. | |
| */ | |
| const uint32_t expected_smdk = UINT32_C(0x20202020) | load_u32le(start); | |
| if (expected_smdk != UINT32_C(0x6B646D73) /* "kdms" = reverse("smdk") */) { | |
| return false; | |
| } | |
| /* | |
| * Check that string ends with "4210" or "4x12". | |
| * The last four characters are loaded and compared as a 32-bit little | |
| * endian word. | |
| */ | |
| uint32_t model = 0; | |
| const uint32_t expected_model = load_u32le(start + 4); | |
| switch (expected_model) { | |
| case UINT32_C(0x30313234): /* "0124" = reverse("4210") */ | |
| model = 4210; | |
| break; | |
| case UINT32_C(0x32317834): /* "21x4" = reverse("4x12") */ | |
| switch (cores) { | |
| case 2: | |
| model = 4212; | |
| break; | |
| case 4: | |
| model = 4412; | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 "-core Exynos 4x12 chipset", cores); | |
| } | |
| } | |
| if (model == 0) { | |
| return false; | |
| } | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_samsung, | |
| .series = cpuinfo_arm_chipset_series_samsung_exynos, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /MTK?\d{4}[A-Z/]*$/ signature for MediaTek MT chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string, ro.product.board, ro.board.platform, ro.mediatek.platform, or | |
| * ro.chipname) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string, | |
| * ro.product.board, ro.board.platform, ro.mediatek.platform, or ro.chipname) to | |
| * match. | |
| * @param match_end - indicates if the function should attempt to match through | |
| * the end of the string and fail if there are unparsed characters in the end, | |
| * or match only MTK signature, model number, and some of the suffix characters | |
| * (the ones that pass validation). | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_mt( | |
| const char* start, | |
| const char* end, | |
| bool match_end, | |
| struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect at least 6 symbols: "MT" (2 symbols) + 4-digit model number */ | |
| if (start + 6 > end) { | |
| return false; | |
| } | |
| /* | |
| * Check that string starts with "MT" (case-insensitive). | |
| * The first two characters are loaded as 16-bit little endian word and | |
| * converted to lowercase. | |
| */ | |
| const uint16_t mt = UINT16_C(0x2020) | load_u16le(start); | |
| if (mt != UINT16_C(0x746D) /* "tm" */) { | |
| return false; | |
| } | |
| /* Some images report "MTK" rather than "MT" */ | |
| const char* pos = start + 2; | |
| if (((uint8_t)*pos | UINT8_C(0x20)) == (uint8_t)'k') { | |
| pos++; | |
| /* Expect 4 more symbols after "MTK" (4-digit model number) */ | |
| if (pos + 4 > end) { | |
| return false; | |
| } | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 0; i < 4; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)(*pos++) - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Record parsed chipset. This implicitly zeroes-out suffix, which will | |
| * be parsed later. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_mediatek, | |
| .series = cpuinfo_arm_chipset_series_mediatek_mt, | |
| .model = model, | |
| }; | |
| if (match_end) { | |
| /* Check that the potential suffix does not exceed maximum | |
| * length */ | |
| const size_t suffix_length = end - pos; | |
| if (suffix_length > CPUINFO_ARM_CHIPSET_SUFFIX_MAX) { | |
| return false; | |
| } | |
| /* Validate suffix characters and copy them to chipset structure | |
| */ | |
| for (size_t i = 0; i < suffix_length; i++) { | |
| const char c = (*pos++); | |
| if (is_ascii_alphabetic(c)) { | |
| /* Matched a letter [A-Za-z], convert to | |
| * uppercase */ | |
| chipset->suffix[i] = c & '\xDF'; | |
| } else if (c == '/') { | |
| /* Matched a slash '/' */ | |
| chipset->suffix[i] = c; | |
| } else { | |
| /* Invalid suffix character (neither of | |
| * [A-Za-z/]) */ | |
| return false; | |
| } | |
| } | |
| } else { | |
| /* Validate and parse as many suffix characters as we can */ | |
| for (size_t i = 0; i < CPUINFO_ARM_CHIPSET_SUFFIX_MAX; i++) { | |
| if (pos + i == end) { | |
| break; | |
| } | |
| const char c = pos[i]; | |
| if (is_ascii_alphabetic(c)) { | |
| /* Matched a letter [A-Za-z], convert to | |
| * uppercase */ | |
| chipset->suffix[i] = c & '\xDF'; | |
| } else if (c == '/') { | |
| /* Matched a slash '/' */ | |
| chipset->suffix[i] = c; | |
| } else { | |
| /* Invalid suffix character (neither of | |
| * [A-Za-z/]). This marks the end of the suffix. | |
| */ | |
| break; | |
| } | |
| } | |
| } | |
| /* All suffix characters successfully validated and copied to chipset | |
| * data */ | |
| return true; | |
| } | |
| /** | |
| * Tries to match /[Kk]irin\s?\d{3}$/ signature for HiSilicon Kirin chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_kirin(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect 8-9 symbols: "Kirin" (5 symbols) + optional whitespace (1 | |
| * symbol) + 3-digit model number */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 8: | |
| case 9: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Check that the string starts with "Kirin" or "kirin". */ | |
| if (((uint8_t)start[0] | UINT8_C(0x20)) != (uint8_t)'k') { | |
| return false; | |
| } | |
| /* Symbols 1-5 are loaded and compared as little-endian 32-bit word. */ | |
| const uint32_t irin = load_u32le(start + 1); | |
| if (irin != UINT32_C(0x6E697269) /* "niri" = reverse("irin") */) { | |
| return false; | |
| } | |
| /* Check for optional whitespace after "Kirin" */ | |
| if (is_ascii_whitespace(start[5])) { | |
| /* When whitespace is present after "Kirin", expect 9 symbols | |
| * total */ | |
| if (length != 9) { | |
| return false; | |
| } | |
| } | |
| /* Validate and parse 3-digit model number */ | |
| uint32_t model = 0; | |
| for (int32_t i = 0; i < 3; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)end[i - 3] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* | |
| * Thats it, return parsed chipset. | |
| * Technically, Kirin 910T has a suffix, but it never appears in the | |
| * form of "910T" string. Instead, Kirin 910T devices report "hi6620oem" | |
| * string (handled outside of this function). | |
| */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_hisilicon, | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /rk\d{4}[a-z]?$/ signature for Rockchip RK chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string or ro.board.platform) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string or | |
| * ro.board.platform) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_rk(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect 6-7 symbols: "RK" (2 symbols) + 4-digit model number + | |
| * optional 1-letter suffix */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 6: | |
| case 7: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* | |
| * Check that string starts with "RK" (case-insensitive). | |
| * The first two characters are loaded as 16-bit little endian word and | |
| * converted to lowercase. | |
| */ | |
| const uint16_t expected_rk = UINT16_C(0x2020) | load_u16le(start); | |
| if (expected_rk != UINT16_C(0x6B72) /* "kr" = reverse("rk") */) { | |
| return false; | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 2; i < 6; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Parse optional suffix */ | |
| char suffix = 0; | |
| if (length == 7) { | |
| /* Parse the suffix letter */ | |
| const char c = start[6]; | |
| if (is_ascii_alphabetic(c)) { | |
| /* Convert to upper case */ | |
| suffix = c & '\xDF'; | |
| } else { | |
| /* Invalid suffix character */ | |
| return false; | |
| } | |
| } | |
| /* Return parsed chipset */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_rockchip, | |
| .series = cpuinfo_arm_chipset_series_rockchip_rk, | |
| .model = model, | |
| .suffix = | |
| { | |
| [0] = suffix, | |
| }, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match, case-insentitively, /s[cp]\d{4}[a-z]*|scx15$/ signature for | |
| * Spreadtrum SC chipsets. If match successful, extracts model information into | |
| * \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string, ro.product.board, ro.board.platform, or ro.chipname) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string, | |
| * ro.product.board, ro.board.platform, or ro.chipname) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_sc(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect at least 5 symbols: "scx15" */ | |
| if (start + 5 > end) { | |
| return false; | |
| } | |
| /* | |
| * Check that string starts with "S[CP]" (case-insensitive). | |
| * The first two characters are loaded as 16-bit little endian word and | |
| * converted to lowercase. | |
| */ | |
| const uint16_t expected_sc_or_sp = UINT16_C(0x2020) | load_u16le(start); | |
| switch (expected_sc_or_sp) { | |
| case UINT16_C(0x6373): /* "cs" = reverse("sc") */ | |
| case UINT16_C(0x7073): /* "ps" = reverse("sp") */ | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Special case: "scx" prefix (SC7715 reported as "scx15") */ | |
| if ((start[2] | '\x20') == 'x') { | |
| /* Expect exactly 5 characters: "scx15" */ | |
| if (start + 5 != end) { | |
| return false; | |
| } | |
| /* Check that string ends with "15" */ | |
| const uint16_t expected_15 = load_u16le(start + 3); | |
| if (expected_15 != UINT16_C(0x3531) /* "51" = reverse("15") */) { | |
| return false; | |
| } | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_spreadtrum, | |
| .series = cpuinfo_arm_chipset_series_spreadtrum_sc, | |
| .model = 7715, | |
| }; | |
| return true; | |
| } | |
| /* Expect at least 6 symbols: "S[CP]" (2 symbols) + 4-digit model number | |
| */ | |
| if (start + 6 > end) { | |
| return false; | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 2; i < 6; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Write parsed chipset */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_spreadtrum, | |
| .series = cpuinfo_arm_chipset_series_spreadtrum_sc, | |
| .model = model, | |
| }; | |
| /* Validate and copy suffix letters. If suffix is too long, truncate at | |
| * CPUINFO_ARM_CHIPSET_SUFFIX_MAX letters. */ | |
| const char* suffix = start + 6; | |
| for (size_t i = 0; i < CPUINFO_ARM_CHIPSET_SUFFIX_MAX; i++) { | |
| if (suffix + i == end) { | |
| break; | |
| } | |
| const char c = suffix[i]; | |
| if (!is_ascii_alphabetic(c)) { | |
| /* Invalid suffix character */ | |
| return false; | |
| } | |
| /* Convert suffix letter to uppercase */ | |
| chipset->suffix[i] = c & '\xDF'; | |
| } | |
| return true; | |
| } | |
| /** | |
| * Tries to match, case-sentitively, /Unisoc T\d{3,4}/ or /UNISOC T\d{3,4}/ signature for Unisoc T | |
| * chipset. If match successful, extracts model information into \p chipset | |
| * argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string, ro.product.board, ro.board.platform, or ro.chipname) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string, | |
| * ro.product.board, ro.board.platform, or ro.chipname) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_t(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect 11-12 symbols: "Unisoc T" / "UNISOC T" (8 symbols) + 3-4-digit model number | |
| */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 11: | |
| case 12: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Check that string starts with "Unisoc T" or "UNISOC T". The first four characters | |
| * are loaded as 32-bit little endian word */ | |
| const uint32_t expected_unis = load_u32le(start); | |
| if (expected_unis != UINT32_C(0x73696E55) /* "sinU" = reverse("Unis") */ && | |
| expected_unis != UINT32_C(0x53494E55) /* "SINU" = reverse("UNIS") */) { | |
| return false; | |
| } | |
| /* The next four characters are loaded as 32-bit little endian word */ | |
| const uint32_t expected_oc_t = load_u32le(start + 4); | |
| if (expected_oc_t != UINT32_C(0x5420636F) /* "T co" = reverse("oc T") */ && | |
| expected_oc_t != UINT32_C(0x5420434F) /* "T CO" = reverse("OC T") */) { | |
| return false; | |
| } | |
| /* Validate and parse 3-4 digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 8; i < length; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unisoc, | |
| .series = cpuinfo_arm_chipset_series_unisoc_t, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match, case-sentitively, /Unisoc UMS\d{3,4}/ signature for Unisoc UMS | |
| * chipset. If match successful, extracts model information into \p chipset | |
| * argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string, ro.product.board, ro.board.platform, or ro.chipname) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardware string, | |
| * ro.product.board, ro.board.platform, or ro.chipname) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_ums(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect 13-14 symbols: "Unisoc UMS" (10 symbols) + 3-4-digit model number | |
| */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 13: | |
| case 14: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Check that string starts with "Unisoc UMS". The first four characters | |
| * are loaded as 32-bit little endian word */ | |
| const uint32_t expected_unis = load_u32le(start); | |
| if (expected_unis != UINT32_C(0x73696E55) /* "sinU" = reverse("Unis") */) { | |
| return false; | |
| } | |
| /* The next four characters are loaded as 32-bit little endian word */ | |
| const uint32_t expected_oc_u = load_u32le(start + 4); | |
| if (expected_oc_u != UINT32_C(0x5520636F) /* "U co" = reverse("oc U") */) { | |
| return false; | |
| } | |
| /* The next four characters are loaded as 16-bit little endian word */ | |
| const uint16_t expected_ms = load_u16le(start + 8); | |
| if (expected_ms != UINT16_C(0x534D) /* "SM" = reverse("MS") */) { | |
| return false; | |
| } | |
| /* Validate and parse 3-4 digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 10; i < length; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unisoc, | |
| .series = cpuinfo_arm_chipset_series_unisoc_ums, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /lc\d{4}[a-z]?$/ signature for Leadcore LC chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (ro.product.board or | |
| * ro.board.platform) to match. | |
| * @param end - end of the platform identifier (ro.product.board or | |
| * ro.board.platform) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_lc(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect 6-7 symbols: "lc" (2 symbols) + 4-digit model number + | |
| * optional 1-letter suffix */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 6: | |
| case 7: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Check that string starts with "lc". The first two characters are | |
| * loaded as 16-bit little endian word */ | |
| const uint16_t expected_lc = load_u16le(start); | |
| if (expected_lc != UINT16_C(0x636C) /* "cl" = reverse("lc") */) { | |
| return false; | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 2; i < 6; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Parse optional suffix letter */ | |
| char suffix = 0; | |
| if (length == 7) { | |
| const char c = start[6]; | |
| if (is_ascii_alphabetic(c)) { | |
| /* Convert to uppercase */ | |
| chipset->suffix[0] = c & '\xDF'; | |
| } else { | |
| /* Invalid suffix character */ | |
| return false; | |
| } | |
| } | |
| /* Return parsed chipset */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_leadcore, | |
| .series = cpuinfo_arm_chipset_series_leadcore_lc, | |
| .model = model, | |
| .suffix = | |
| { | |
| [0] = suffix, | |
| }, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /PXA(\d{3,4}|1L88)$/ signature for Marvell PXA chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (/proc/cpuinfo Hardware | |
| * string, ro.product.board or ro.chipname) to match. | |
| * @param end - end of the platform identifier (/proc/cpuinfo Hardaware string, | |
| * ro.product.board or ro.chipname) to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_pxa(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect 6-7 symbols: "PXA" (3 symbols) + 3-4 digit model number */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 6: | |
| case 7: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Check that the string starts with "PXA". Symbols 1-3 are loaded and | |
| * compared as little-endian 16-bit word. */ | |
| if (start[0] != 'P') { | |
| return false; | |
| } | |
| const uint16_t expected_xa = load_u16le(start + 1); | |
| if (expected_xa != UINT16_C(0x4158) /* "AX" = reverse("XA") */) { | |
| return false; | |
| } | |
| uint32_t model = 0; | |
| /* Check for a very common typo: "PXA1L88" for "PXA1088" */ | |
| if (length == 7) { | |
| /* Load 4 model "number" symbols as a little endian 32-bit word | |
| * and compare to "1L88" */ | |
| const uint32_t expected_1L88 = load_u32le(start + 3); | |
| if (expected_1L88 == UINT32_C(0x38384C31) /* "88L1" = reverse("1L88") */) { | |
| model = 1088; | |
| goto write_chipset; | |
| } | |
| } | |
| /* Check and parse 3-4 digit model number */ | |
| for (uint32_t i = 3; i < length; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| write_chipset: | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_marvell, | |
| .series = cpuinfo_arm_chipset_series_marvell_pxa, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /BCM\d{4}$/ signature for Broadcom BCM chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_bcm(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 7 symbols: "BCM" (3 symbols) + 4-digit model number */ | |
| if (start + 7 != end) { | |
| return false; | |
| } | |
| /* Check that the string starts with "BCM". | |
| * The first three characters are loaded and compared as a 24-bit little | |
| * endian word. | |
| */ | |
| const uint32_t expected_bcm = load_u24le(start); | |
| if (expected_bcm != UINT32_C(0x004D4342) /* "MCB" = reverse("BCM") */) { | |
| return false; | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 3; i < 7; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_broadcom, | |
| .series = cpuinfo_arm_chipset_series_broadcom_bcm, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /OMAP\d{4}$/ signature for Texas Instruments OMAP chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_omap(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 8 symbols: "OMAP" (4 symbols) + 4-digit model number | |
| */ | |
| if (start + 8 != end) { | |
| return false; | |
| } | |
| /* Check that the string starts with "OMAP". Symbols 0-4 are loaded and | |
| * compared as little-endian 32-bit word. */ | |
| const uint32_t expected_omap = load_u32le(start); | |
| if (expected_omap != UINT32_C(0x50414D4F) /* "PAMO" = reverse("OMAP") */) { | |
| return false; | |
| } | |
| /* Validate and parse 4-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 4; i < 8; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Return parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_texas_instruments, | |
| .series = cpuinfo_arm_chipset_series_texas_instruments_omap, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Compares platform identifier string to known values for Broadcom chipsets. | |
| * If the string matches one of the known values, the function decodes Broadcom | |
| * chipset from frequency and number of cores into \p chipset argument. | |
| * | |
| * @param start - start of the platform identifier (ro.product.board or | |
| * ro.board.platform) to match. | |
| * @param end - end of the platform identifier (ro.product.board or | |
| * ro.board.platform) to match. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match and decoding. | |
| * | |
| * @returns true if signature matched (even if exact model can't be decoded), | |
| * false otherwise. | |
| */ | |
| static bool match_and_parse_broadcom( | |
| const char* start, | |
| const char* end, | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max, | |
| struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect 4-6 symbols: "java" (4 symbols), "rhea" (4 symbols), "capri" | |
| * (5 symbols), or "hawaii" (6 symbols) */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 4: | |
| case 5: | |
| case 6: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* | |
| * Compare the platform identifier to known values for Broadcom | |
| * chipsets: | |
| * - "rhea" | |
| * - "java" | |
| * - "capri" | |
| * - "hawaii" | |
| * Upon a successful match, decode chipset name from frequency and | |
| * number of cores. | |
| */ | |
| uint32_t model = 0; | |
| char suffix = 0; | |
| const uint32_t expected_platform = load_u32le(start); | |
| switch (expected_platform) { | |
| case UINT32_C(0x61656872): /* "aehr" = reverse("rhea") */ | |
| if (length == 4) { | |
| /* | |
| * Detected "rhea" platform: | |
| * - 1 core @ 849999 KHz -> BCM21654 | |
| * - 1 core @ 999999 KHz -> BCM21654G | |
| */ | |
| if (cores == 1) { | |
| model = 21654; | |
| if (max_cpu_freq_max >= 999999) { | |
| suffix = 'G'; | |
| } | |
| } | |
| } | |
| break; | |
| case UINT32_C(0x6176616A): /* "avaj" = reverse("java") */ | |
| if (length == 4) { | |
| /* | |
| * Detected "java" platform: | |
| * - 4 cores -> BCM23550 | |
| */ | |
| if (cores == 4) { | |
| model = 23550; | |
| } | |
| } | |
| break; | |
| case UINT32_C(0x61776168): /* "awah" = reverse("hawa") */ | |
| if (length == 6) { | |
| /* Check that string equals "hawaii" */ | |
| const uint16_t expected_ii = load_u16le(start + 4); | |
| if (expected_ii == UINT16_C(0x6969) /* "ii" */) { | |
| /* | |
| * Detected "hawaii" platform: | |
| * - 1 core -> BCM21663 | |
| * - 2 cores @ 999999 KHz -> BCM21664 | |
| * - 2 cores @ 1200000 KHz -> BCM21664T | |
| */ | |
| switch (cores) { | |
| case 1: | |
| model = 21663; | |
| break; | |
| case 2: | |
| model = 21664; | |
| if (max_cpu_freq_max >= 1200000) { | |
| suffix = 'T'; | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| break; | |
| case UINT32_C(0x72706163): /* "rpac" = reverse("capr") */ | |
| if (length == 5) { | |
| /* Check that string equals "capri" */ | |
| if (start[4] == 'i') { | |
| /* | |
| * Detected "capri" platform: | |
| * - 2 cores -> BCM28155 | |
| */ | |
| if (cores == 2) { | |
| model = 28155; | |
| } | |
| } | |
| } | |
| break; | |
| } | |
| if (model != 0) { | |
| /* Chipset was successfully decoded */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_broadcom, | |
| .series = cpuinfo_arm_chipset_series_broadcom_bcm, | |
| .model = model, | |
| .suffix = | |
| { | |
| [0] = suffix, | |
| }, | |
| }; | |
| } | |
| return model != 0; | |
| } | |
| struct sunxi_map_entry { | |
| uint8_t sunxi; | |
| uint8_t cores; | |
| uint8_t model; | |
| char suffix; | |
| }; | |
| static const struct sunxi_map_entry sunxi_map_entries[] = { | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* ("sun4i", 1) -> "A10" */ | |
| .sunxi = 4, | |
| .cores = 1, | |
| .model = 10, | |
| }, | |
| { | |
| /* ("sun5i", 1) -> "A13" */ | |
| .sunxi = 5, | |
| .cores = 1, | |
| .model = 13, | |
| }, | |
| { | |
| /* ("sun6i", 4) -> "A31" */ | |
| .sunxi = 6, | |
| .cores = 4, | |
| .model = 31, | |
| }, | |
| { | |
| /* ("sun7i", 2) -> "A20" */ | |
| .sunxi = 7, | |
| .cores = 2, | |
| .model = 20, | |
| }, | |
| { | |
| /* ("sun8i", 2) -> "A23" */ | |
| .sunxi = 8, | |
| .cores = 2, | |
| .model = 23, | |
| }, | |
| { | |
| /* ("sun8i", 4) -> "A33" */ | |
| .sunxi = 8, | |
| .cores = 4, | |
| .model = 33, | |
| }, | |
| { | |
| /* ("sun8i", 8) -> "A83T" */ | |
| .sunxi = 8, | |
| .cores = 8, | |
| .model = 83, | |
| .suffix = 'T', | |
| }, | |
| { | |
| /* ("sun9i", 8) -> "A80" */ | |
| .sunxi = 9, | |
| .cores = 8, | |
| .model = 80, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* ("sun50i", 4) -> "A64" */ | |
| .sunxi = 50, | |
| .cores = 4, | |
| .model = 64, | |
| }, | |
| }; | |
| /** | |
| * Tries to match /proc/cpuinfo Hardware string to Allwinner /sun\d+i/ | |
| * signature. If the string matches signature, the function decodes Allwinner | |
| * chipset from the number in the signature and the number of cores, and stores | |
| * it in \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param cores - number of cores in the chipset. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match and decoding. | |
| * | |
| * @returns true if signature matched (even if exact model can't be decoded), | |
| * false otherwise. | |
| */ | |
| static bool match_and_parse_sunxi( | |
| const char* start, | |
| const char* end, | |
| uint32_t cores, | |
| struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect at least 5 symbols: "sun" (3 symbols) + platform id (1-2 | |
| * digits) + "i" (1 symbol) */ | |
| if (start + 5 > end) { | |
| return false; | |
| } | |
| /* Compare the first 3 characters to "sun" */ | |
| if (start[0] != 's') { | |
| return false; | |
| } | |
| const uint16_t expected_un = load_u16le(start + 1); | |
| if (expected_un != UINT16_C(0x6E75) /* "nu" = reverse("un") */) { | |
| return false; | |
| } | |
| /* Check and parse the first (required) digit of the sunXi platform id | |
| */ | |
| uint32_t sunxi_platform = 0; | |
| { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[3] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| sunxi_platform = digit; | |
| } | |
| /* Parse optional second digit of the sunXi platform id */ | |
| const char* pos = start + 4; | |
| { | |
| const uint32_t digit = (uint32_t)(uint8_t)(*pos) - '0'; | |
| if (digit < 10) { | |
| sunxi_platform = sunxi_platform * 10 + digit; | |
| if (++pos == end) { | |
| /* Expected one more character, final 'i' letter | |
| */ | |
| return false; | |
| } | |
| } | |
| } | |
| /* Validate the final 'i' letter */ | |
| if (*pos != 'i') { | |
| return false; | |
| } | |
| /* Compare sunXi platform id and number of cores to tabulated values to | |
| * decode chipset name */ | |
| uint32_t model = 0; | |
| char suffix = 0; | |
| for (size_t i = 0; i < CPUINFO_COUNT_OF(sunxi_map_entries); i++) { | |
| if (sunxi_platform == sunxi_map_entries[i].sunxi && cores == sunxi_map_entries[i].cores) { | |
| model = sunxi_map_entries[i].model; | |
| suffix = sunxi_map_entries[i].suffix; | |
| break; | |
| } | |
| } | |
| if (model == 0) { | |
| cpuinfo_log_info( | |
| "unrecognized %" PRIu32 "-core Allwinner sun%" PRIu32 " platform", cores, sunxi_platform); | |
| } | |
| /* Create chipset name from decoded data */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_allwinner, | |
| .series = cpuinfo_arm_chipset_series_allwinner_a, | |
| .model = model, | |
| .suffix = | |
| { | |
| [0] = suffix, | |
| }, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Compares /proc/cpuinfo Hardware string to "WMT" signature. | |
| * If the string matches signature, the function decodes WonderMedia chipset | |
| * from frequency and number of cores into \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match and decoding. | |
| * | |
| * @returns true if signature matched (even if exact model can't be decoded), | |
| * false otherwise. | |
| */ | |
| static bool match_and_parse_wmt( | |
| const char* start, | |
| const char* end, | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max, | |
| struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expected 3 symbols: "WMT" */ | |
| if (start + 3 != end) { | |
| return false; | |
| } | |
| /* Compare string to "WMT" */ | |
| if (start[0] != 'W') { | |
| return false; | |
| } | |
| const uint16_t expected_mt = load_u16le(start + 1); | |
| if (expected_mt != UINT16_C(0x544D) /* "TM" = reverse("MT") */) { | |
| return false; | |
| } | |
| /* Decode chipset name from frequency and number of cores */ | |
| uint32_t model = 0; | |
| switch (cores) { | |
| case 1: | |
| switch (max_cpu_freq_max) { | |
| case 1008000: | |
| /* 1 core @ 1008000 KHz -> WM8950 */ | |
| model = 8950; | |
| break; | |
| case 1200000: | |
| /* 1 core @ 1200000 KHz -> WM8850 */ | |
| model = 8850; | |
| break; | |
| } | |
| break; | |
| case 2: | |
| if (max_cpu_freq_max == 1500000) { | |
| /* 2 cores @ 1500000 KHz -> WM8880 */ | |
| model = 8880; | |
| } | |
| break; | |
| } | |
| if (model == 0) { | |
| cpuinfo_log_info( | |
| "unrecognized WonderMedia platform with %" PRIu32 " cores at %" PRIu32 " KHz", | |
| cores, | |
| max_cpu_freq_max); | |
| } | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_wondermedia, | |
| .series = cpuinfo_arm_chipset_series_wondermedia_wm, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| struct huawei_map_entry { | |
| uint32_t platform; | |
| uint32_t model; | |
| }; | |
| static const struct huawei_map_entry huawei_platform_map[] = { | |
| { | |
| /* "ALP" -> Kirin 970 */ | |
| .platform = UINT32_C(0x00504C41), /* "\0PLA" = reverse("ALP\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "BAC" -> Kirin 659 */ | |
| .platform = UINT32_C(0x00434142), /* "\0CAB" = reverse("BAC\0") */ | |
| .model = 659, | |
| }, | |
| { | |
| /* "BLA" -> Kirin 970 */ | |
| .platform = UINT32_C(0x00414C42), /* "\0ALB" = reverse("BLA\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "BKL" -> Kirin 970 */ | |
| .platform = UINT32_C(0x004C4B42), /* "\0LKB" = reverse("BKL\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "CLT" -> Kirin 970 */ | |
| .platform = UINT32_C(0x00544C43), /* "\0TLC" = reverse("CLT\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "COL" -> Kirin 970 */ | |
| .platform = UINT32_C(0x004C4F43), /* "\0LOC" = reverse("COL\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "COR" -> Kirin 970 */ | |
| .platform = UINT32_C(0x00524F43), /* "\0ROC" = reverse("COR\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "DUK" -> Kirin 960 */ | |
| .platform = UINT32_C(0x004B5544), /* "\0KUD" = reverse("DUK\0") */ | |
| .model = 960, | |
| }, | |
| { | |
| /* "EML" -> Kirin 970 */ | |
| .platform = UINT32_C(0x004C4D45), /* "\0LME" = reverse("EML\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "EVA" -> Kirin 955 */ | |
| .platform = UINT32_C(0x00415645), /* "\0AVE" = reverse("EVA\0") */ | |
| .model = 955, | |
| }, | |
| { | |
| /* "FRD" -> Kirin 950 */ | |
| .platform = UINT32_C(0x00445246), /* "\0DRF" = reverse("FRD\0") */ | |
| .model = 950, | |
| }, | |
| { | |
| /* "INE" -> Kirin 710 */ | |
| .platform = UINT32_C(0x00454E49), /* "\0ENI" = reverse("INE\0") */ | |
| .model = 710, | |
| }, | |
| { | |
| /* "KNT" -> Kirin 950 */ | |
| .platform = UINT32_C(0x00544E4B), /* "\0TNK" = reverse("KNT\0") */ | |
| .model = 950, | |
| }, | |
| { | |
| /* "LON" -> Kirin 960 */ | |
| .platform = UINT32_C(0x004E4F4C), /* "\0NOL" = reverse("LON\0") */ | |
| .model = 960, | |
| }, | |
| { | |
| /* "LYA" -> Kirin 980 */ | |
| .platform = UINT32_C(0x0041594C), /* "\0AYL" = reverse("LYA\0") */ | |
| .model = 980, | |
| }, | |
| { | |
| /* "MCN" -> Kirin 980 */ | |
| .platform = UINT32_C(0x004E434D), /* "\0NCM" = reverse("MCN\0") */ | |
| .model = 980, | |
| }, | |
| { | |
| /* "MHA" -> Kirin 960 */ | |
| .platform = UINT32_C(0x0041484D), /* "\0AHM" = reverse("MHA\0") */ | |
| .model = 960, | |
| }, | |
| { | |
| /* "NEO" -> Kirin 970 */ | |
| .platform = UINT32_C(0x004F454E), /* "\0OEN" = reverse("NEO\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "NXT" -> Kirin 950 */ | |
| .platform = UINT32_C(0x0054584E), /* "\0TXN" = reverse("NXT\0") */ | |
| .model = 950, | |
| }, | |
| { | |
| /* "PAN" -> Kirin 980 */ | |
| .platform = UINT32_C(0x004E4150), /* "\0NAP" = reverse("PAN\0") */ | |
| .model = 980, | |
| }, | |
| { | |
| /* "PAR" -> Kirin 970 */ | |
| .platform = UINT32_C(0x00524150), /* "\0RAP" = reverse("PAR\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "RVL" -> Kirin 970 */ | |
| .platform = UINT32_C(0x004C5652), /* "\0LVR" = reverse("RVL\0") */ | |
| .model = 970, | |
| }, | |
| { | |
| /* "STF" -> Kirin 960 */ | |
| .platform = UINT32_C(0x00465453), /* "\0FTS" = reverse("STF\0") */ | |
| .model = 960, | |
| }, | |
| { | |
| /* "SUE" -> Kirin 980 */ | |
| .platform = UINT32_C(0x00455553), /* "\0EUS" = reverse("SUE\0") */ | |
| .model = 980, | |
| }, | |
| { | |
| /* "VIE" -> Kirin 955 */ | |
| .platform = UINT32_C(0x00454956), /* "\0EIV" = reverse("VIE\0") */ | |
| .model = 955, | |
| }, | |
| { | |
| /* "VKY" -> Kirin 960 */ | |
| .platform = UINT32_C(0x00594B56), /* "\0YKV" = reverse("VKY\0") */ | |
| .model = 960, | |
| }, | |
| { | |
| /* "VTR" -> Kirin 960 */ | |
| .platform = UINT32_C(0x00525456), /* "\0RTV" = reverse("VTR\0") */ | |
| .model = 960, | |
| }, | |
| }; | |
| /** | |
| * Tries to match ro.product.board string to Huawei | |
| * /([A-Z]{3})(\-[A-Z]?L\d{2})$/ signature where \1 is one of the known values | |
| * for Huawei devices, which do not report chipset name elsewhere. If the string | |
| * matches signature, the function decodes chipset (always HiSilicon Kirin for | |
| * matched devices) from the Huawei platform ID in the signature and stores it | |
| * in \p chipset argument. | |
| * | |
| * @param start - start of the ro.product.board string to match. | |
| * @param end - end of the ro.product.board string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match and decoding. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_and_parse_huawei( | |
| const char* start, | |
| const char* end, | |
| struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* | |
| * Expect length of either 3, 7 or 8, exactly: | |
| * - 3-letter platform identifier (see huawei_platform_map) | |
| * - 3-letter platform identifier + '-' + 'L' + two digits | |
| * - 3-letter platform identifier + '-' + capital letter + 'L' + two | |
| * digits | |
| */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 3: | |
| case 7: | |
| case 8: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* | |
| * Try to find the first three-letter substring in among the tabulated | |
| * entries for Huawei devices. The first three letters are loaded and | |
| * compared as a little-endian 24-bit word. | |
| */ | |
| uint32_t model = 0; | |
| const uint32_t target_platform_id = load_u24le(start); | |
| for (uint32_t i = 0; i < CPUINFO_COUNT_OF(huawei_platform_map); i++) { | |
| if (huawei_platform_map[i].platform == target_platform_id) { | |
| model = huawei_platform_map[i].model; | |
| break; | |
| } | |
| } | |
| if (model == 0) { | |
| /* Platform does not match the tabulated Huawei entries */ | |
| return false; | |
| } | |
| if (length > 3) { | |
| /* | |
| * Check that: | |
| * - The symbol after platform id is a dash | |
| * - The symbol after it is an uppercase letter. For 7-symbol | |
| * strings, the symbol is just 'L'. | |
| */ | |
| if (start[3] != '-' || !is_ascii_alphabetic_uppercase(start[4])) { | |
| return false; | |
| } | |
| /* Check that the last 3 entries are /L\d\d/ */ | |
| if (end[-3] != 'L' || !is_ascii_numeric(end[-2]) || !is_ascii_numeric(end[-1])) { | |
| return false; | |
| } | |
| } | |
| /* All checks succeeded, commit chipset name */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_hisilicon, | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = model, | |
| }; | |
| return true; | |
| } | |
| /** | |
| * Tries to match /tcc\d{3}x$/ signature for Telechips TCCXXXx chipsets. | |
| * If match successful, extracts model information into \p chipset argument. | |
| * | |
| * @param start - start of the /proc/cpuinfo Hardware string to match. | |
| * @param end - end of the /proc/cpuinfo Hardware string to match. | |
| * @param[out] chipset - location where chipset information will be stored upon | |
| * a successful match. | |
| * | |
| * @returns true if signature matched, false otherwise. | |
| */ | |
| static bool match_tcc(const char* start, const char* end, struct cpuinfo_arm_chipset chipset[restrict static 1]) { | |
| /* Expect exactly 7 symbols: "tcc" (3 symbols) + 3-digit model number + | |
| * fixed "x" suffix */ | |
| if (start + 7 != end) { | |
| return false; | |
| } | |
| /* Quick check for the first character */ | |
| if (start[0] != 't') { | |
| return false; | |
| } | |
| /* Load the next 2 bytes as little endian 16-bit word */ | |
| const uint16_t expected_cc = load_u16le(start + 1); | |
| if (expected_cc != UINT16_C(0x6363) /* "cc" */) { | |
| return false; | |
| } | |
| /* Check and parse 3-digit model number */ | |
| uint32_t model = 0; | |
| for (uint32_t i = 3; i < 6; i++) { | |
| const uint32_t digit = (uint32_t)(uint8_t)start[i] - '0'; | |
| if (digit >= 10) { | |
| /* Not really a digit */ | |
| return false; | |
| } | |
| model = model * 10 + digit; | |
| } | |
| /* Check the fixed 'x' suffix in the end */ | |
| if (start[6] != 'x') { | |
| return false; | |
| } | |
| /* Commit parsed chipset. */ | |
| *chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_telechips, | |
| .series = cpuinfo_arm_chipset_series_telechips_tcc, | |
| .model = model, | |
| .suffix = {[0] = 'X'}, | |
| }; | |
| return true; | |
| } | |
| /* | |
| * Compares ro.board.platform string to Nvidia Tegra signatures ("tegra" and | |
| * "tegra3") This check has effect on how /proc/cpuinfo Hardware string is | |
| * interpreted. | |
| * | |
| * @param start - start of the ro.board.platform string to check. | |
| * @param end - end of the ro.board.platform string to check. | |
| * | |
| * @returns true if the string matches an Nvidia Tegra signature, and false | |
| * otherwise | |
| */ | |
| static bool is_tegra(const char* start, const char* end) { | |
| /* Expect 5 ("tegra") or 6 ("tegra3") symbols */ | |
| const size_t length = end - start; | |
| switch (length) { | |
| case 5: | |
| case 6: | |
| break; | |
| default: | |
| return false; | |
| } | |
| /* Check that the first 5 characters match "tegra" */ | |
| if (start[0] != 't') { | |
| return false; | |
| } | |
| const uint32_t expected_egra = load_u32le(start + 1); | |
| if (expected_egra != UINT32_C(0x61726765) /* "arge" = reverse("egra") */) { | |
| return false; | |
| } | |
| /* Check if the string is either "tegra" (length = 5) or "tegra3" | |
| * (length != 5) and last character is '3' */ | |
| return (length == 5 || start[5] == '3'); | |
| } | |
| struct special_map_entry { | |
| const char* platform; | |
| uint16_t model; | |
| uint8_t series; | |
| char suffix; | |
| }; | |
| static const struct special_map_entry special_hardware_map_entries[] = { | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "k3v2oem1" -> HiSilicon K3V2 */ | |
| .platform = "k3v2oem1", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_k3v, | |
| .model = 2, | |
| }, | |
| {/* "hi6620oem" -> HiSilicon Kirin 910T */ | |
| .platform = "hi6620oem", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 910, | |
| .suffix = 'T'}, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "hi6250" -> HiSilicon Kirin 650 */ | |
| .platform = "hi6250", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 650, | |
| }, | |
| { | |
| /* "hi6210sft" -> HiSilicon Kirin 620 */ | |
| .platform = "hi6210sft", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 620, | |
| }, | |
| { | |
| /* "hi3751" -> HiSilicon Hi3751 */ | |
| .platform = "hi3751", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_hi, | |
| .model = 3751, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "hi3630" -> HiSilicon Kirin 920 */ | |
| .platform = "hi3630", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 920, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "hi3635" -> HiSilicon Kirin 930 */ | |
| .platform = "hi3635", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 930, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "gs702a" -> Actions ATM7029 (Cortex-A5 + GC1000) */ | |
| .platform = "gs702a", | |
| .series = cpuinfo_arm_chipset_series_actions_atm, | |
| .model = 7029, | |
| }, | |
| { | |
| /* "gs702c" -> Actions ATM7029B (Cortex-A5 + SGX540) */ | |
| .platform = "gs702c", | |
| .series = cpuinfo_arm_chipset_series_actions_atm, | |
| .model = 7029, | |
| .suffix = 'B', | |
| }, | |
| { | |
| /* "gs703d" -> Actions ATM7039S */ | |
| .platform = "gs703d", | |
| .series = cpuinfo_arm_chipset_series_actions_atm, | |
| .model = 7039, | |
| .suffix = 'S', | |
| }, | |
| { | |
| /* "gs705a" -> Actions ATM7059A */ | |
| .platform = "gs705a", | |
| .series = cpuinfo_arm_chipset_series_actions_atm, | |
| .model = 7059, | |
| .suffix = 'A', | |
| }, | |
| { | |
| /* "Amlogic Meson8" -> Amlogic S812 */ | |
| .platform = "Amlogic Meson8", | |
| .series = cpuinfo_arm_chipset_series_amlogic_s, | |
| .model = 812, | |
| }, | |
| { | |
| /* "Amlogic Meson8B" -> Amlogic S805 */ | |
| .platform = "Amlogic Meson8B", | |
| .series = cpuinfo_arm_chipset_series_amlogic_s, | |
| .model = 805, | |
| }, | |
| { | |
| /* "mapphone_CDMA" -> Texas Instruments OMAP4430 */ | |
| .platform = "mapphone_CDMA", | |
| .series = cpuinfo_arm_chipset_series_texas_instruments_omap, | |
| .model = 4430, | |
| }, | |
| { | |
| /* "Superior" -> Texas Instruments OMAP4470 */ | |
| .platform = "Superior", | |
| .series = cpuinfo_arm_chipset_series_texas_instruments_omap, | |
| .model = 4470, | |
| }, | |
| { | |
| /* "Tuna" (Samsung Galaxy Nexus) -> Texas Instruments OMAP4460 | |
| */ | |
| .platform = "Tuna", | |
| .series = cpuinfo_arm_chipset_series_texas_instruments_omap, | |
| .model = 4460, | |
| }, | |
| { | |
| /* "Manta" (Samsung Nexus 10) -> Samsung Exynos 5250 */ | |
| .platform = "Manta", | |
| .series = cpuinfo_arm_chipset_series_samsung_exynos, | |
| .model = 5250, | |
| }, | |
| { | |
| /* "Odin" -> LG Nuclun 7111 */ | |
| .platform = "Odin", | |
| .series = cpuinfo_arm_chipset_series_lg_nuclun, | |
| .model = 7111, | |
| }, | |
| { | |
| /* "Madison" -> MStar 6A338 */ | |
| .platform = "Madison", | |
| .series = cpuinfo_arm_chipset_series_mstar_6a, | |
| .model = 338, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| }; | |
| static const struct special_map_entry tegra_hardware_map_entries[] = { | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "cardhu" (Nvidia Cardhu developer tablet) -> Tegra T30 */ | |
| .platform = "cardhu", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "kai" -> Tegra T30L */ | |
| .platform = "kai", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "p3" (Samsung Galaxy Tab 8.9) -> Tegra T20 */ | |
| .platform = "p3", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 20, | |
| }, | |
| { | |
| /* "n1" (Samsung Galaxy R / Samsung Captivate Glide) -> Tegra | |
| AP20H */ | |
| .platform = "n1", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 20, | |
| .suffix = 'H', | |
| }, | |
| { | |
| /* "SHW-M380S" (Samsung Galaxy Tab 10.1) -> Tegra T20 */ | |
| .platform = "SHW-M380S", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 20, | |
| }, | |
| { | |
| /* "m470" (Hisense Sero 7 Pro) -> Tegra T30L */ | |
| .platform = "m470", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "endeavoru" (HTC One X) -> Tegra AP33 */ | |
| .platform = "endeavoru", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 33, | |
| }, | |
| { | |
| /* "evitareul" (HTC One X+) -> Tegra T33 */ | |
| .platform = "evitareul", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 33, | |
| }, | |
| { | |
| /* "enrc2b" (HTC One X+) -> Tegra T33 */ | |
| .platform = "enrc2b", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 33, | |
| }, | |
| { | |
| /* "mozart" (Asus Transformer Pad TF701T) -> Tegra T114 */ | |
| .platform = "mozart", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "tegratab" (Tegra Note 7) -> Tegra T114 */ | |
| .platform = "tegratab", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "tn8" (Nvidia Shield Tablet K1) -> Tegra T124 */ | |
| .platform = "tn8", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 124, | |
| }, | |
| { | |
| /* "roth" (Nvidia Shield Portable) -> Tegra T114 */ | |
| .platform = "roth", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "pisces" (Xiaomi Mi 3) -> Tegra T114 */ | |
| .platform = "pisces", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "mocha" (Xiaomi Mi Pad) -> Tegra T124 */ | |
| .platform = "mocha", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 124, | |
| }, | |
| { | |
| /* "stingray" (Motorola XOOM) -> Tegra AP20H */ | |
| .platform = "stingray", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 20, | |
| .suffix = 'H', | |
| }, | |
| { | |
| /* "Ceres" (Wiko Highway 4G) -> Tegra SL460N */ | |
| .platform = "Ceres", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_sl, | |
| .model = 460, | |
| .suffix = 'N', | |
| }, | |
| { | |
| /* "MT799" (nabi 2 Tablet) -> Tegra T30 */ | |
| .platform = "MT799", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "t8400n" (nabi DreamTab HD8) -> Tegra T114 */ | |
| .platform = "t8400n", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "chagall" (Fujitsu Stylistic M532) -> Tegra T30 */ | |
| .platform = "chagall", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "ventana" (Asus Transformer TF101) -> Tegra T20 */ | |
| .platform = "ventana", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 20, | |
| }, | |
| { | |
| /* "bobsleigh" (Fujitsu Arrows Tab F-05E) -> Tegra T33 */ | |
| .platform = "bobsleigh", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 33, | |
| }, | |
| { | |
| /* "tegra_fjdev101" (Fujitsu Arrows X F-10D) -> Tegra AP33 */ | |
| .platform = "tegra_fjdev101", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 33, | |
| }, | |
| { | |
| /* "tegra_fjdev103" (Fujitsu Arrows V F-04E) -> Tegra T33 */ | |
| .platform = "tegra_fjdev103", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 33, | |
| }, | |
| { | |
| /* "nbx03" (Sony Tablet S) -> Tegra T20 */ | |
| .platform = "nbx03", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 20, | |
| }, | |
| { | |
| /* "txs03" (Sony Xperia Tablet S) -> Tegra T30L */ | |
| .platform = "txs03", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "x3" (LG Optimus 4X HD P880) -> Tegra AP33 */ | |
| .platform = "x3", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 33, | |
| }, | |
| { | |
| /* "vu10" (LG Optimus Vu P895) -> Tegra AP33 */ | |
| .platform = "vu10", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 33, | |
| }, | |
| { | |
| /* "BIRCH" (HP Slate 7 Plus) -> Tegra T30L */ | |
| .platform = "BIRCH", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "macallan" (HP Slate 8 Pro) -> Tegra T114 */ | |
| .platform = "macallan", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "maya" (HP SlateBook 10 x2) -> Tegra T114 */ | |
| .platform = "maya", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "antares" (Toshiba AT100) -> Tegra T20 */ | |
| .platform = "antares", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 20, | |
| }, | |
| { | |
| /* "tostab12AL" (Toshiba AT300SE "Excite 10 SE") -> Tegra T30L | |
| */ | |
| .platform = "tostab12AL", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "tostab12BL" (Toshiba AT10-A "Excite Pure") -> Tegra T30L */ | |
| .platform = "tostab12BL", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "sphinx" (Toshiba AT270 "Excite 7.7") -> Tegra T30 */ | |
| .platform = "sphinx", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "tostab11BS" (Toshiba AT570 "Regza 7.7") -> Tegra T30 */ | |
| .platform = "tostab11BS", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "tostab12BA" (Toshiba AT10-LE-A "Excite Pro") -> Tegra T114 | |
| */ | |
| .platform = "tostab12BA", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "vangogh" (Acer Iconia Tab A100) -> Tegra T20 */ | |
| .platform = "vangogh", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 20, | |
| }, | |
| { | |
| /* "a110" (Acer Iconia Tab A110) -> Tegra T30L */ | |
| .platform = "a110", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "picasso_e" (Acer Iconia Tab A200) -> Tegra AP20H */ | |
| .platform = "picasso_e", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 20, | |
| .suffix = 'H', | |
| }, | |
| { | |
| /* "picasso_e2" (Acer Iconia Tab A210) -> Tegra T30L */ | |
| .platform = "picasso_e2", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "picasso" (Acer Iconia Tab A500) -> Tegra AP20H */ | |
| .platform = "picasso", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_ap, | |
| .model = 20, | |
| .suffix = 'H', | |
| }, | |
| { | |
| /* "picasso_m" (Acer Iconia Tab A510) -> Tegra T30 */ | |
| .platform = "picasso_m", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "picasso_mf" (Acer Iconia Tab A700) -> Tegra T30 */ | |
| .platform = "picasso_mf", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "avalon" (Toshiba AT300 "Excite 10") -> Tegra T30L */ | |
| .platform = "avalon", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "NS_14T004" (iRiver NS-14T004) -> Tegra T30L */ | |
| .platform = "NS_14T004", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| { | |
| /* "WIKIPAD" (Wikipad) -> Tegra T30 */ | |
| .platform = "WIKIPAD", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| }, | |
| { | |
| /* "kb" (Pegatron Q00Q) -> Tegra T114 */ | |
| .platform = "kb", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "foster_e" (Nvidia Shield TV, Flash) -> Tegra T210 */ | |
| .platform = "foster_e", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 210, | |
| }, | |
| { | |
| /* "foster_e_hdd" (Nvidia Shield TV, HDD) -> Tegra T210 */ | |
| .platform = "foster_e_hdd", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 210, | |
| }, | |
| { | |
| /* "darcy" (Nvidia Shield TV 2017) -> Tegra T210 */ | |
| .platform = "darcy", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 210, | |
| }, | |
| }; | |
| /* | |
| * Decodes chipset name from /proc/cpuinfo Hardware string. | |
| * For some chipsets, the function relies frequency and on number of cores for | |
| * chipset detection. | |
| * | |
| * @param[in] platform - /proc/cpuinfo Hardware string. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_linux_decode_chipset_from_proc_cpuinfo_hardware( | |
| const char hardware[restrict static CPUINFO_HARDWARE_VALUE_MAX], | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max, | |
| bool is_tegra) { | |
| struct cpuinfo_arm_chipset chipset; | |
| const size_t hardware_length = strnlen(hardware, CPUINFO_HARDWARE_VALUE_MAX); | |
| const char* hardware_end = hardware + hardware_length; | |
| if (is_tegra) { | |
| /* | |
| * Nvidia Tegra-specific path: compare /proc/cpuinfo Hardware | |
| * string to tabulated Hardware values for popular | |
| * chipsets/devices with Tegra chipsets. This path is only used | |
| * when ro.board.platform indicates a Tegra chipset (albeit does | |
| * not indicate which exactly Tegra chipset). | |
| */ | |
| for (size_t i = 0; i < CPUINFO_COUNT_OF(tegra_hardware_map_entries); i++) { | |
| if (strncmp(tegra_hardware_map_entries[i].platform, hardware, hardware_length) == 0 && | |
| tegra_hardware_map_entries[i].platform[hardware_length] == 0) { | |
| cpuinfo_log_debug( | |
| "found /proc/cpuinfo Hardware string \"%.*s\" in Nvidia Tegra chipset table", | |
| (int)hardware_length, | |
| hardware); | |
| /* Create chipset name from entry */ | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = chipset_series_vendor[tegra_hardware_map_entries[i].series], | |
| .series = (enum cpuinfo_arm_chipset_series)tegra_hardware_map_entries[i].series, | |
| .model = tegra_hardware_map_entries[i].model, | |
| .suffix = | |
| { | |
| [0] = tegra_hardware_map_entries[i].suffix, | |
| }, | |
| }; | |
| } | |
| } | |
| } else { | |
| /* Generic path: consider all other vendors */ | |
| bool word_start = true; | |
| for (const char* pos = hardware; pos != hardware_end; pos++) { | |
| const char c = *pos; | |
| switch (c) { | |
| case ' ': | |
| case '\t': | |
| case ',': | |
| word_start = true; | |
| break; | |
| default: | |
| if (word_start && is_ascii_alphabetic(c)) { | |
| /* Check Qualcomm MSM/APQ | |
| * signature */ | |
| if (match_msm_apq(pos, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm MSM/APQ signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check SDMxxx (Qualcomm | |
| * Snapdragon) signature */ | |
| if (match_sdm(pos, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm SDM signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check SMxxxx (Qualcomm | |
| * Snapdragon) signature */ | |
| if (match_sm(pos, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm SM signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check MediaTek MT signature | |
| */ | |
| if (match_mt(pos, hardware_end, true, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched MediaTek MT signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check HiSilicon Kirin | |
| * signature */ | |
| if (match_kirin(pos, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched HiSilicon Kirin signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check Rockchip RK signature | |
| */ | |
| if (match_rk(pos, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Rockchip RK signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| } | |
| word_start = false; | |
| break; | |
| } | |
| } | |
| /* Check Samsung Exynos signature */ | |
| if (match_samsung_exynos(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Samsung Exynos signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check universalXXXX (Samsung Exynos) signature */ | |
| if (match_universal(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched UNIVERSAL (Samsung Exynos) signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* Match /SMDK(4410|4x12)$/ */ | |
| if (match_and_parse_smdk(hardware, hardware_end, cores, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched SMDK (Samsung Exynos) signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| #endif | |
| /* Check Spreadtrum SC signature */ | |
| if (match_sc(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Spreadtrum SC signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check Unisoc T signature */ | |
| if (match_t(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Unisoc T signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check Unisoc UMS signature */ | |
| if (match_ums(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Unisoc UMS signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* Check Marvell PXA signature */ | |
| if (match_pxa(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Marvell PXA signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| #endif | |
| /* Match /sun\d+i/ signature and map to Allwinner chipset name | |
| */ | |
| if (match_and_parse_sunxi(hardware, hardware_end, cores, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched sunxi (Allwinner Ax) signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check Broadcom BCM signature */ | |
| if (match_bcm(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Broadcom BCM signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* Check Texas Instruments OMAP signature */ | |
| if (match_omap(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Texas Instruments OMAP signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Check WonderMedia WMT signature and decode chipset from | |
| * frequency and number of cores */ | |
| if (match_and_parse_wmt(hardware, hardware_end, cores, max_cpu_freq_max, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched WonderMedia WMT signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| #endif | |
| /* Check Telechips TCC signature */ | |
| if (match_tcc(hardware, hardware_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Telechips TCC signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)hardware_length, | |
| hardware); | |
| return chipset; | |
| } | |
| /* Compare to tabulated Hardware values for popular | |
| * chipsets/devices which can't be otherwise detected */ | |
| for (size_t i = 0; i < CPUINFO_COUNT_OF(special_hardware_map_entries); i++) { | |
| if (strncmp(special_hardware_map_entries[i].platform, hardware, hardware_length) == 0 && | |
| special_hardware_map_entries[i].platform[hardware_length] == 0) { | |
| cpuinfo_log_debug( | |
| "found /proc/cpuinfo Hardware string \"%.*s\" in special chipset table", | |
| (int)hardware_length, | |
| hardware); | |
| /* Create chipset name from entry */ | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = chipset_series_vendor[special_hardware_map_entries[i].series], | |
| .series = | |
| (enum cpuinfo_arm_chipset_series)special_hardware_map_entries[i].series, | |
| .model = special_hardware_map_entries[i].model, | |
| .suffix = | |
| { | |
| [0] = special_hardware_map_entries[i].suffix, | |
| }, | |
| }; | |
| } | |
| } | |
| } | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| } | |
| #ifdef __ANDROID__ | |
| static const struct special_map_entry special_board_map_entries[] = { | |
| { | |
| /* "hi6250" -> HiSilicon Kirin 650 */ | |
| .platform = "hi6250", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 650, | |
| }, | |
| { | |
| /* "hi6210sft" -> HiSilicon Kirin 620 */ | |
| .platform = "hi6210sft", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 620, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "hi3630" -> HiSilicon Kirin 920 */ | |
| .platform = "hi3630", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 920, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "hi3635" -> HiSilicon Kirin 930 */ | |
| .platform = "hi3635", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 930, | |
| }, | |
| { | |
| /* "hi3650" -> HiSilicon Kirin 950 */ | |
| .platform = "hi3650", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 950, | |
| }, | |
| { | |
| /* "hi3660" -> HiSilicon Kirin 960 */ | |
| .platform = "hi3660", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 960, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "mp523x" -> Renesas MP5232 */ | |
| .platform = "mp523x", | |
| .series = cpuinfo_arm_chipset_series_renesas_mp, | |
| .model = 5232, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "BEETHOVEN" (Huawei MadiaPad M3) -> HiSilicon Kirin 950 */ | |
| .platform = "BEETHOVEN", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 950, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "hws7701u" (Huawei MediaPad 7 Youth) -> Rockchip RK3168 */ | |
| .platform = "hws7701u", | |
| .series = cpuinfo_arm_chipset_series_rockchip_rk, | |
| .model = 3168, | |
| }, | |
| { | |
| /* "g2mv" (LG G2 mini LTE) -> Nvidia Tegra SL460N */ | |
| .platform = "g2mv", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_sl, | |
| .model = 460, | |
| .suffix = 'N', | |
| }, | |
| { | |
| /* "K00F" (Asus MeMO Pad 10) -> Rockchip RK3188 */ | |
| .platform = "K00F", | |
| .series = cpuinfo_arm_chipset_series_rockchip_rk, | |
| .model = 3188, | |
| }, | |
| { | |
| /* "T7H" (HP Slate 7) -> Rockchip RK3066 */ | |
| .platform = "T7H", | |
| .series = cpuinfo_arm_chipset_series_rockchip_rk, | |
| .model = 3066, | |
| }, | |
| { | |
| /* "tuna" (Samsung Galaxy Nexus) -> Texas Instruments OMAP4460 | |
| */ | |
| .platform = "tuna", | |
| .series = cpuinfo_arm_chipset_series_texas_instruments_omap, | |
| .model = 4460, | |
| }, | |
| { | |
| /* "grouper" (Asus Nexus 7 2012) -> Nvidia Tegra T30L */ | |
| .platform = "grouper", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 30, | |
| .suffix = 'L', | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "flounder" (HTC Nexus 9) -> Nvidia Tegra T132 */ | |
| .platform = "flounder", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 132, | |
| }, | |
| { | |
| /* "dragon" (Google Pixel C) -> Nvidia Tegra T210 */ | |
| .platform = "dragon", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 210, | |
| }, | |
| { | |
| /* "sailfish" (Google Pixel) -> Qualcomm MSM8996PRO */ | |
| .platform = "sailfish", | |
| .series = cpuinfo_arm_chipset_series_qualcomm_msm, | |
| .model = 8996, | |
| .suffix = 'P', | |
| }, | |
| { | |
| /* "marlin" (Google Pixel XL) -> Qualcomm MSM8996PRO */ | |
| .platform = "marlin", | |
| .series = cpuinfo_arm_chipset_series_qualcomm_msm, | |
| .model = 8996, | |
| .suffix = 'P', | |
| }, | |
| }; | |
| /* | |
| * Decodes chipset name from ro.product.board Android system property. | |
| * For some chipsets, the function relies frequency and on number of cores for | |
| * chipset detection. | |
| * | |
| * @param[in] platform - ro.product.board value. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_android_decode_chipset_from_ro_product_board( | |
| const char ro_product_board[restrict static CPUINFO_BUILD_PROP_VALUE_MAX], | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max) { | |
| struct cpuinfo_arm_chipset chipset; | |
| const char* board = ro_product_board; | |
| const size_t board_length = strnlen(ro_product_board, CPUINFO_BUILD_PROP_VALUE_MAX); | |
| const char* board_end = ro_product_board + board_length; | |
| /* Check Qualcomm MSM/APQ signature */ | |
| if (match_msm_apq(board, board_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm MSM/APQ signature in ro.product.board string \"%.*s\"", | |
| (int)board_length, | |
| board); | |
| return chipset; | |
| } | |
| /* Check universaXXXX (Samsung Exynos) signature */ | |
| if (match_universal(board, board_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched UNIVERSAL (Samsung Exynos) signature in ro.product.board string \"%.*s\"", | |
| (int)board_length, | |
| board); | |
| return chipset; | |
| } | |
| /* Check s5eXXXX (Samsung Exynos) signature */ | |
| if (match_s5e(board, board_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched S5E (Samsung Exynos) signature in ro.product.board string \"%.*s\"", | |
| (int)board_length, | |
| board); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* Check SMDK (Samsung Exynos) signature */ | |
| if (match_and_parse_smdk(board, board_end, cores, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched SMDK (Samsung Exynos) signature in ro.product.board string \"%.*s\"", | |
| (int)board_length, | |
| board); | |
| return chipset; | |
| } | |
| #endif | |
| /* Check MediaTek MT signature */ | |
| if (match_mt(board, board_end, true, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched MediaTek MT signature in ro.product.board string \"%.*s\"", (int)board_length, board); | |
| return chipset; | |
| } | |
| /* Check Spreadtrum SC signature */ | |
| if (match_sc(board, board_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Spreadtrum SC signature in ro.product.board string \"%.*s\"", | |
| (int)board_length, | |
| board); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* Check Marvell PXA signature */ | |
| if (match_pxa(board, board_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Marvell PXA signature in ro.product.board string \"%.*s\"", (int)board_length, board); | |
| return chipset; | |
| } | |
| /* Check Leadcore LCxxxx signature */ | |
| if (match_lc(board, board_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Leadcore LC signature in ro.product.board string \"%.*s\"", (int)board_length, board); | |
| return chipset; | |
| } | |
| /* | |
| * Compare to tabulated ro.product.board values for Broadcom chipsets | |
| * and decode chipset from frequency and number of cores. | |
| */ | |
| if (match_and_parse_broadcom(board, board_end, cores, max_cpu_freq_max, &chipset)) { | |
| cpuinfo_log_debug( | |
| "found ro.product.board string \"%.*s\" in Broadcom chipset table", (int)board_length, board); | |
| return chipset; | |
| } | |
| #endif | |
| /* Compare to tabulated ro.product.board values for Huawei devices which | |
| * don't report chipset elsewhere */ | |
| if (match_and_parse_huawei(board, board_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "found ro.product.board string \"%.*s\" in Huawei chipset table", (int)board_length, board); | |
| return chipset; | |
| } | |
| /* Compare to tabulated ro.product.board values for popular | |
| * chipsets/devices which can't be otherwise detected */ | |
| for (size_t i = 0; i < CPUINFO_COUNT_OF(special_board_map_entries); i++) { | |
| if (strncmp(special_board_map_entries[i].platform, board, board_length) == 0 && | |
| special_board_map_entries[i].platform[board_length] == 0) { | |
| cpuinfo_log_debug( | |
| "found ro.product.board string \"%.*s\" in special chipset table", | |
| (int)board_length, | |
| board); | |
| /* Create chipset name from entry */ | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = chipset_series_vendor[special_board_map_entries[i].series], | |
| .series = (enum cpuinfo_arm_chipset_series)special_board_map_entries[i].series, | |
| .model = special_board_map_entries[i].model, | |
| .suffix = | |
| { | |
| [0] = special_board_map_entries[i].suffix, | |
| /* The suffix of MSM8996PRO is | |
| truncated at the first | |
| letter, reconstruct it here. | |
| */ | |
| [1] = special_board_map_entries[i].suffix == 'P' ? 'R' : 0, | |
| [2] = special_board_map_entries[i].suffix == 'P' ? 'O' : 0, | |
| }, | |
| }; | |
| } | |
| } | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| } | |
| struct amlogic_map_entry { | |
| char ro_board_platform[6]; | |
| uint16_t model; | |
| uint8_t series; | |
| char suffix[3]; | |
| }; | |
| static const struct amlogic_map_entry amlogic_map_entries[] = { | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "meson3" -> Amlogic AML8726-M */ | |
| .ro_board_platform = "meson3", | |
| .series = cpuinfo_arm_chipset_series_amlogic_aml, | |
| .model = 8726, | |
| .suffix = "-M", | |
| }, | |
| { | |
| /* "meson6" -> Amlogic AML8726-MX */ | |
| .ro_board_platform = "meson6", | |
| .series = cpuinfo_arm_chipset_series_amlogic_aml, | |
| .model = 8726, | |
| .suffix = "-MX", | |
| }, | |
| { | |
| /* "meson8" -> Amlogic S805 */ | |
| .ro_board_platform = "meson8", | |
| .series = cpuinfo_arm_chipset_series_amlogic_s, | |
| .model = 805, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "gxbaby" -> Amlogic S905 */ | |
| .ro_board_platform = "gxbaby", | |
| .series = cpuinfo_arm_chipset_series_amlogic_s, | |
| .model = 905, | |
| }, | |
| { | |
| /* "gxl" -> Amlogic S905X */ | |
| .ro_board_platform = "gxl", | |
| .series = cpuinfo_arm_chipset_series_amlogic_s, | |
| .model = 905, | |
| .suffix = "X", | |
| }, | |
| { | |
| /* "gxm" -> Amlogic S912 */ | |
| .ro_board_platform = "gxm", | |
| .series = cpuinfo_arm_chipset_series_amlogic_s, | |
| .model = 912, | |
| }, | |
| }; | |
| static const struct special_map_entry special_platform_map_entries[] = { | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "hi6620oem" -> HiSilicon Kirin 910T */ | |
| .platform = "hi6620oem", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 910, | |
| .suffix = 'T', | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "hi6250" -> HiSilicon Kirin 650 */ | |
| .platform = "hi6250", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 650, | |
| }, | |
| { | |
| /* "hi6210sft" -> HiSilicon Kirin 620 */ | |
| .platform = "hi6210sft", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 620, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "hi3630" -> HiSilicon Kirin 920 */ | |
| .platform = "hi3630", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 920, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "hi3635" -> HiSilicon Kirin 930 */ | |
| .platform = "hi3635", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 930, | |
| }, | |
| { | |
| /* "hi3650" -> HiSilicon Kirin 950 */ | |
| .platform = "hi3650", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 950, | |
| }, | |
| { | |
| /* "hi3660" -> HiSilicon Kirin 960 */ | |
| .platform = "hi3660", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_kirin, | |
| .model = 960, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "k3v2oem1" -> HiSilicon K3V2 */ | |
| .platform = "k3v2oem1", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_k3v, | |
| .model = 2, | |
| }, | |
| { | |
| /* "k3v200" -> HiSilicon K3V2 */ | |
| .platform = "k3v200", | |
| .series = cpuinfo_arm_chipset_series_hisilicon_k3v, | |
| .model = 2, | |
| }, | |
| { | |
| /* "montblanc" -> NovaThor U8500 */ | |
| .platform = "montblanc", | |
| .series = cpuinfo_arm_chipset_series_novathor_u, | |
| .model = 8500, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "song" -> Pinecone Surge S1 */ | |
| .platform = "song", | |
| .series = cpuinfo_arm_chipset_series_pinecone_surge_s, | |
| .model = 1, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "rk322x" -> RockChip RK3229 */ | |
| .platform = "rk322x", | |
| .series = cpuinfo_arm_chipset_series_rockchip_rk, | |
| .model = 3229, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| { | |
| /* "tegra132" -> Nvidia Tegra T132 */ | |
| .platform = "tegra132", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 132, | |
| }, | |
| { | |
| /* "tegra210_dragon" -> Nvidia Tegra T210 */ | |
| .platform = "tegra210_dragon", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 210, | |
| }, | |
| #if CPUINFO_ARCH_ARM | |
| { | |
| /* "tegra4" -> Nvidia Tegra T114 */ | |
| .platform = "tegra4", | |
| .series = cpuinfo_arm_chipset_series_nvidia_tegra_t, | |
| .model = 114, | |
| }, | |
| { | |
| /* "s5pc110" -> Samsung Exynos 3110 */ | |
| .platform = "s5pc110", | |
| .series = cpuinfo_arm_chipset_series_samsung_exynos, | |
| .model = 3110, | |
| }, | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| }; | |
| /* | |
| * Decodes chipset name from ro.board.platform Android system property. | |
| * For some chipsets, the function relies frequency and on number of cores for | |
| * chipset detection. | |
| * | |
| * @param[in] platform - ro.board.platform value. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_android_decode_chipset_from_ro_board_platform( | |
| const char platform[restrict static CPUINFO_BUILD_PROP_VALUE_MAX], | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max) { | |
| struct cpuinfo_arm_chipset chipset; | |
| const size_t platform_length = strnlen(platform, CPUINFO_BUILD_PROP_VALUE_MAX); | |
| const char* platform_end = platform + platform_length; | |
| /* Check Qualcomm MSM/APQ signature */ | |
| if (match_msm_apq(platform, platform_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm MSM/APQ signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| /* Check exynosXXXX (Samsung Exynos) signature */ | |
| if (match_exynos(platform, platform_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched exynosXXXX (Samsung Exynos) signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| /* Check MediaTek MT signature */ | |
| if (match_mt(platform, platform_end, true, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched MediaTek MT signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| /* Check HiSilicon Kirin signature */ | |
| if (match_kirin(platform, platform_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched HiSilicon Kirin signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| /* Check Spreadtrum SC signature */ | |
| if (match_sc(platform, platform_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Spreadtrum SC signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| /* Check Rockchip RK signature */ | |
| if (match_rk(platform, platform_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Rockchip RK signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* Check Leadcore LCxxxx signature */ | |
| if (match_lc(platform, platform_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Leadcore LC signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| #endif | |
| /* Compare to tabulated ro.board.platform values for Huawei devices | |
| * which don't report chipset elsewhere */ | |
| if (match_and_parse_huawei(platform, platform_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "found ro.board.platform string \"%.*s\" in Huawei chipset table", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* | |
| * Compare to known ro.board.platform values for Broadcom devices and | |
| * detect chipset from frequency and number of cores | |
| */ | |
| if (match_and_parse_broadcom(platform, platform_end, cores, max_cpu_freq_max, &chipset)) { | |
| cpuinfo_log_debug( | |
| "found ro.board.platform string \"%.*s\" in Broadcom chipset table", | |
| (int)platform_length, | |
| platform); | |
| return chipset; | |
| } | |
| /* | |
| * Compare to ro.board.platform value ("omap4") for OMAP4xxx chipsets. | |
| * Upon successful match, detect OMAP4430 from frequency and number of | |
| * cores. | |
| */ | |
| if (platform_length == 5 && cores == 2 && max_cpu_freq_max == 1008000 && memcmp(platform, "omap4", 5) == 0) { | |
| cpuinfo_log_debug( | |
| "matched Texas Instruments OMAP4 signature in ro.board.platform string \"%.*s\"", | |
| (int)platform_length, | |
| platform); | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_texas_instruments, | |
| .series = cpuinfo_arm_chipset_series_texas_instruments_omap, | |
| .model = 4430, | |
| }; | |
| } | |
| #endif | |
| /* | |
| * Compare to tabulated ro.board.platform values for Amlogic | |
| * chipsets/devices which can't be otherwise detected. The tabulated | |
| * Amlogic ro.board.platform values have not more than 6 characters. | |
| */ | |
| if (platform_length <= 6) { | |
| for (size_t i = 0; i < CPUINFO_COUNT_OF(amlogic_map_entries); i++) { | |
| if (strncmp(amlogic_map_entries[i].ro_board_platform, platform, 6) == 0) { | |
| cpuinfo_log_debug( | |
| "found ro.board.platform string \"%.*s\" in Amlogic chipset table", | |
| (int)platform_length, | |
| platform); | |
| /* Create chipset name from entry */ | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_amlogic, | |
| .series = (enum cpuinfo_arm_chipset_series)amlogic_map_entries[i].series, | |
| .model = amlogic_map_entries[i].model, | |
| .suffix = | |
| { | |
| [0] = amlogic_map_entries[i].suffix[0], | |
| [1] = amlogic_map_entries[i].suffix[1], | |
| [2] = amlogic_map_entries[i].suffix[2], | |
| }, | |
| }; | |
| } | |
| } | |
| } | |
| /* Compare to tabulated ro.board.platform values for popular | |
| * chipsets/devices which can't be otherwise detected */ | |
| for (size_t i = 0; i < CPUINFO_COUNT_OF(special_platform_map_entries); i++) { | |
| if (strncmp(special_platform_map_entries[i].platform, platform, platform_length) == 0 && | |
| special_platform_map_entries[i].platform[platform_length] == 0) { | |
| /* Create chipset name from entry */ | |
| cpuinfo_log_debug( | |
| "found ro.board.platform string \"%.*s\" in special chipset table", | |
| (int)platform_length, | |
| platform); | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = chipset_series_vendor[special_platform_map_entries[i].series], | |
| .series = (enum cpuinfo_arm_chipset_series)special_platform_map_entries[i].series, | |
| .model = special_platform_map_entries[i].model, | |
| .suffix = | |
| { | |
| [0] = special_platform_map_entries[i].suffix, | |
| }, | |
| }; | |
| } | |
| } | |
| /* None of the ro.board.platform signatures matched, indicate unknown | |
| * chipset | |
| */ | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| } | |
| /* | |
| * Decodes chipset name from ro.mediatek.platform Android system property. | |
| * | |
| * @param[in] platform - ro.mediatek.platform value. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_android_decode_chipset_from_ro_mediatek_platform( | |
| const char platform[restrict static CPUINFO_BUILD_PROP_VALUE_MAX]) { | |
| struct cpuinfo_arm_chipset chipset; | |
| const char* platform_end = platform + strnlen(platform, CPUINFO_BUILD_PROP_VALUE_MAX); | |
| /* Check MediaTek MT signature */ | |
| if (match_mt(platform, platform_end, false, &chipset)) { | |
| return chipset; | |
| } | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| } | |
| /* | |
| * Decodes chipset name from ro.arch Android system property. | |
| * | |
| * The ro.arch property is matched only against Samsung Exynos signature. | |
| * Systems with other chipset rarely configure ro.arch Android system property, | |
| * and can be decoded through other properties, but some Exynos chipsets are | |
| * identified only in ro.arch. | |
| * | |
| * @param[in] arch - ro.arch value. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_android_decode_chipset_from_ro_arch( | |
| const char arch[restrict static CPUINFO_BUILD_PROP_VALUE_MAX]) { | |
| struct cpuinfo_arm_chipset chipset; | |
| const char* arch_end = arch + strnlen(arch, CPUINFO_BUILD_PROP_VALUE_MAX); | |
| /* Check Samsung exynosXXXX signature */ | |
| if (match_exynos(arch, arch_end, &chipset)) { | |
| return chipset; | |
| } | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| } | |
| /* | |
| * Decodes chipset name from ro.chipname or ro.hardware.chipname Android system | |
| * property. | |
| * | |
| * @param[in] chipname - ro.chipname or ro.hardware.chipname value. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_android_decode_chipset_from_ro_chipname( | |
| const char chipname[restrict static CPUINFO_BUILD_PROP_VALUE_MAX]) { | |
| struct cpuinfo_arm_chipset chipset; | |
| const size_t chipname_length = strnlen(chipname, CPUINFO_BUILD_PROP_VALUE_MAX); | |
| const char* chipname_end = chipname + chipname_length; | |
| /* Check Qualcomm MSM/APQ signatures */ | |
| if (match_msm_apq(chipname, chipname_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm MSM/APQ signature in ro.chipname string \"%.*s\"", | |
| (int)chipname_length, | |
| chipname); | |
| return chipset; | |
| } | |
| /* Check SMxxxx (Qualcomm Snapdragon) signature */ | |
| if (match_sm(chipname, chipname_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm SM signature in /proc/cpuinfo Hardware string \"%.*s\"", | |
| (int)chipname_length, | |
| chipname); | |
| return chipset; | |
| } | |
| /* Check exynosXXXX (Samsung Exynos) signature */ | |
| if (match_exynos(chipname, chipname_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched exynosXXXX (Samsung Exynos) signature in ro.chipname string \"%.*s\"", | |
| (int)chipname_length, | |
| chipname); | |
| return chipset; | |
| } | |
| /* Check universalXXXX (Samsung Exynos) signature */ | |
| if (match_universal(chipname, chipname_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched UNIVERSAL (Samsung Exynos) signature in ro.chipname Hardware string \"%.*s\"", | |
| (int)chipname_length, | |
| chipname); | |
| return chipset; | |
| } | |
| /* Check MediaTek MT signature */ | |
| if (match_mt(chipname, chipname_end, true, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched MediaTek MT signature in ro.chipname string \"%.*s\"", (int)chipname_length, chipname); | |
| return chipset; | |
| } | |
| /* Check Spreadtrum SC signature */ | |
| if (match_sc(chipname, chipname_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Spreadtrum SC signature in ro.chipname string \"%.*s\"", | |
| (int)chipname_length, | |
| chipname); | |
| return chipset; | |
| } | |
| #if CPUINFO_ARCH_ARM | |
| /* Check Marvell PXA signature */ | |
| if (match_pxa(chipname, chipname_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Marvell PXA signature in ro.chipname string \"%.*s\"", (int)chipname_length, chipname); | |
| return chipset; | |
| } | |
| /* Compare to ro.chipname value ("mp523x") for Renesas MP5232 which | |
| * can't be otherwise detected */ | |
| if (chipname_length == 6 && memcmp(chipname, "mp523x", 6) == 0) { | |
| cpuinfo_log_debug( | |
| "matched Renesas MP5232 signature in ro.chipname string \"%.*s\"", | |
| (int)chipname_length, | |
| chipname); | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_renesas, | |
| .series = cpuinfo_arm_chipset_series_renesas_mp, | |
| .model = 5232, | |
| }; | |
| } | |
| #endif | |
| return (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| } | |
| /* | |
| * Decodes chipset name from ro.soc.model Android system property. | |
| * | |
| * @param[in] soc_model - ro.soc.model value. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_android_decode_chipset_from_ro_soc_model( | |
| const char soc_model[restrict static CPUINFO_BUILD_PROP_VALUE_MAX]) { | |
| struct cpuinfo_arm_chipset chipset = { | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| const size_t soc_model_length = strnlen(soc_model, CPUINFO_BUILD_PROP_VALUE_MAX); | |
| const char* soc_model_end = soc_model + soc_model_length; | |
| /* Check Qualcomm SMxxxx signature */ | |
| if (match_sm(soc_model, soc_model_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm SM signature in ro.soc.model string \"%.*s\"", | |
| (int)soc_model_length, | |
| soc_model); | |
| return chipset; | |
| } | |
| /* Check Qualcomm MSM/APQ signatures */ | |
| if (match_msm_apq(soc_model, soc_model_end, &chipset)) { | |
| cpuinfo_log_debug( | |
| "matched Qualcomm MSM/APQ signature in ro.soc.model string \"%.*s\"", | |
| (int)soc_model_length, | |
| soc_model); | |
| return chipset; | |
| } | |
| if (soc_model[0] != '\0') { | |
| if (strncmp(soc_model, "Tensor", 6) == 0) { | |
| chipset.vendor = cpuinfo_arm_chipset_vendor_google; | |
| chipset.series = cpuinfo_arm_chipset_series_google_tensor; | |
| const char* suffix_start = soc_model + 6; | |
| while (*suffix_start == ' ') { | |
| suffix_start++; | |
| } | |
| const size_t suffix_length = strnlen(suffix_start, CPUINFO_ARM_CHIPSET_SUFFIX_MAX); | |
| if (suffix_length > 0) { | |
| strncpy(chipset.suffix, suffix_start, suffix_length); | |
| } | |
| return chipset; | |
| } else if (strncmp(soc_model, "GS201", 5) == 0) { | |
| chipset.vendor = cpuinfo_arm_chipset_vendor_google; | |
| chipset.series = cpuinfo_arm_chipset_series_google_tensor; | |
| strncpy(chipset.suffix, "G2", 2); | |
| return chipset; | |
| } | |
| } | |
| return chipset; | |
| } | |
| #endif /* __ANDROID__ */ | |
| /* | |
| * Fix common bugs, typos, and renames in chipset name. | |
| * | |
| * @param[in,out] chipset - chipset name to fix. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| */ | |
| void cpuinfo_arm_fixup_chipset( | |
| struct cpuinfo_arm_chipset chipset[restrict static 1], | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max) { | |
| switch (chipset->series) { | |
| case cpuinfo_arm_chipset_series_qualcomm_msm: | |
| /* Check if there is suffix */ | |
| if (chipset->suffix[0] == 0) { | |
| /* No suffix, but the model may be misreported | |
| */ | |
| switch (chipset->model) { | |
| case 8216: | |
| /* MSM8216 was renamed to | |
| * MSM8916 */ | |
| cpuinfo_log_info("reinterpreted MSM8216 chipset as MSM8916"); | |
| chipset->model = 8916; | |
| break; | |
| case 8916: | |
| /* Common bug: MSM8939 | |
| * (Octa-core) reported as | |
| * MSM8916 (Quad-core) | |
| */ | |
| switch (cores) { | |
| case 4: | |
| break; | |
| case 8: | |
| cpuinfo_log_info( | |
| "reinterpreted MSM8916 chipset with 8 cores as MSM8939"); | |
| chipset->model = 8939; | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 | |
| "-core MSM%" PRIu32 " chipset", | |
| cores, | |
| chipset->model); | |
| chipset->model = 0; | |
| } | |
| break; | |
| case 8937: | |
| /* Common bug: MSM8917 | |
| * (Quad-core) reported as | |
| * MSM8937 (Octa-core) | |
| */ | |
| switch (cores) { | |
| case 4: | |
| cpuinfo_log_info( | |
| "reinterpreted MSM8937 chipset with 4 cores as MSM8917"); | |
| chipset->model = 8917; | |
| break; | |
| case 8: | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 | |
| "-core MSM%" PRIu32 " chipset", | |
| cores, | |
| chipset->model); | |
| chipset->model = 0; | |
| } | |
| break; | |
| case 8960: | |
| /* Common bug: APQ8064 | |
| * (Quad-core) reported as | |
| * MSM8960 (Dual-core) | |
| */ | |
| switch (cores) { | |
| case 2: | |
| break; | |
| case 4: | |
| cpuinfo_log_info( | |
| "reinterpreted MSM8960 chipset with 4 cores as APQ8064"); | |
| chipset->series = | |
| cpuinfo_arm_chipset_series_qualcomm_apq; | |
| chipset->model = 8064; | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 | |
| "-core MSM%" PRIu32 " chipset", | |
| cores, | |
| chipset->model); | |
| chipset->model = 0; | |
| } | |
| break; | |
| case 8996: | |
| /* Common bug: MSM8994 | |
| * (Octa-core) reported as | |
| * MSM8996 (Quad-core) | |
| */ | |
| switch (cores) { | |
| case 4: | |
| break; | |
| case 8: | |
| cpuinfo_log_info( | |
| "reinterpreted MSM8996 chipset with 8 cores as MSM8994"); | |
| chipset->model = 8994; | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 | |
| "-core MSM%" PRIu32 " chipset", | |
| cores, | |
| chipset->model); | |
| chipset->model = 0; | |
| } | |
| break; | |
| #if CPUINFO_ARCH_ARM | |
| case 8610: | |
| /* Common bug: MSM8612 | |
| * (Quad-core) reported as | |
| * MSM8610 (Dual-core) | |
| */ | |
| switch (cores) { | |
| case 2: | |
| break; | |
| case 4: | |
| cpuinfo_log_info( | |
| "reinterpreted MSM8610 chipset with 4 cores as MSM8612"); | |
| chipset->model = 8612; | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 | |
| "-core MSM%" PRIu32 " chipset", | |
| cores, | |
| chipset->model); | |
| chipset->model = 0; | |
| } | |
| break; | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| } | |
| } else { | |
| /* Suffix may need correction */ | |
| const uint32_t suffix_word = load_u32le(chipset->suffix); | |
| if (suffix_word == UINT32_C(0x004D534D) /* "\0MSM" = reverse("MSM\0") */) { | |
| /* | |
| * Common bug: model name repeated | |
| * twice, e.g. "MSM8916MSM8916" In this | |
| * case, model matching code parses the | |
| * second "MSM" as a suffix | |
| */ | |
| chipset->suffix[0] = 0; | |
| chipset->suffix[1] = 0; | |
| chipset->suffix[2] = 0; | |
| } else { | |
| switch (chipset->model) { | |
| case 8976: | |
| /* MSM8976SG -> | |
| * MSM8976PRO */ | |
| if (suffix_word == | |
| UINT32_C(0x00004753) /* "\0\0GS" = reverse("SG\0\0") */) { | |
| chipset->suffix[0] = 'P'; | |
| chipset->suffix[1] = 'R'; | |
| chipset->suffix[2] = 'O'; | |
| } | |
| break; | |
| case 8996: | |
| /* MSM8996PRO -> | |
| * MSM8996PRO-AB or | |
| * MSM8996PRO-AC */ | |
| if (suffix_word == | |
| UINT32_C(0x004F5250) /* "\0ORP" = reverse("PRO\0") */) { | |
| chipset->suffix[3] = '-'; | |
| chipset->suffix[4] = 'A'; | |
| chipset->suffix[5] = | |
| 'B' + (char)(max_cpu_freq_max >= 2188800); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| break; | |
| case cpuinfo_arm_chipset_series_qualcomm_apq: { | |
| /* Suffix may need correction */ | |
| const uint32_t expected_apq = load_u32le(chipset->suffix); | |
| if (expected_apq == UINT32_C(0x00515041) /* "\0QPA" = reverse("APQ\0") */) { | |
| /* | |
| * Common bug: model name repeated twice, e.g. | |
| * "APQ8016APQ8016" In this case, model matching | |
| * code parses the second "APQ" as a suffix | |
| */ | |
| chipset->suffix[0] = 0; | |
| chipset->suffix[1] = 0; | |
| chipset->suffix[2] = 0; | |
| } | |
| break; | |
| } | |
| case cpuinfo_arm_chipset_series_samsung_exynos: | |
| switch (chipset->model) { | |
| #if CPUINFO_ARCH_ARM | |
| case 4410: | |
| /* Exynos 4410 was renamed to Exynos | |
| * 4412 */ | |
| chipset->model = 4412; | |
| break; | |
| case 5420: | |
| /* Common bug: Exynos 5260 (Hexa-core) | |
| * reported as Exynos 5420 (Quad-core) | |
| */ | |
| switch (cores) { | |
| case 4: | |
| break; | |
| case 6: | |
| cpuinfo_log_info( | |
| "reinterpreted Exynos 5420 chipset with 6 cores as Exynos 5260"); | |
| chipset->model = 5260; | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 | |
| "-core Exynos 5420 chipset", | |
| cores); | |
| chipset->model = 0; | |
| } | |
| break; | |
| #endif /* CPUINFO_ARCH_ARM */ | |
| case 7580: | |
| /* Common bug: Exynos 7578 (Quad-core) | |
| * reported as Exynos 7580 (Octa-core) | |
| */ | |
| switch (cores) { | |
| case 4: | |
| cpuinfo_log_info( | |
| "reinterpreted Exynos 7580 chipset with 4 cores as Exynos 7578"); | |
| chipset->model = 7578; | |
| break; | |
| case 8: | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 | |
| "-core Exynos 7580 chipset", | |
| cores); | |
| chipset->model = 0; | |
| } | |
| break; | |
| } | |
| break; | |
| case cpuinfo_arm_chipset_series_mediatek_mt: | |
| if (chipset->model == 6752) { | |
| /* Common bug: MT6732 (Quad-core) reported as | |
| * MT6752 (Octa-core) */ | |
| switch (cores) { | |
| case 4: | |
| cpuinfo_log_info("reinterpreted MT6752 chipset with 4 cores as MT6732"); | |
| chipset->model = 6732; | |
| break; | |
| case 8: | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 "-core MT6752 chipset", | |
| cores); | |
| chipset->model = 0; | |
| } | |
| } | |
| if (chipset->suffix[0] == 'T') { | |
| /* Normalization: "TURBO" and "TRUBO" | |
| * (apparently a typo) -> "T" */ | |
| const uint32_t suffix_word = load_u32le(chipset->suffix + 1); | |
| switch (suffix_word) { | |
| case UINT32_C(0x4F425255): /* "OBRU" = | |
| reverse("URBO") | |
| */ | |
| case UINT32_C(0x4F425552): /* "OBUR" = | |
| reverse("RUBO") | |
| */ | |
| if (chipset->suffix[5] == 0) { | |
| chipset->suffix[1] = 0; | |
| chipset->suffix[2] = 0; | |
| chipset->suffix[3] = 0; | |
| chipset->suffix[4] = 0; | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case cpuinfo_arm_chipset_series_rockchip_rk: | |
| if (chipset->model == 3288) { | |
| /* Common bug: Rockchip RK3399 (Hexa-core) | |
| * always reported as RK3288 (Quad-core) */ | |
| switch (cores) { | |
| case 4: | |
| break; | |
| case 6: | |
| cpuinfo_log_info("reinterpreted RK3288 chipset with 6 cores as RK3399"); | |
| chipset->model = 3399; | |
| break; | |
| default: | |
| cpuinfo_log_warning( | |
| "system reported invalid %" PRIu32 "-core RK3288 chipset", | |
| cores); | |
| chipset->model = 0; | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| /* Map from ARM chipset vendor ID to its string representation */ | |
| static const char* chipset_vendor_string[cpuinfo_arm_chipset_vendor_max] = { | |
| [cpuinfo_arm_chipset_vendor_unknown] = "Unknown", | |
| [cpuinfo_arm_chipset_vendor_qualcomm] = "Qualcomm", | |
| [cpuinfo_arm_chipset_vendor_mediatek] = "MediaTek", | |
| [cpuinfo_arm_chipset_vendor_samsung] = "Samsung", | |
| [cpuinfo_arm_chipset_vendor_hisilicon] = "HiSilicon", | |
| [cpuinfo_arm_chipset_vendor_actions] = "Actions", | |
| [cpuinfo_arm_chipset_vendor_allwinner] = "Allwinner", | |
| [cpuinfo_arm_chipset_vendor_amlogic] = "Amlogic", | |
| [cpuinfo_arm_chipset_vendor_broadcom] = "Broadcom", | |
| [cpuinfo_arm_chipset_vendor_lg] = "LG", | |
| [cpuinfo_arm_chipset_vendor_leadcore] = "Leadcore", | |
| [cpuinfo_arm_chipset_vendor_marvell] = "Marvell", | |
| [cpuinfo_arm_chipset_vendor_mstar] = "MStar", | |
| [cpuinfo_arm_chipset_vendor_novathor] = "NovaThor", | |
| [cpuinfo_arm_chipset_vendor_nvidia] = "Nvidia", | |
| [cpuinfo_arm_chipset_vendor_pinecone] = "Pinecone", | |
| [cpuinfo_arm_chipset_vendor_renesas] = "Renesas", | |
| [cpuinfo_arm_chipset_vendor_rockchip] = "Rockchip", | |
| [cpuinfo_arm_chipset_vendor_spreadtrum] = "Spreadtrum", | |
| [cpuinfo_arm_chipset_vendor_telechips] = "Telechips", | |
| [cpuinfo_arm_chipset_vendor_texas_instruments] = "Texas Instruments", | |
| [cpuinfo_arm_chipset_vendor_unisoc] = "Unisoc", | |
| [cpuinfo_arm_chipset_vendor_wondermedia] = "WonderMedia", | |
| [cpuinfo_arm_chipset_vendor_google] = "Google", | |
| }; | |
| /* Map from ARM chipset series ID to its string representation */ | |
| static const char* chipset_series_string[cpuinfo_arm_chipset_series_max] = { | |
| [cpuinfo_arm_chipset_series_unknown] = NULL, | |
| [cpuinfo_arm_chipset_series_qualcomm_qsd] = "QSD", | |
| [cpuinfo_arm_chipset_series_qualcomm_msm] = "MSM", | |
| [cpuinfo_arm_chipset_series_qualcomm_apq] = "APQ", | |
| [cpuinfo_arm_chipset_series_qualcomm_snapdragon] = "Snapdragon ", | |
| [cpuinfo_arm_chipset_series_qualcomm_sm] = "SM", | |
| [cpuinfo_arm_chipset_series_mediatek_mt] = "MT", | |
| [cpuinfo_arm_chipset_series_samsung_exynos] = "Exynos ", | |
| [cpuinfo_arm_chipset_series_hisilicon_k3v] = "K3V", | |
| [cpuinfo_arm_chipset_series_hisilicon_hi] = "Hi", | |
| [cpuinfo_arm_chipset_series_hisilicon_kirin] = "Kirin ", | |
| [cpuinfo_arm_chipset_series_actions_atm] = "ATM", | |
| [cpuinfo_arm_chipset_series_allwinner_a] = "A", | |
| [cpuinfo_arm_chipset_series_amlogic_aml] = "AML", | |
| [cpuinfo_arm_chipset_series_amlogic_s] = "S", | |
| [cpuinfo_arm_chipset_series_broadcom_bcm] = "BCM", | |
| [cpuinfo_arm_chipset_series_lg_nuclun] = "Nuclun ", | |
| [cpuinfo_arm_chipset_series_leadcore_lc] = "LC", | |
| [cpuinfo_arm_chipset_series_marvell_pxa] = "PXA", | |
| [cpuinfo_arm_chipset_series_mstar_6a] = "6A", | |
| [cpuinfo_arm_chipset_series_novathor_u] = "U", | |
| [cpuinfo_arm_chipset_series_nvidia_tegra_t] = "Tegra T", | |
| [cpuinfo_arm_chipset_series_nvidia_tegra_ap] = "Tegra AP", | |
| [cpuinfo_arm_chipset_series_nvidia_tegra_sl] = "Tegra SL", | |
| [cpuinfo_arm_chipset_series_pinecone_surge_s] = "Surge S", | |
| [cpuinfo_arm_chipset_series_renesas_mp] = "MP", | |
| [cpuinfo_arm_chipset_series_rockchip_rk] = "RK", | |
| [cpuinfo_arm_chipset_series_spreadtrum_sc] = "SC", | |
| [cpuinfo_arm_chipset_series_telechips_tcc] = "TCC", | |
| [cpuinfo_arm_chipset_series_texas_instruments_omap] = "OMAP", | |
| [cpuinfo_arm_chipset_series_unisoc_t] = "T", | |
| [cpuinfo_arm_chipset_series_unisoc_ums] = "UMS", | |
| [cpuinfo_arm_chipset_series_wondermedia_wm] = "WM", | |
| [cpuinfo_arm_chipset_series_google_tensor] = "Tensor", | |
| }; | |
| /* Convert chipset name represented by cpuinfo_arm_chipset structure to a string | |
| * representation */ | |
| void cpuinfo_arm_chipset_to_string( | |
| const struct cpuinfo_arm_chipset chipset[restrict static 1], | |
| char name[restrict static CPUINFO_ARM_CHIPSET_NAME_MAX]) { | |
| enum cpuinfo_arm_chipset_vendor vendor = chipset->vendor; | |
| if (vendor >= cpuinfo_arm_chipset_vendor_max) { | |
| vendor = cpuinfo_arm_chipset_vendor_unknown; | |
| } | |
| enum cpuinfo_arm_chipset_series series = chipset->series; | |
| if (series >= cpuinfo_arm_chipset_series_max) { | |
| series = cpuinfo_arm_chipset_series_unknown; | |
| } | |
| const char* vendor_string = chipset_vendor_string[vendor]; | |
| const char* series_string = chipset_series_string[series]; | |
| const uint32_t model = chipset->model; | |
| const size_t suffix_length = strnlen(chipset->suffix, CPUINFO_ARM_CHIPSET_SUFFIX_MAX); | |
| if (model == 0) { | |
| if (suffix_length > 0) { | |
| if (series == cpuinfo_arm_chipset_series_unknown) { | |
| snprintf( | |
| name, | |
| CPUINFO_ARM_CHIPSET_NAME_MAX, | |
| "%s %.*s", | |
| vendor_string, | |
| (int)suffix_length, | |
| chipset->suffix); | |
| } else { | |
| snprintf( | |
| name, | |
| CPUINFO_ARM_CHIPSET_NAME_MAX, | |
| "%s %s %.*s", | |
| vendor_string, | |
| series_string, | |
| (int)suffix_length, | |
| chipset->suffix); | |
| } | |
| } else { | |
| if (series == cpuinfo_arm_chipset_series_unknown) { | |
| strncpy(name, vendor_string, CPUINFO_ARM_CHIPSET_NAME_MAX); | |
| } else { | |
| snprintf(name, CPUINFO_ARM_CHIPSET_NAME_MAX, "%s %s", vendor_string, series_string); | |
| } | |
| } | |
| } else { | |
| snprintf( | |
| name, | |
| CPUINFO_ARM_CHIPSET_NAME_MAX, | |
| "%s %s%" PRIu32 "%.*s", | |
| vendor_string, | |
| series_string, | |
| model, | |
| (int)suffix_length, | |
| chipset->suffix); | |
| } | |
| } | |
| #if defined(__ANDROID__) | |
| static inline struct cpuinfo_arm_chipset disambiguate_qualcomm_chipset( | |
| const struct cpuinfo_arm_chipset proc_cpuinfo_hardware_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_product_board_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_board_platform_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_chipname_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_hardware_chipname_chipset[restrict static 1]) { | |
| if (ro_hardware_chipname_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_hardware_chipname_chipset; | |
| } | |
| if (ro_chipname_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_chipname_chipset; | |
| } | |
| if (proc_cpuinfo_hardware_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *proc_cpuinfo_hardware_chipset; | |
| } | |
| if (ro_product_board_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_product_board_chipset; | |
| } | |
| return *ro_board_platform_chipset; | |
| } | |
| static inline struct cpuinfo_arm_chipset disambiguate_mediatek_chipset( | |
| const struct cpuinfo_arm_chipset proc_cpuinfo_hardware_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_product_board_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_board_platform_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_mediatek_platform_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_chipname_chipset[restrict static 1]) { | |
| if (ro_chipname_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_chipname_chipset; | |
| } | |
| if (proc_cpuinfo_hardware_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *proc_cpuinfo_hardware_chipset; | |
| } | |
| if (ro_product_board_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_product_board_chipset; | |
| } | |
| if (ro_board_platform_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_board_platform_chipset; | |
| } | |
| return *ro_mediatek_platform_chipset; | |
| } | |
| static inline struct cpuinfo_arm_chipset disambiguate_hisilicon_chipset( | |
| const struct cpuinfo_arm_chipset proc_cpuinfo_hardware_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_product_board_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_board_platform_chipset[restrict static 1]) { | |
| if (proc_cpuinfo_hardware_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *proc_cpuinfo_hardware_chipset; | |
| } | |
| if (ro_product_board_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_product_board_chipset; | |
| } | |
| return *ro_board_platform_chipset; | |
| } | |
| static inline struct cpuinfo_arm_chipset disambiguate_amlogic_chipset( | |
| const struct cpuinfo_arm_chipset proc_cpuinfo_hardware_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_board_platform_chipset[restrict static 1]) { | |
| if (proc_cpuinfo_hardware_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *proc_cpuinfo_hardware_chipset; | |
| } | |
| return *ro_board_platform_chipset; | |
| } | |
| static inline struct cpuinfo_arm_chipset disambiguate_marvell_chipset( | |
| const struct cpuinfo_arm_chipset proc_cpuinfo_hardware_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_product_board_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_chipname_chipset[restrict static 1]) { | |
| if (ro_chipname_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_chipname_chipset; | |
| } | |
| if (ro_product_board_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_product_board_chipset; | |
| } | |
| return *proc_cpuinfo_hardware_chipset; | |
| } | |
| static inline struct cpuinfo_arm_chipset disambiguate_rockchip_chipset( | |
| const struct cpuinfo_arm_chipset proc_cpuinfo_hardware_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_product_board_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_board_platform_chipset[restrict static 1]) { | |
| if (ro_product_board_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_product_board_chipset; | |
| } | |
| if (proc_cpuinfo_hardware_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *proc_cpuinfo_hardware_chipset; | |
| } | |
| return *ro_board_platform_chipset; | |
| } | |
| static inline struct cpuinfo_arm_chipset disambiguate_spreadtrum_chipset( | |
| const struct cpuinfo_arm_chipset proc_cpuinfo_hardware_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_product_board_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_board_platform_chipset[restrict static 1], | |
| const struct cpuinfo_arm_chipset ro_chipname_chipset[restrict static 1]) { | |
| if (ro_chipname_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_chipname_chipset; | |
| } | |
| if (ro_product_board_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *ro_product_board_chipset; | |
| } | |
| if (proc_cpuinfo_hardware_chipset->series != cpuinfo_arm_chipset_series_unknown) { | |
| return *proc_cpuinfo_hardware_chipset; | |
| } | |
| return *ro_board_platform_chipset; | |
| } | |
| static enum cpuinfo_arm_chipset_vendor disambiguate_chipset_vendor( | |
| enum cpuinfo_arm_chipset_vendor vendor_a, | |
| enum cpuinfo_arm_chipset_vendor vendor_b) { | |
| /* Some UNISOC-based platforms reporting conflicting vendor names depending | |
| * on the source. For phones that report both UNISOC and Spreadtrum, treat it | |
| * as UNISOC. */ | |
| if ((vendor_a == cpuinfo_arm_chipset_vendor_unisoc && vendor_b == cpuinfo_arm_chipset_vendor_spreadtrum) || | |
| (vendor_a == cpuinfo_arm_chipset_vendor_spreadtrum && vendor_b == cpuinfo_arm_chipset_vendor_unisoc)) { | |
| return cpuinfo_arm_chipset_vendor_unisoc; | |
| } | |
| return cpuinfo_arm_chipset_vendor_unknown; | |
| } | |
| /* | |
| * Decodes chipset name from Android system properties: | |
| * - /proc/cpuinfo Hardware string | |
| * - ro.product.board | |
| * - ro.board.platform | |
| * - ro.mediatek.platform | |
| * - ro.chipname | |
| * For some chipsets, the function relies frequency and on number of cores for | |
| * chipset detection. | |
| * | |
| * @param[in] properties - structure with the Android system properties | |
| * described above. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_android_decode_chipset( | |
| const struct cpuinfo_android_properties properties[restrict static 1], | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max) { | |
| struct cpuinfo_arm_chipset chipset = { | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| const bool tegra_platform = is_tegra( | |
| properties->ro_board_platform, | |
| properties->ro_board_platform + strnlen(properties->ro_board_platform, CPUINFO_BUILD_PROP_VALUE_MAX)); | |
| struct cpuinfo_arm_chipset chipsets[cpuinfo_android_chipset_property_max] = { | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware] = | |
| cpuinfo_arm_linux_decode_chipset_from_proc_cpuinfo_hardware( | |
| properties->proc_cpuinfo_hardware, cores, max_cpu_freq_max, tegra_platform), | |
| [cpuinfo_android_chipset_property_ro_product_board] = | |
| cpuinfo_arm_android_decode_chipset_from_ro_product_board( | |
| properties->ro_product_board, cores, max_cpu_freq_max), | |
| [cpuinfo_android_chipset_property_ro_board_platform] = | |
| cpuinfo_arm_android_decode_chipset_from_ro_board_platform( | |
| properties->ro_board_platform, cores, max_cpu_freq_max), | |
| [cpuinfo_android_chipset_property_ro_mediatek_platform] = | |
| cpuinfo_arm_android_decode_chipset_from_ro_mediatek_platform(properties->ro_mediatek_platform), | |
| [cpuinfo_android_chipset_property_ro_arch] = | |
| cpuinfo_arm_android_decode_chipset_from_ro_arch(properties->ro_arch), | |
| [cpuinfo_android_chipset_property_ro_chipname] = | |
| cpuinfo_arm_android_decode_chipset_from_ro_chipname(properties->ro_chipname), | |
| [cpuinfo_android_chipset_property_ro_hardware_chipname] = | |
| cpuinfo_arm_android_decode_chipset_from_ro_chipname(properties->ro_hardware_chipname), | |
| [cpuinfo_android_chipset_property_ro_soc_model] = | |
| cpuinfo_arm_android_decode_chipset_from_ro_soc_model(properties->ro_soc_model), | |
| }; | |
| enum cpuinfo_arm_chipset_vendor vendor = cpuinfo_arm_chipset_vendor_unknown; | |
| for (size_t i = 0; i < cpuinfo_android_chipset_property_max; i++) { | |
| const enum cpuinfo_arm_chipset_vendor decoded_vendor = chipsets[i].vendor; | |
| if (decoded_vendor != cpuinfo_arm_chipset_vendor_unknown) { | |
| if (vendor == cpuinfo_arm_chipset_vendor_unknown) { | |
| vendor = decoded_vendor; | |
| } else if (vendor != decoded_vendor) { | |
| /* Parsing different system properties produces | |
| * different chipset vendors. This situation is | |
| * rare. Try to disambiguate for known cases, | |
| * otherwise treat as unknown. */ | |
| enum cpuinfo_arm_chipset_vendor disambiguated_vendor = | |
| disambiguate_chipset_vendor(vendor, decoded_vendor); | |
| if (disambiguated_vendor != cpuinfo_arm_chipset_vendor_unknown) { | |
| vendor = disambiguated_vendor; | |
| } else { | |
| cpuinfo_log_error( | |
| "chipset detection failed: different chipset vendors reported in different system properties"); | |
| goto finish; | |
| } | |
| } | |
| } | |
| } | |
| if (vendor == cpuinfo_arm_chipset_vendor_unknown) { | |
| cpuinfo_log_warning("chipset detection failed: none of the system properties matched known signatures"); | |
| goto finish; | |
| } | |
| /* Fix common bugs in reported chipsets */ | |
| for (size_t i = 0; i < cpuinfo_android_chipset_property_max; i++) { | |
| cpuinfo_arm_fixup_chipset(&chipsets[i], cores, max_cpu_freq_max); | |
| } | |
| /* | |
| * Propagate suffixes: consider all pairs of chipsets, if both chipsets | |
| * in the pair are from the same series, and one's suffix is a prefix of | |
| * another's chipset suffix, use the longest suffix. | |
| */ | |
| for (size_t i = 0; i < cpuinfo_android_chipset_property_max; i++) { | |
| const size_t chipset_i_suffix_length = strnlen(chipsets[i].suffix, CPUINFO_ARM_CHIPSET_SUFFIX_MAX); | |
| for (size_t j = 0; j < i; j++) { | |
| if (chipsets[i].series == chipsets[j].series) { | |
| const size_t chipset_j_suffix_length = | |
| strnlen(chipsets[j].suffix, CPUINFO_ARM_CHIPSET_SUFFIX_MAX); | |
| if (chipset_i_suffix_length != chipset_j_suffix_length) { | |
| const size_t common_prefix_length = | |
| (chipset_i_suffix_length < chipset_j_suffix_length) | |
| ? chipset_i_suffix_length | |
| : chipset_j_suffix_length; | |
| if (common_prefix_length == 0 || | |
| memcmp(chipsets[i].suffix, chipsets[j].suffix, common_prefix_length) == 0) { | |
| if (chipset_i_suffix_length > chipset_j_suffix_length) { | |
| memcpy(chipsets[j].suffix, | |
| chipsets[i].suffix, | |
| chipset_i_suffix_length); | |
| } else { | |
| memcpy(chipsets[i].suffix, | |
| chipsets[j].suffix, | |
| chipset_j_suffix_length); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| for (size_t i = 0; i < cpuinfo_android_chipset_property_max; i++) { | |
| if (chipsets[i].series != cpuinfo_arm_chipset_series_unknown) { | |
| if (chipset.series == cpuinfo_arm_chipset_series_unknown) { | |
| chipset = chipsets[i]; | |
| } else if ( | |
| chipsets[i].series != chipset.series || chipsets[i].model != chipset.model || | |
| strncmp(chipsets[i].suffix, chipset.suffix, CPUINFO_ARM_CHIPSET_SUFFIX_MAX) != 0) { | |
| cpuinfo_log_info( | |
| "different chipsets reported in different system properties; " | |
| "vendor-specific disambiguation heuristic would be used"); | |
| switch (vendor) { | |
| case cpuinfo_arm_chipset_vendor_qualcomm: | |
| return disambiguate_qualcomm_chipset( | |
| &chipsets | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware], | |
| &chipsets[cpuinfo_android_chipset_property_ro_product_board], | |
| &chipsets[cpuinfo_android_chipset_property_ro_board_platform], | |
| &chipsets[cpuinfo_android_chipset_property_ro_chipname], | |
| &chipsets | |
| [cpuinfo_android_chipset_property_ro_hardware_chipname]); | |
| case cpuinfo_arm_chipset_vendor_mediatek: | |
| return disambiguate_mediatek_chipset( | |
| &chipsets | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware], | |
| &chipsets[cpuinfo_android_chipset_property_ro_product_board], | |
| &chipsets[cpuinfo_android_chipset_property_ro_board_platform], | |
| &chipsets | |
| [cpuinfo_android_chipset_property_ro_mediatek_platform], | |
| &chipsets[cpuinfo_android_chipset_property_ro_chipname]); | |
| case cpuinfo_arm_chipset_vendor_hisilicon: | |
| return disambiguate_hisilicon_chipset( | |
| &chipsets | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware], | |
| &chipsets[cpuinfo_android_chipset_property_ro_product_board], | |
| &chipsets[cpuinfo_android_chipset_property_ro_board_platform]); | |
| case cpuinfo_arm_chipset_vendor_amlogic: | |
| return disambiguate_amlogic_chipset( | |
| &chipsets | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware], | |
| &chipsets[cpuinfo_android_chipset_property_ro_board_platform]); | |
| case cpuinfo_arm_chipset_vendor_marvell: | |
| return disambiguate_marvell_chipset( | |
| &chipsets | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware], | |
| &chipsets[cpuinfo_android_chipset_property_ro_product_board], | |
| &chipsets[cpuinfo_android_chipset_property_ro_chipname]); | |
| case cpuinfo_arm_chipset_vendor_rockchip: | |
| return disambiguate_rockchip_chipset( | |
| &chipsets | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware], | |
| &chipsets[cpuinfo_android_chipset_property_ro_product_board], | |
| &chipsets[cpuinfo_android_chipset_property_ro_board_platform]); | |
| case cpuinfo_arm_chipset_vendor_spreadtrum: | |
| return disambiguate_spreadtrum_chipset( | |
| &chipsets | |
| [cpuinfo_android_chipset_property_proc_cpuinfo_hardware], | |
| &chipsets[cpuinfo_android_chipset_property_ro_product_board], | |
| &chipsets[cpuinfo_android_chipset_property_ro_board_platform], | |
| &chipsets[cpuinfo_android_chipset_property_ro_chipname]); | |
| default: | |
| cpuinfo_log_error( | |
| "chipset detection failed: " | |
| "could not disambiguate different chipsets reported in different system properties"); | |
| /* chipset variable contains | |
| * valid, but inconsistent | |
| * chipset information, | |
| * overwrite it */ | |
| chipset = (struct cpuinfo_arm_chipset){ | |
| .vendor = cpuinfo_arm_chipset_vendor_unknown, | |
| .series = cpuinfo_arm_chipset_series_unknown, | |
| }; | |
| goto finish; | |
| } | |
| } | |
| } | |
| } | |
| finish: | |
| return chipset; | |
| } | |
| #else /* !defined(__ANDROID__) */ | |
| /* | |
| * Fix commonly misreported Broadcom BCM models on Raspberry Pi boards. | |
| * | |
| * @param[in,out] chipset - chipset name to fix. | |
| * @param[in] revision - /proc/cpuinfo Revision string. | |
| */ | |
| void cpuinfo_arm_fixup_raspberry_pi_chipset( | |
| struct cpuinfo_arm_chipset chipset[restrict static 1], | |
| const char revision[restrict static CPUINFO_REVISION_VALUE_MAX]) { | |
| const size_t revision_length = strnlen(revision, CPUINFO_REVISION_VALUE_MAX); | |
| /* Parse revision codes according to | |
| * https://www.raspberrypi.org/documentation/hardware/raspberrypi/revision-codes/README.md | |
| */ | |
| #if CPUINFO_ARCH_ARM | |
| if (revision_length == 4) { | |
| /* | |
| * Old-style revision codes. | |
| * All Raspberry Pi models with old-style revision code use | |
| * Broadcom BCM2835. | |
| */ | |
| /* BCM2835 often misreported as BCM2708 */ | |
| if (chipset->model == 2708) { | |
| chipset->model = 2835; | |
| } | |
| return; | |
| } | |
| #endif | |
| if ((size_t)(revision_length - 5) <= (size_t)(8 - 5) /* 5 <= length(revision) <= 8 */) { | |
| /* New-style revision codes */ | |
| uint32_t model = 0; | |
| switch (revision[revision_length - 4]) { | |
| case '0': | |
| /* BCM2835 */ | |
| model = 2835; | |
| break; | |
| case '1': | |
| /* BCM2836 */ | |
| model = 2836; | |
| break; | |
| case '2': | |
| /* BCM2837 */ | |
| model = 2837; | |
| break; | |
| case '3': | |
| /* BCM2711 */ | |
| model = 2711; | |
| break; | |
| } | |
| if (model != 0) { | |
| chipset->model = model; | |
| chipset->suffix[0] = 0; | |
| } | |
| } | |
| } | |
| /* | |
| * Decodes chipset name from /proc/cpuinfo Hardware string. | |
| * For some chipsets, the function relies frequency and on number of cores for | |
| * chipset detection. | |
| * | |
| * @param[in] hardware - /proc/cpuinfo Hardware string. | |
| * @param cores - number of cores in the chipset. | |
| * @param max_cpu_freq_max - maximum of | |
| * /sys/devices/system/cpu/cpu<number>/cpufreq/cpu_freq_max values. | |
| * | |
| * @returns Decoded chipset name. If chipset could not be decoded, the resulting | |
| * structure would use `unknown` vendor and series identifiers. | |
| */ | |
| struct cpuinfo_arm_chipset cpuinfo_arm_linux_decode_chipset( | |
| const char hardware[restrict static CPUINFO_HARDWARE_VALUE_MAX], | |
| const char revision[restrict static CPUINFO_REVISION_VALUE_MAX], | |
| uint32_t cores, | |
| uint32_t max_cpu_freq_max) { | |
| struct cpuinfo_arm_chipset chipset = | |
| cpuinfo_arm_linux_decode_chipset_from_proc_cpuinfo_hardware(hardware, cores, max_cpu_freq_max, false); | |
| if (chipset.vendor == cpuinfo_arm_chipset_vendor_unknown) { | |
| cpuinfo_log_warning( | |
| "chipset detection failed: /proc/cpuinfo Hardware string did not match known signatures"); | |
| } else if (chipset.vendor == cpuinfo_arm_chipset_vendor_broadcom) { | |
| /* Raspberry Pi kernel reports bogus chipset models; detect | |
| * chipset from RPi revision */ | |
| cpuinfo_arm_fixup_raspberry_pi_chipset(&chipset, revision); | |
| } else { | |
| cpuinfo_arm_fixup_chipset(&chipset, cores, max_cpu_freq_max); | |
| } | |
| return chipset; | |
| } | |
| #endif |