drivers/soc/amlogic/meson-gx-socinfo.c - manifest_repos/kernel - Git at Google

 /*
  * Copyright (c) 2017 BayLibre, SAS
  * Author: Neil Armstrong <narmstrong@baylibre.com>
  *
  * SPDX-License-Identifier: GPL-2.0+
  */

 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/sys_soc.h>
 #include <linux/bitfield.h>
 #include <linux/regmap.h>
 #include <linux/mfd/syscon.h>
 #include <linux/arm-smccc.h>
 #include <linux/amlogic/cpu_version.h>


 #define AO_SEC_SD_CFG8		0xe0
 #define AO_SEC_SOCINFO_OFFSET	AO_SEC_SD_CFG8
 #ifdef CONFIG_AMLOGIC_MODIFY
 #define GET_SHARE_MEM_OUTPUT_BASE	(0x82000021)
 #define GET_CHIP_ID			(0x82000044)
 unsigned char cpuinfo_chipid[16] = { 0 };
 #endif

 #define SOCINFO_MAJOR	GENMASK(31, 24)
 #define SOCINFO_PACK	GENMASK(23, 16)
 #define SOCINFO_MINOR	GENMASK(15, 8)
 #define SOCINFO_MISC	GENMASK(7, 0)

 static const struct meson_gx_soc_id {
 	const char *name;
 	unsigned int id;
 } soc_ids[] = {
 	{ "GXBB", 0x1f },
 	{ "GXTVBB", 0x20 },
 	{ "GXL", 0x21 },
 	{ "GXM", 0x22 },
 	{ "TXL", 0x23 },
 	{ "TXLX", 0x24 },
 	{ "AXG", 0x25 },
 	{ "GXLX", 0x26 },
 	{ "TXHD", 0x27 },
 };

 static const struct meson_gx_package_id {
 	const char *name;
 	unsigned int major_id;
 	unsigned int pack_id;
 	unsigned int pack_mask;
 } soc_packages[] = {
 	{ "S905", 0x1f, 0, 0x20 }, /* pack_id != 0x20 */
 	{ "S905H", 0x1f, 0x3, 0xf }, /* pack_id & 0xf == 0x3 */
 	{ "S905M", 0x1f, 0x20, 0xf0 }, /* pack_id == 0x20 */
 	{ "S905D", 0x21, 0, 0xf0 },
 	{ "S905X", 0x21, 0x80, 0xf0 },
 	{ "S905W", 0x21, 0xa0, 0xf0 },
 	{ "S905L", 0x21, 0xc0, 0xf0 },
 	{ "S905M2", 0x21, 0xe0, 0xf0 },
 	{ "S912", 0x22, 0, 0x0 }, /* Only S912 is known for GXM */
 	{ "962X", 0x24, 0x10, 0xf0 },
 	{ "962E", 0x24, 0x20, 0xf0 },
 	{ "A113X", 0x25, 0x37, 0xff },
 	{ "A113D", 0x25, 0x22, 0xff },
 };

 #ifndef CONFIG_AMLOGIC_MODIFY
 static inline unsigned int socinfo_to_major(u32 socinfo)
 {
 	return FIELD_GET(SOCINFO_MAJOR, socinfo);
 }

 static inline unsigned int socinfo_to_minor(u32 socinfo)
 {
 	return FIELD_GET(SOCINFO_MINOR, socinfo);
 }

 static inline unsigned int socinfo_to_pack(u32 socinfo)
 {
 	return FIELD_GET(SOCINFO_PACK, socinfo);
 }

 static inline unsigned int socinfo_to_misc(u32 socinfo)
 {
 	return FIELD_GET(SOCINFO_MISC, socinfo);
 }

 static const char *socinfo_to_package_id(u32 socinfo)
 {
 	unsigned int pack = socinfo_to_pack(socinfo);
 	unsigned int major = socinfo_to_major(socinfo);
 	int i;

 	for (i = 0 ; i < ARRAY_SIZE(soc_packages) ; ++i) {
 		if (soc_packages[i].major_id == major &&
 		    soc_packages[i].pack_id ==
 				(pack & soc_packages[i].pack_mask))
 			return soc_packages[i].name;
 	}

 	return "Unknown";
 }

 static const char *socinfo_to_soc_id(u32 socinfo)
 {
 	unsigned int id = socinfo_to_major(socinfo);
 	int i;

 	for (i = 0 ; i < ARRAY_SIZE(soc_ids) ; ++i) {
 		if (soc_ids[i].id == id)
 			return soc_ids[i].name;
 	}

 	return "Unknown";
 }
 #endif

 #ifdef CONFIG_AMLOGIC_MODIFY
 static DEFINE_MUTEX(socinfo_lock);

 static unsigned long get_sharemem_info(unsigned long function_id)
 {
 	struct arm_smccc_res res;

 	arm_smccc_smc((unsigned long)function_id, 0, 0, 0, 0, 0, 0, 0, &res);

 	return res.a0;
 }

 static ssize_t meson_get_chip_id(unsigned char *buff, unsigned int size)
 {
 	long ret;
 	struct arm_smccc_res res;
 	void *sharemem_out_base;
 	long phy_out_base = 0;

 	mutex_lock(&socinfo_lock);

 	phy_out_base = get_sharemem_info(GET_SHARE_MEM_OUTPUT_BASE);

 	if (!valid_phys_addr_range(phy_out_base, size))
 		sharemem_out_base = ioremap_nocache(phy_out_base, size);
 	else
 		sharemem_out_base = phys_to_virt(phy_out_base);

 	arm_smccc_smc(GET_CHIP_ID, 2, 0, 0, 0, 0, 0, 0, &res);
 	ret = res.a0;
 	if (ret == 0) {
 		int version = *((unsigned int *)sharemem_out_base);

 		if (version == 2) {
 			memcpy((void *)&buff[0],
 			       (void *)sharemem_out_base + 4,
 			       16);
 		} else {
 			/**
 			 * Legacy 12-byte chip ID read out, transform data
 			 * to expected order format.
 			 */
 			u8 *ch;
 			int i;

 			buff[0] = get_meson_cpu_version
 				(MESON_CPU_VERSION_LVL_MAJOR);
 			buff[1] = get_meson_cpu_version
 				(MESON_CPU_VERSION_LVL_MINOR);
 			buff[2] = get_meson_cpu_version
 				(MESON_CPU_VERSION_LVL_PACK);
 			buff[3] = 0;

 			/* Transform into expected order for display */
 			ch = (uint8_t *)(sharemem_out_base + 4);
 			for (i = 0; i < 12; i++)
 				buff[i + 4] = ch[11 - i];
 		}
 	}

 	if (!valid_phys_addr_range(phy_out_base, ret))
 		iounmap(sharemem_out_base);

 	mutex_unlock(&socinfo_lock);

 	if (!ret)
 		return -1;

 	return ret;
 }

 void cpuinfo_get_chipid(unsigned char *cid, unsigned int size)
 {
 	memcpy(&cid[0], cpuinfo_chipid, size);
 }
 #endif

 static int __init meson_gx_socinfo_init(void)
 {
 	struct device_node *np;
 #ifndef CONFIG_AMLOGIC_MODIFY
 	struct soc_device_attribute *soc_dev_attr;
 	struct soc_device *soc_dev;
 	struct regmap *regmap;
 	unsigned int socinfo;
 	struct device *dev;
 	int ret;
 #endif

 	/* look up for chipid node */
 	np = of_find_compatible_node(NULL, NULL, "amlogic,meson-gx-ao-secure");
 	if (!np)
 		return -ENODEV;

 	/* check if interface is enabled */
 	if (!of_device_is_available(np))
 		return -ENODEV;

 	/* check if chip-id is available */
 	if (!of_property_read_bool(np, "amlogic,has-chip-id"))
 		return -ENODEV;
 #ifdef CONFIG_AMLOGIC_MODIFY
 	return meson_get_chip_id(cpuinfo_chipid, 16);
 #else
 	/* node should be a syscon */
 	regmap = syscon_node_to_regmap(np);
 	of_node_put(np);
 	if (IS_ERR(regmap)) {
 		pr_err("%s: failed to get regmap\n", __func__);
 		return -ENODEV;
 	}

 	ret = regmap_read(regmap, AO_SEC_SOCINFO_OFFSET, &socinfo);
 	if (ret < 0)
 		return ret;

 	if (!socinfo) {
 		pr_err("%s: invalid chipid value\n", __func__);
 		return -EINVAL;
 	}

 	soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
 	if (!soc_dev_attr)
 		return -ENODEV;

 	soc_dev_attr->family = "Amlogic Meson";

 	np = of_find_node_by_path("/");
 	of_property_read_string(np, "model", &soc_dev_attr->machine);
 	of_node_put(np);

 	soc_dev_attr->revision = kasprintf(GFP_KERNEL, "%x:%x - %x:%x",
 					   socinfo_to_major(socinfo),
 					   socinfo_to_minor(socinfo),
 					   socinfo_to_pack(socinfo),
 					   socinfo_to_misc(socinfo));
 	soc_dev_attr->soc_id = kasprintf(GFP_KERNEL, "%s (%s)",
 					 socinfo_to_soc_id(socinfo),
 					 socinfo_to_package_id(socinfo));

 	soc_dev = soc_device_register(soc_dev_attr);
 	if (IS_ERR(soc_dev)) {
 		kfree(soc_dev_attr->revision);
 		kfree_const(soc_dev_attr->soc_id);
 		kfree(soc_dev_attr);
 		return PTR_ERR(soc_dev);
 	}
 	dev = soc_device_to_device(soc_dev);

 	dev_info(dev, "Amlogic Meson %s Revision %x:%x (%x:%x) Detected\n",
 			soc_dev_attr->soc_id,
 			socinfo_to_major(socinfo),
 			socinfo_to_minor(socinfo),
 			socinfo_to_pack(socinfo),
 			socinfo_to_misc(socinfo));

 	return 0;
 #endif
 }
 device_initcall(meson_gx_socinfo_init);
	/*
	* Copyright (c) 2017 BayLibre, SAS
	* Author: Neil Armstrong <narmstrong@baylibre.com>
	*
	* SPDX-License-Identifier: GPL-2.0+
	*/

	#include <linux/io.h>
	#include <linux/of.h>
	#include <linux/of_address.h>
	#include <linux/of_platform.h>
	#include <linux/platform_device.h>
	#include <linux/slab.h>
	#include <linux/sys_soc.h>
	#include <linux/bitfield.h>
	#include <linux/regmap.h>
	#include <linux/mfd/syscon.h>
	#include <linux/arm-smccc.h>
	#include <linux/amlogic/cpu_version.h>


	#define AO_SEC_SD_CFG8 0xe0
	#define AO_SEC_SOCINFO_OFFSET AO_SEC_SD_CFG8
	#ifdef CONFIG_AMLOGIC_MODIFY
	#define GET_SHARE_MEM_OUTPUT_BASE (0x82000021)
	#define GET_CHIP_ID (0x82000044)
	unsigned char cpuinfo_chipid[16] = { 0 };
	#endif

	#define SOCINFO_MAJOR GENMASK(31, 24)
	#define SOCINFO_PACK GENMASK(23, 16)
	#define SOCINFO_MINOR GENMASK(15, 8)
	#define SOCINFO_MISC GENMASK(7, 0)

	static const struct meson_gx_soc_id {
	const char *name;
	unsigned int id;
	} soc_ids[] = {
	{ "GXBB", 0x1f },
	{ "GXTVBB", 0x20 },
	{ "GXL", 0x21 },
	{ "GXM", 0x22 },
	{ "TXL", 0x23 },
	{ "TXLX", 0x24 },
	{ "AXG", 0x25 },
	{ "GXLX", 0x26 },
	{ "TXHD", 0x27 },
	};

	static const struct meson_gx_package_id {
	const char *name;
	unsigned int major_id;
	unsigned int pack_id;
	unsigned int pack_mask;
	} soc_packages[] = {
	{ "S905", 0x1f, 0, 0x20 }, /* pack_id != 0x20 */
	{ "S905H", 0x1f, 0x3, 0xf }, /* pack_id & 0xf == 0x3 */
	{ "S905M", 0x1f, 0x20, 0xf0 }, /* pack_id == 0x20 */
	{ "S905D", 0x21, 0, 0xf0 },
	{ "S905X", 0x21, 0x80, 0xf0 },
	{ "S905W", 0x21, 0xa0, 0xf0 },
	{ "S905L", 0x21, 0xc0, 0xf0 },
	{ "S905M2", 0x21, 0xe0, 0xf0 },
	{ "S912", 0x22, 0, 0x0 }, /* Only S912 is known for GXM */
	{ "962X", 0x24, 0x10, 0xf0 },
	{ "962E", 0x24, 0x20, 0xf0 },
	{ "A113X", 0x25, 0x37, 0xff },
	{ "A113D", 0x25, 0x22, 0xff },
	};

	#ifndef CONFIG_AMLOGIC_MODIFY
	static inline unsigned int socinfo_to_major(u32 socinfo)
	{
	return FIELD_GET(SOCINFO_MAJOR, socinfo);
	}

	static inline unsigned int socinfo_to_minor(u32 socinfo)
	{
	return FIELD_GET(SOCINFO_MINOR, socinfo);
	}

	static inline unsigned int socinfo_to_pack(u32 socinfo)
	{
	return FIELD_GET(SOCINFO_PACK, socinfo);
	}

	static inline unsigned int socinfo_to_misc(u32 socinfo)
	{
	return FIELD_GET(SOCINFO_MISC, socinfo);
	}

	static const char *socinfo_to_package_id(u32 socinfo)
	{
	unsigned int pack = socinfo_to_pack(socinfo);
	unsigned int major = socinfo_to_major(socinfo);
	int i;

	for (i = 0 ; i < ARRAY_SIZE(soc_packages) ; ++i) {
	if (soc_packages[i].major_id == major &&
	soc_packages[i].pack_id ==
	(pack & soc_packages[i].pack_mask))
	return soc_packages[i].name;
	}

	return "Unknown";
	}

	static const char *socinfo_to_soc_id(u32 socinfo)
	{
	unsigned int id = socinfo_to_major(socinfo);
	int i;

	for (i = 0 ; i < ARRAY_SIZE(soc_ids) ; ++i) {
	if (soc_ids[i].id == id)
	return soc_ids[i].name;
	}

	return "Unknown";
	}
	#endif

	#ifdef CONFIG_AMLOGIC_MODIFY
	static DEFINE_MUTEX(socinfo_lock);

	static unsigned long get_sharemem_info(unsigned long function_id)
	{
	struct arm_smccc_res res;

	arm_smccc_smc((unsigned long)function_id, 0, 0, 0, 0, 0, 0, 0, &res);

	return res.a0;
	}

	static ssize_t meson_get_chip_id(unsigned char *buff, unsigned int size)
	{
	long ret;
	struct arm_smccc_res res;
	void *sharemem_out_base;
	long phy_out_base = 0;

	mutex_lock(&socinfo_lock);

	phy_out_base = get_sharemem_info(GET_SHARE_MEM_OUTPUT_BASE);

	if (!valid_phys_addr_range(phy_out_base, size))
	sharemem_out_base = ioremap_nocache(phy_out_base, size);
	else
	sharemem_out_base = phys_to_virt(phy_out_base);

	arm_smccc_smc(GET_CHIP_ID, 2, 0, 0, 0, 0, 0, 0, &res);
	ret = res.a0;
	if (ret == 0) {
	int version = ((unsigned int )sharemem_out_base);

	if (version == 2) {
	memcpy((void *)&buff[0],
	(void *)sharemem_out_base + 4,
	16);
	} else {
	/**
	* Legacy 12-byte chip ID read out, transform data
	* to expected order format.
	*/
	u8 *ch;
	int i;

	buff[0] = get_meson_cpu_version
	(MESON_CPU_VERSION_LVL_MAJOR);
	buff[1] = get_meson_cpu_version
	(MESON_CPU_VERSION_LVL_MINOR);
	buff[2] = get_meson_cpu_version
	(MESON_CPU_VERSION_LVL_PACK);
	buff[3] = 0;

	/* Transform into expected order for display */
	ch = (uint8_t *)(sharemem_out_base + 4);
	for (i = 0; i < 12; i++)
	buff[i + 4] = ch[11 - i];
	}
	}

	if (!valid_phys_addr_range(phy_out_base, ret))
	iounmap(sharemem_out_base);

	mutex_unlock(&socinfo_lock);

	if (!ret)
	return -1;

	return ret;
	}

	void cpuinfo_get_chipid(unsigned char *cid, unsigned int size)
	{
	memcpy(&cid[0], cpuinfo_chipid, size);
	}
	#endif

	static int __init meson_gx_socinfo_init(void)
	{
	struct device_node *np;
	#ifndef CONFIG_AMLOGIC_MODIFY
	struct soc_device_attribute *soc_dev_attr;
	struct soc_device *soc_dev;
	struct regmap *regmap;
	unsigned int socinfo;
	struct device *dev;
	int ret;
	#endif

	/* look up for chipid node */
	np = of_find_compatible_node(NULL, NULL, "amlogic,meson-gx-ao-secure");
	if (!np)
	return -ENODEV;

	/* check if interface is enabled */
	if (!of_device_is_available(np))
	return -ENODEV;

	/* check if chip-id is available */
	if (!of_property_read_bool(np, "amlogic,has-chip-id"))
	return -ENODEV;
	#ifdef CONFIG_AMLOGIC_MODIFY
	return meson_get_chip_id(cpuinfo_chipid, 16);
	#else
	/* node should be a syscon */
	regmap = syscon_node_to_regmap(np);
	of_node_put(np);
	if (IS_ERR(regmap)) {
	pr_err("%s: failed to get regmap\n", __func__);
	return -ENODEV;
	}

	ret = regmap_read(regmap, AO_SEC_SOCINFO_OFFSET, &socinfo);
	if (ret < 0)
	return ret;

	if (!socinfo) {
	pr_err("%s: invalid chipid value\n", __func__);
	return -EINVAL;
	}

	soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
	if (!soc_dev_attr)
	return -ENODEV;

	soc_dev_attr->family = "Amlogic Meson";

	np = of_find_node_by_path("/");
	of_property_read_string(np, "model", &soc_dev_attr->machine);
	of_node_put(np);

	soc_dev_attr->revision = kasprintf(GFP_KERNEL, "%x:%x - %x:%x",
	socinfo_to_major(socinfo),
	socinfo_to_minor(socinfo),
	socinfo_to_pack(socinfo),
	socinfo_to_misc(socinfo));
	soc_dev_attr->soc_id = kasprintf(GFP_KERNEL, "%s (%s)",
	socinfo_to_soc_id(socinfo),
	socinfo_to_package_id(socinfo));

	soc_dev = soc_device_register(soc_dev_attr);
	if (IS_ERR(soc_dev)) {
	kfree(soc_dev_attr->revision);
	kfree_const(soc_dev_attr->soc_id);
	kfree(soc_dev_attr);
	return PTR_ERR(soc_dev);
	}
	dev = soc_device_to_device(soc_dev);

	dev_info(dev, "Amlogic Meson %s Revision %x:%x (%x:%x) Detected\n",
	soc_dev_attr->soc_id,
	socinfo_to_major(socinfo),
	socinfo_to_minor(socinfo),
	socinfo_to_pack(socinfo),
	socinfo_to_misc(socinfo));

	return 0;
	#endif
	}
	device_initcall(meson_gx_socinfo_init);