/* SPDX-License-Identifier: GPL-2.0-or-later */

#define __SIMPLE_DEVICE__

#include <assert.h>
#include <bootstate.h>
#include <console/console.h>
#include <device/device.h>
#include <fsp/debug.h>
#include <intelblocks/cpulib.h>
#include <intelblocks/gpio.h>
#include <gpio.h>
#include <intelblocks/itss.h>
#include <intelblocks/p2sb.h>
#include <intelblocks/pcr.h>
#include <security/vboot/vboot_common.h>
#include <soc/pci_devs.h>
#include <soc/pm.h>
#include <stdlib.h>
#include <types.h>

#define GPIO_DWx_SIZE(x)	(sizeof(uint32_t) * (x))
#define PAD_CFG_OFFSET(x, dw_num)	((x) + GPIO_DWx_SIZE(dw_num))
#define PAD_CFG0_OFFSET(x)	PAD_CFG_OFFSET(x, 0)
#define PAD_CFG1_OFFSET(x)	PAD_CFG_OFFSET(x, 1)
#define PAD_CFG2_OFFSET(x)	PAD_CFG_OFFSET(x, 2)
#define PAD_CFG3_OFFSET(x)	PAD_CFG_OFFSET(x, 3)

#define PAD_DW0_MASK	(PAD_CFG0_TX_STATE |				\
	PAD_CFG0_TX_DISABLE | PAD_CFG0_RX_DISABLE | PAD_CFG0_MODE_MASK |\
	PAD_CFG0_ROUTE_MASK | PAD_CFG0_RXTENCFG_MASK |			\
	PAD_CFG0_RXINV_MASK | PAD_CFG0_PREGFRXSEL |			\
	PAD_CFG0_TRIG_MASK | PAD_CFG0_RXRAW1_MASK | PAD_CFG0_NAFVWE_ENABLE |\
	PAD_CFG0_RXPADSTSEL_MASK | PAD_CFG0_RESET_MASK)

#if CONFIG(SOC_INTEL_COMMON_BLOCK_GPIO_PADCFG_PADTOL)
#define PAD_DW1_MASK	(PAD_CFG1_IOSTERM_MASK |			\
			PAD_CFG1_PULL_MASK |				\
			PAD_CFG1_TOL_MASK |				\
			PAD_CFG1_IOSSTATE_MASK)
#else
#define PAD_DW1_MASK	(PAD_CFG1_IOSTERM_MASK |			\
			PAD_CFG1_PULL_MASK |				\
			PAD_CFG1_IOSSTATE_MASK)
#endif

#define PAD_DW2_MASK	(PAD_CFG2_DEBOUNCE_MASK)
#define PAD_DW3_MASK	(0)

#define MISCCFG_GPE0_DW0_SHIFT 8
#define MISCCFG_GPE0_DW0_MASK (0xf << MISCCFG_GPE0_DW0_SHIFT)
#define MISCCFG_GPE0_DW1_SHIFT 12
#define MISCCFG_GPE0_DW1_MASK (0xf << MISCCFG_GPE0_DW1_SHIFT)
#define MISCCFG_GPE0_DW2_SHIFT 16
#define MISCCFG_GPE0_DW2_MASK (0xf << MISCCFG_GPE0_DW2_SHIFT)

#define GPI_SMI_STS_OFFSET(comm, group) ((comm)->gpi_smi_sts_reg_0 +	\
				((group) * sizeof(uint32_t)))
#define GPI_SMI_EN_OFFSET(comm, group) ((comm)->gpi_smi_en_reg_0 +	\
				((group) * sizeof(uint32_t)))
#define GPI_NMI_STS_OFFSET(comm, group) ((comm)->gpi_nmi_sts_reg_0 +	\
				((group) * sizeof(uint32_t)))
#define GPI_NMI_EN_OFFSET(comm, group) ((comm)->gpi_nmi_en_reg_0 +	\
				((group) * sizeof(uint32_t)))
#define GPI_IS_OFFSET(comm, group) ((comm)->gpi_int_sts_reg_0 +	\
				((group) * sizeof(uint32_t)))
#define GPI_IE_OFFSET(comm, group) ((comm)->gpi_int_en_reg_0 +	\
				((group) * sizeof(uint32_t)))
#define GPI_GPE_STS_OFFSET(comm, group) ((comm)->gpi_gpe_sts_reg_0 +	\
				((group) * sizeof(uint32_t)))
#define GPI_GPE_EN_OFFSET(comm, group) ((comm)->gpi_gpe_en_reg_0 +	\
				((group) * sizeof(uint32_t)))

static inline size_t relative_pad_in_comm(const struct pad_community *comm,
						gpio_t gpio)
{
	return gpio - comm->first_pad;
}

/* find the group within the community that the pad is a part of */
static inline size_t gpio_group_index(const struct pad_community *comm,
					unsigned int relative_pad)
{
	size_t i;

	if (!comm->groups)
		die("Failed to get comm->groups.");

	/* find the base pad number for this pad's group */
	for (i = 0; i < comm->num_groups; i++) {
		if (relative_pad >= comm->groups[i].first_pad &&
			relative_pad < comm->groups[i].first_pad +
			comm->groups[i].size) {
			return i;
		}
	}
	printk(BIOS_ERR, "%s: pad %d is not found in community %s!\n",
			__func__, relative_pad, comm->name);
	BUG();

	return i;
}

static inline size_t gpio_group_index_scaled(const struct pad_community *comm,
					unsigned int relative_pad, size_t scale)
{
	return gpio_group_index(comm, relative_pad) * scale;
}

static inline size_t gpio_within_group(const struct pad_community *comm,
						unsigned int relative_pad)
{
	size_t i;

	i = gpio_group_index(comm, relative_pad);

	return relative_pad - comm->groups[i].first_pad;
}

static inline uint32_t gpio_bitmask_within_group(
					const struct pad_community *comm,
					unsigned int relative_pad)
{
	return 1U << gpio_within_group(comm, relative_pad);
}

static const struct pad_community *gpio_get_community(gpio_t pad)
{
	size_t gpio_communities;
	size_t i;
	const struct pad_community *comm;
	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0; i < gpio_communities; i++, comm++) {
		if (pad >= comm->first_pad && pad <= comm->last_pad)
			return comm;
	}
	printk(BIOS_ERR, "%s pad %d not found\n", __func__, pad);
	die("Invalid GPIO pad number\n");
	return NULL;
}

static void gpio_configure_owner(const struct pad_config *cfg,
				const struct pad_community *comm)
{
	uint32_t hostsw_own;
	uint16_t hostsw_own_offset;
	int pin;

	pin = relative_pad_in_comm(comm, cfg->pad);

	/* Based on the gpio pin number configure the corresponding bit in
	 * HOSTSW_OWN register. Value of 0x1 indicates GPIO Driver onwership.
	 */
	hostsw_own_offset = comm->host_own_reg_0;
	hostsw_own_offset += gpio_group_index_scaled(comm, pin,
		sizeof(uint32_t));

	hostsw_own = pcr_read32(comm->port, hostsw_own_offset);

	/* The 4th bit in pad_config 1 (RO) is used to indicate if the pad
	 * needs GPIO driver ownership.  Set the bit if GPIO driver ownership
	 * requested, otherwise clear the bit.
	 */
	if (cfg->pad_config[1] & PAD_CFG_OWN_GPIO_DRIVER)
		hostsw_own |= gpio_bitmask_within_group(comm, pin);
	else
		hostsw_own &= ~gpio_bitmask_within_group(comm, pin);

	pcr_write32(comm->port, hostsw_own_offset, hostsw_own);
}

static void gpi_enable_gpe(const struct pad_config *cfg,
			const struct pad_community *comm, int group, int pin)
{
	uint16_t en_reg;
	uint32_t en_value;

	/* Do not configure GPE_EN if PAD is not configured for SCI/wake */
	if (((cfg->pad_config[0]) & PAD_CFG0_ROUTE_SCI) != PAD_CFG0_ROUTE_SCI)
		return;

	/* Get comm offset and bit mask to be set as per pin */
	en_reg = GPI_GPE_EN_OFFSET(comm, group);
	en_value = gpio_bitmask_within_group(comm, pin);

	/* Set enable bits */
	pcr_or32(comm->port, en_reg, en_value);

	if (CONFIG(DEBUG_GPIO)) {
		printk(BIOS_DEBUG, "GPE_EN[0x%02x, %02zd]: Reg: 0x%x, Value = 0x%x\n",
			comm->port, relative_pad_in_comm(comm, cfg->pad), en_reg,
			pcr_read32(comm->port, en_reg));
	}
}

static void gpi_enable_smi(const struct pad_config *cfg,
			const struct pad_community *comm, int group, int pin)
{
	uint16_t sts_reg;
	uint16_t en_reg;
	uint32_t en_value;

	if (((cfg->pad_config[0]) & PAD_CFG0_ROUTE_SMI) != PAD_CFG0_ROUTE_SMI)
		return;

	sts_reg = GPI_SMI_STS_OFFSET(comm, group);
	en_reg = GPI_SMI_EN_OFFSET(comm, group);
	en_value = gpio_bitmask_within_group(comm, pin);

	/* Write back 1 to reset the sts bit */
	pcr_rmw32(comm->port, sts_reg, en_value, 0);

	/* Set enable bits */
	pcr_or32(comm->port, en_reg, en_value);
}

static void gpi_enable_nmi(const struct pad_config *cfg,
			const struct pad_community *comm, int group, int pin)
{
	uint16_t sts_reg;
	uint16_t en_reg;
	uint32_t en_value;

	if (((cfg->pad_config[0]) & PAD_CFG0_ROUTE_NMI) != PAD_CFG0_ROUTE_NMI)
		return;

	/* Do not configure NMI if the platform doesn't support it */
	if (!comm->gpi_nmi_sts_reg_0 || !comm->gpi_nmi_en_reg_0)
		return;

	sts_reg = GPI_NMI_STS_OFFSET(comm, group);
	en_reg = GPI_NMI_EN_OFFSET(comm, group);
	en_value = gpio_bitmask_within_group(comm, pin);

	/* Write back 1 to reset the sts bit */
	pcr_rmw32(comm->port, sts_reg, en_value, 0);

	/* Set enable bits */
	pcr_or32(comm->port, en_reg, en_value);
}

/* 120 GSIs is the default for IOxAPIC */
static uint32_t gpio_ioapic_irqs_used[120 / (sizeof(uint32_t) * BITS_PER_BYTE) + 1];
static void set_ioapic_used(uint32_t irq)
{
	size_t word_offset = irq / 32;
	size_t bit_offset = irq % 32;
	assert (word_offset < ARRAY_SIZE(gpio_ioapic_irqs_used));
	gpio_ioapic_irqs_used[word_offset] |= BIT(bit_offset);
}

bool gpio_routes_ioapic_irq(uint32_t irq)
{
	size_t word_offset = irq / 32;
	size_t bit_offset = irq % 32;
	assert (word_offset < ARRAY_SIZE(gpio_ioapic_irqs_used));
	return (gpio_ioapic_irqs_used[word_offset] & BIT(bit_offset)) != 0;
}

static void gpio_configure_itss(const struct pad_config *cfg, uint16_t port,
	uint16_t  pad_cfg_offset)
{
	/* No ITSS configuration in SMM. */
	if (ENV_SMM)
		return;

	int irq;

	/* Set up ITSS polarity if pad is routed to APIC.
	 *
	 * The ITSS takes only active high interrupt signals. Therefore,
	 * if the pad configuration indicates an inversion assume the
	 * intent is for the ITSS polarity. Before forwarding on the
	 * request to the APIC there's an inversion setting for how the
	 * signal is forwarded to the APIC. Honor the inversion setting
	 * in the GPIO pad configuration so that a hardware active low
	 * signal looks that way to the APIC (double inversion).
	 */
	if (!(cfg->pad_config[0] & PAD_CFG0_ROUTE_IOAPIC))
		return;

	irq = pcr_read32(port, PAD_CFG1_OFFSET(pad_cfg_offset));
	irq &= PAD_CFG1_IRQ_MASK;
	if (!irq) {
		printk(BIOS_ERR, "GPIO %u doesn't support APIC routing,\n",
			cfg->pad);
		return;
	}

	if (CONFIG(SOC_INTEL_COMMON_BLOCK_GPIO_ITSS_POL_CFG))
		itss_set_irq_polarity(irq, !!(cfg->pad_config[0] &
					      PAD_CFG0_RX_POL_INVERT));

	set_ioapic_used(irq);
}

/* Number of DWx config registers can be different for different SOCs */
static uint16_t pad_config_offset(const struct pad_community *comm, gpio_t pad)
{
	size_t offset;

	offset = relative_pad_in_comm(comm, pad);
	offset *= GPIO_DWx_SIZE(GPIO_NUM_PAD_CFG_REGS);
	return offset + comm->pad_cfg_base;
}

static uint32_t gpio_pad_reset_config_override(const struct pad_community *comm,
	uint32_t config_value)
{
	const struct reset_mapping *rst_map = comm->reset_map;
	int i;

	if (rst_map == NULL || comm->num_reset_vals == 0)
		return config_value;/* Logical reset values equal chipset
					values */
	for (i = 0; i < comm->num_reset_vals; i++, rst_map++) {
		if ((config_value & PAD_CFG0_RESET_MASK) == rst_map->logical) {
			config_value &= ~PAD_CFG0_RESET_MASK;
			config_value |= rst_map->chipset;
			return config_value;
		}
	}
	printk(BIOS_ERR, "%s: Logical to Chipset mapping not found\n",
			__func__);
	return config_value;
}

static const int mask[4] = {
	PAD_DW0_MASK, PAD_DW1_MASK, PAD_DW2_MASK, PAD_DW3_MASK
};

static void gpio_configure_pad(const struct pad_config *cfg)
{
	const struct pad_community *comm;
	uint16_t config_offset;
	uint32_t pad_conf, soc_pad_conf;
	int i, pin, group;

	if (!cfg) {
		printk(BIOS_ERR, "%s: cfg value is NULL\n", __func__);
		return;
	}

	comm = gpio_get_community(cfg->pad);
	if (!comm) {
		printk(BIOS_ERR, "%s: Could not find community for pad: 0x%x\n",
				__func__, cfg->pad);
		return;
	}

	config_offset = pad_config_offset(comm, cfg->pad);
	pin = relative_pad_in_comm(comm, cfg->pad);
	group = gpio_group_index(comm, pin);

	for (i = 0; i < GPIO_NUM_PAD_CFG_REGS; i++) {
		pad_conf = pcr_read32(comm->port,
			PAD_CFG_OFFSET(config_offset, i));

		soc_pad_conf = cfg->pad_config[i];
		if (i == 0)
			soc_pad_conf = gpio_pad_reset_config_override(comm,
				soc_pad_conf);
		soc_pad_conf &= mask[i];
		soc_pad_conf |= pad_conf & ~mask[i];

		/* Patch GPIO settings for SoC specifically */
		soc_pad_conf = soc_gpio_pad_config_fixup(cfg, i, soc_pad_conf);

		if (CONFIG(DEBUG_GPIO))
			printk(BIOS_DEBUG,
			"gpio_padcfg [0x%02x, %02d] DW%d [0x%08x : 0x%08x"
			" : 0x%08x]\n",
			comm->port, pin, i,
			pad_conf,/* old value */
			cfg->pad_config[i],/* value passed from gpio table */
			soc_pad_conf);/*new value*/
		pcr_write32(comm->port, PAD_CFG_OFFSET(config_offset, i),
			soc_pad_conf);
	}

	gpio_configure_itss(cfg, comm->port, config_offset);
	gpio_configure_owner(cfg, comm);
	gpi_enable_smi(cfg, comm, group, pin);
	gpi_enable_nmi(cfg, comm, group, pin);
	gpi_enable_gpe(cfg, comm, group, pin);
	if (cfg->lock_action)
		gpio_lock_pad(cfg->pad, cfg->lock_action);
}

void gpio_configure_pads(const struct pad_config *cfg, size_t num_pads)
{
	size_t i;

	for (i = 0; i < num_pads; i++)
		gpio_configure_pad(cfg + i);
}

/*
 * This functions checks to see if there is an override config present for the
 * provided pad_config. If no override config is present, then the input config
 * is returned. Else, it returns the override config.
 */
static const struct pad_config *gpio_get_config(const struct pad_config *c,
				const struct pad_config *override_cfg_table,
				size_t num)
{
	size_t i;

	if (override_cfg_table == NULL)
		return c;

	for (i = 0; i < num; i++) {
		if (c->pad == override_cfg_table[i].pad)
			return override_cfg_table + i;
	}

	return c;
}

void gpio_configure_pads_with_override(const struct pad_config *base_cfg,
					size_t base_num_pads,
					const struct pad_config *override_cfg,
					size_t override_num_pads)
{
	size_t i;
	const struct pad_config *c;

	for (i = 0; i < base_num_pads; i++) {
		c = gpio_get_config(base_cfg + i, override_cfg,
				override_num_pads);
		gpio_configure_pad(c);
	}
}

struct pad_config *new_padbased_table(void)
{
	struct pad_config *padbased_table;
	padbased_table = malloc(sizeof(struct pad_config) * TOTAL_PADS);
	memset(padbased_table, 0, sizeof(struct pad_config) * TOTAL_PADS);

	return padbased_table;
}

void gpio_padbased_override(struct pad_config *padbased_table,
				const struct pad_config *override_cfg,
				size_t override_num_pads)
{
	for (size_t i = 0; i < override_num_pads; i++) {
		/* Prevent overflow hack */
		ASSERT(override_cfg[i].pad < TOTAL_PADS);
		padbased_table[override_cfg[i].pad] = override_cfg[i];
	}
}

void gpio_configure_pads_with_padbased(struct pad_config *padbased_table)
{
	size_t i;
	const struct pad_config *cfg = padbased_table;
	for (i = 0; i < TOTAL_PADS; i++) {
		/* Consider unmapped pin as default setting, skip */
		if (cfg[i].pad == 0 && cfg[i].pad_config[0] == 0)
			continue;
		gpio_configure_pad(&cfg[i]);
	}
}

void *gpio_dwx_address(const gpio_t pad)
{
	/* Calculate Address of DW0 register for given GPIO
	 * pad - GPIO number
	 * returns - address of GPIO
	 */
	const struct pad_community *comm = gpio_get_community(pad);
	uint16_t config_offset;

	config_offset = pad_config_offset(comm, pad);
	return pcr_reg_address(comm->port, config_offset);
}

uint8_t gpio_get_pad_portid(const gpio_t pad)
{
	/* Get the port id of given pad
	 * pad - GPIO number
	 * returns - given pad port id
	 */
	const struct pad_community *comm = gpio_get_community(pad);
	return comm->port;
}

void gpio_input_pulldown(gpio_t gpio)
{
	struct pad_config cfg = PAD_CFG_GPI(gpio, DN_20K, DEEP);
	gpio_configure_pad(&cfg);
}

void gpio_input_pullup(gpio_t gpio)
{
	struct pad_config cfg = PAD_CFG_GPI(gpio, UP_20K, DEEP);
	gpio_configure_pad(&cfg);
}

void gpio_input(gpio_t gpio)
{
	struct pad_config cfg = PAD_CFG_GPI(gpio, NONE, DEEP);
	gpio_configure_pad(&cfg);
}

void gpio_output(gpio_t gpio, int value)
{
	struct pad_config cfg = PAD_CFG_GPO(gpio, value, DEEP);
	gpio_configure_pad(&cfg);
}

int gpio_get(gpio_t gpio_num)
{
	const struct pad_community *comm = gpio_get_community(gpio_num);
	uint16_t config_offset;
	uint32_t reg;

	config_offset = pad_config_offset(comm, gpio_num);
	reg = pcr_read32(comm->port, config_offset);

	return !!(reg & PAD_CFG0_RX_STATE);
}

int gpio_tx_get(gpio_t gpio_num)
{
	const struct pad_community *comm = gpio_get_community(gpio_num);
	uint16_t config_offset;
	uint32_t reg;

	config_offset = pad_config_offset(comm, gpio_num);
	reg = pcr_read32(comm->port, config_offset);

	return !!(reg & PAD_CFG0_TX_STATE);
}

static void
gpio_pad_config_lock_using_sbi(const struct gpio_lock_config *pad_info,
	uint8_t pid, uint16_t offset, const uint32_t bit_mask)
{
	int status;
	uint8_t response;
	uint32_t data;
	struct pcr_sbi_msg msg = {
		.pid = pid,
		.offset = offset,
		.opcode = GPIO_LOCK_UNLOCK,
		.is_posted = false,
		.fast_byte_enable = 0xf,
		.bar = 0,
		.fid = 0,
	};

	if (!(pad_info->lock_action & GPIO_LOCK_FULL)) {
		printk(BIOS_ERR, "%s: Error: no lock_action specified for pad %d!\n",
				__func__, pad_info->pad);
		return;
	}

	if ((pad_info->lock_action & GPIO_LOCK_CONFIG) == GPIO_LOCK_CONFIG) {
		if (CONFIG(DEBUG_GPIO))
			printk(BIOS_INFO, "%s: Locking pad %d configuration\n",
						__func__, pad_info->pad);
		data = pcr_read32(pid, offset) | bit_mask;
		status = pcr_execute_sideband_msg(PCH_DEV_P2SB, &msg, &data, &response);
		if (status || response)
			printk(BIOS_ERR, "Failed to lock GPIO PAD, response = %d\n", response);
	}

	if ((pad_info->lock_action & GPIO_LOCK_TX) == GPIO_LOCK_TX) {
		if (CONFIG(DEBUG_GPIO))
			printk(BIOS_INFO, "%s: Locking pad %d Tx state\n",
						__func__, pad_info->pad);
		offset += sizeof(uint32_t);
		data = pcr_read32(pid, offset) | bit_mask;
		msg.offset = offset;
		status = pcr_execute_sideband_msg(PCH_DEV_P2SB, &msg, &data, &response);
		if (status || response)
			printk(BIOS_ERR, "Failed to lock GPIO PAD Tx state, response = %d\n",
					response);
	}
}

int gpio_lock_pads(const struct gpio_lock_config *pad_list, const size_t count)
{
	const struct pad_community *comm;
	uint16_t offset;
	size_t rel_pad;
	gpio_t pad;

	if (!CONFIG(SOC_INTEL_COMMON_BLOCK_SMM_LOCK_GPIO_PADS))
		return -1;

	/*
	 * FSP-S will unlock all the GPIO pads and hide the P2SB device.  With
	 * the device hidden, we will not be able to send the sideband interface
	 * message to lock the GPIO configuration. Therefore, we need to unhide
	 * the P2SB device which can only be done in SMM requiring that this
	 * function is called from SMM.
	 */
	if (!ENV_SMM) {
		printk(BIOS_ERR, "%s: Error: must be called from SMM!\n", __func__);
		return -1;
	}

	if ((pad_list == NULL) || (count == 0)) {
		printk(BIOS_ERR, "%s: Error: pad_list null or count = 0!\n", __func__);
		return -1;
	}

	p2sb_unhide();

	for (int x = 0; x < count; x++) {
		pad = pad_list[x].pad;
		comm = gpio_get_community(pad);
		rel_pad = relative_pad_in_comm(comm, pad);
		offset = comm->pad_cfg_lock_offset;
		if (!offset) {
			printk(BIOS_ERR, "%s: Error: offset not defined for pad %d!\n",
					__func__, pad);
			continue;
		}
		/* PADCFGLOCK and PADCFGLOCKTX registers for each community are contiguous */
		offset += gpio_group_index_scaled(comm, rel_pad, 2 * sizeof(uint32_t));

		const uint32_t bit_mask = gpio_bitmask_within_group(comm, rel_pad);

		gpio_pad_config_lock_using_sbi(&pad_list[x], comm->port, offset, bit_mask);
	}

	p2sb_hide();
}

static void
gpio_pad_config_lock_using_pcr(const struct gpio_lock_config *pad_info,
	uint8_t pid, uint16_t offset, const uint32_t bit_mask)
{
	if ((pad_info->lock_action & GPIO_LOCK_CONFIG) == GPIO_LOCK_CONFIG) {
		if (CONFIG(DEBUG_GPIO))
			printk(BIOS_INFO, "%s: Locking pad %d configuration\n",
						__func__, pad_info->pad);
		pcr_or32(pid, offset, bit_mask);
	}

	if ((pad_info->lock_action & GPIO_LOCK_TX) == GPIO_LOCK_TX) {
		if (CONFIG(DEBUG_GPIO))
			printk(BIOS_INFO, "%s: Locking pad %d TX state\n",
				__func__, pad_info->pad);
		pcr_or32(pid, offset + sizeof(uint32_t), bit_mask);
	}
}

static int gpio_non_smm_lock_pad(const struct gpio_lock_config *pad_info)
{
	const struct pad_community *comm = gpio_get_community(pad_info->pad);
	uint16_t offset;
	size_t rel_pad;

	if (!pad_info) {
		printk(BIOS_ERR, "%s: Error: pad_info is null!\n", __func__);
		return -1;
	}

	if (cpu_soc_is_in_untrusted_mode()) {
		printk(BIOS_ERR, "%s: Error: IA Untrusted Mode enabled, can't lock pad!\n",
					__func__);
		return -1;
	}

	rel_pad = relative_pad_in_comm(comm, pad_info->pad);
	offset = comm->pad_cfg_lock_offset;
	if (!offset) {
		printk(BIOS_ERR, "%s: Error: offset not defined for pad %d!\n",
						__func__, pad_info->pad);
		return -1;
	}

	/* PADCFGLOCK and PADCFGLOCKTX registers for each community are contiguous */
	offset += gpio_group_index_scaled(comm, rel_pad, 2 * sizeof(uint32_t));
	const uint32_t bit_mask = gpio_bitmask_within_group(comm, rel_pad);

	if (CONFIG(SOC_INTEL_COMMON_BLOCK_GPIO_LOCK_USING_PCR)) {
		if (CONFIG(DEBUG_GPIO))
			printk(BIOS_INFO, "Locking pad configuration using PCR\n");
		gpio_pad_config_lock_using_pcr(pad_info, comm->port, offset, bit_mask);
	} else if (CONFIG(SOC_INTEL_COMMON_BLOCK_GPIO_LOCK_USING_SBI)) {
		if (CONFIG(DEBUG_GPIO))
			printk(BIOS_INFO, "Locking pad configuration using SBI\n");
		gpio_pad_config_lock_using_sbi(pad_info, comm->port, offset, bit_mask);
	} else {
		printk(BIOS_ERR, "%s: Error: No pad configuration lock method is selected!\n",
						__func__);
	}

	return 0;
}

int gpio_lock_pad(const gpio_t pad, enum gpio_lock_action lock_action)
{
	/* Skip locking GPIO PAD in early stages or in recovery mode */
	if (ENV_ROMSTAGE_OR_BEFORE || vboot_recovery_mode_enabled())
		return -1;

	const struct gpio_lock_config pads = {
		.pad = pad,
		.lock_action = lock_action
	};

	if (!ENV_SMM && !CONFIG(SOC_INTEL_COMMON_BLOCK_SMM_LOCK_GPIO_PADS))
		return gpio_non_smm_lock_pad(&pads);

	return gpio_lock_pads(&pads, 1);
}

void gpio_set(gpio_t gpio_num, int value)
{
	const struct pad_community *comm = gpio_get_community(gpio_num);
	uint16_t config_offset;

	config_offset = pad_config_offset(comm, gpio_num);
	pcr_rmw32(comm->port, config_offset,
		~PAD_CFG0_TX_STATE, (!!value & PAD_CFG0_TX_STATE));
}

uint16_t gpio_acpi_pin(gpio_t gpio_num)
{
	const struct pad_community *comm;
	size_t group, pin;

	if (CONFIG(SOC_INTEL_COMMON_BLOCK_GPIO_MULTI_ACPI_DEVICES))
		return relative_pad_in_comm(gpio_get_community(gpio_num),
					    gpio_num);

	comm = gpio_get_community(gpio_num);
	pin = relative_pad_in_comm(comm, gpio_num);
	group = gpio_group_index(comm, pin);

	/* If pad base is not set then use GPIO number as ACPI pin number. */
	if (comm->groups[group].acpi_pad_base == PAD_BASE_NONE)
		return gpio_num;

	/*
	 * If this group has a non-zero pad base then compute the ACPI pin
	 * number from the pad base and the relative pad in the group.
	 */
	return comm->groups[group].acpi_pad_base + gpio_within_group(comm, pin);
}

static void print_gpi_status(const struct gpi_status *sts)
{
	int i;
	int group;
	int index;
	int bit_set;
	int num_groups;
	int abs_bit;
	size_t gpio_communities;
	const struct pad_community *comm;

	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0; i < gpio_communities; i++) {
		num_groups = comm->num_gpi_regs;
		index = comm->gpi_status_offset;
		for (group = 0; group < num_groups; group++, index++) {
			for (bit_set = comm->max_pads_per_group - 1;
				bit_set >= 0; bit_set--) {
				if (!(sts->grp[index] & (1 << bit_set)))
					continue;

				abs_bit = bit_set;
				abs_bit += group * comm->max_pads_per_group;
				printk(BIOS_DEBUG, "%s %d\n", comm->name,
								abs_bit);
			}
		}
		comm++;
	}
}

void gpi_clear_get_smi_status(struct gpi_status *sts)
{
	int i;
	int group;
	int index;
	uint32_t sts_value;
	uint32_t en_value;
	size_t gpio_communities;
	int num_groups;
	const struct pad_community *comm;

	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0; i < gpio_communities; i++) {
		num_groups = comm->num_gpi_regs;
		index = comm->gpi_status_offset;
		for (group = 0; group < num_groups; group++, index++) {
			sts_value = pcr_read32(comm->port,
					GPI_SMI_STS_OFFSET(comm, group));
			en_value = pcr_read32(comm->port,
					GPI_SMI_EN_OFFSET(comm, group));
			sts->grp[index] = sts_value & en_value;
			/* Clear the set status bits. */
			pcr_write32(comm->port, GPI_SMI_STS_OFFSET(comm,
				group), sts->grp[index]);
		}
		comm++;
	}

	if (CONFIG(DEBUG_SMI))
		print_gpi_status(sts);

}

int gpi_status_get(const struct gpi_status *sts, gpio_t pad)
{
	uint8_t sts_index;
	const struct pad_community *comm = gpio_get_community(pad);

	pad = relative_pad_in_comm(comm, pad);
	sts_index = comm->gpi_status_offset;
	sts_index += gpio_group_index(comm, pad);

	return !!(sts->grp[sts_index] & gpio_bitmask_within_group(comm, pad));
}

static int gpio_route_pmc_gpio_gpe(int pmc_gpe_num)
{
	size_t num_routes;
	const struct pmc_to_gpio_route *routes;
	int i;

	routes = soc_pmc_gpio_routes(&num_routes);
	assert (routes != NULL);
	for (i = 0; i < num_routes; i++, routes++) {
		if (pmc_gpe_num == routes->pmc)
			return routes->gpio;
	}
	return -1;
}

void gpio_route_gpe(uint8_t gpe0b, uint8_t gpe0c, uint8_t gpe0d)
{
	int i;
	uint32_t misccfg_mask;
	uint32_t misccfg_value;
	int ret;
	size_t gpio_communities;
	const struct pad_community *comm;

	/* Get the group here for community specific MISCCFG register.
	 * If any of these returns -1 then there is some error in devicetree
	 * where the group is probably hardcoded and does not comply with the
	 * PMC group defines. So we return from here and MISCFG is set to
	 * default.
	 */
	ret = gpio_route_pmc_gpio_gpe(gpe0b);
	if (ret == -1)
		return;
	gpe0b = ret;

	ret = gpio_route_pmc_gpio_gpe(gpe0c);
	if (ret == -1)
		return;
	gpe0c = ret;

	ret = gpio_route_pmc_gpio_gpe(gpe0d);
	if (ret == -1)
		return;
	gpe0d = ret;

	misccfg_value = gpe0b << MISCCFG_GPE0_DW0_SHIFT;
	misccfg_value |= gpe0c << MISCCFG_GPE0_DW1_SHIFT;
	misccfg_value |= gpe0d << MISCCFG_GPE0_DW2_SHIFT;

	/* Program GPIO_MISCCFG */
	misccfg_mask = ~(MISCCFG_GPE0_DW2_MASK |
			MISCCFG_GPE0_DW1_MASK |
			MISCCFG_GPE0_DW0_MASK);

	if (CONFIG(DEBUG_GPIO))
		printk(BIOS_DEBUG, "misccfg_mask:%x misccfg_value:%x\n",
			misccfg_mask, misccfg_value);
	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0; i < gpio_communities; i++, comm++)
		pcr_rmw32(comm->port, GPIO_MISCCFG,
				misccfg_mask, misccfg_value);
}

const char *gpio_acpi_path(gpio_t gpio_num)
{
	const struct pad_community *comm = gpio_get_community(gpio_num);
	return comm->acpi_path;
}

uint32_t __weak soc_gpio_pad_config_fixup(const struct pad_config *cfg,
						int dw_reg, uint32_t reg_val)
{
	return reg_val;
}

void gpi_clear_int_cfg(void)
{
	int i, group, num_groups;
	uint32_t sts_value;
	size_t gpio_communities;
	const struct pad_community *comm;

	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0; i < gpio_communities; i++, comm++) {
		num_groups = comm->num_gpi_regs;
		for (group = 0; group < num_groups; group++) {
			/* Clear the enable register */
			pcr_write32(comm->port, GPI_IE_OFFSET(comm, group), 0);

			/* Read and clear the set status register bits*/
			sts_value = pcr_read32(comm->port,
					GPI_IS_OFFSET(comm, group));
			pcr_write32(comm->port,
					GPI_IS_OFFSET(comm, group), sts_value);
		}
	}
}

/* The function performs GPIO Power Management programming. */
void gpio_pm_configure(const uint8_t *misccfg_pm_values, size_t num)
{
	int i;
	size_t gpio_communities;
	const uint8_t misccfg_pm_mask = (uint8_t)~MISCCFG_GPIO_PM_CONFIG_BITS;
	const struct pad_community *comm;

	comm = soc_gpio_get_community(&gpio_communities);
	if (gpio_communities != num)
		die("Incorrect GPIO community count!\n");

	/* Program GPIO_MISCCFG */
	for (i = 0; i < num; i++, comm++)
		pcr_rmw8(comm->port, GPIO_MISCCFG,
				misccfg_pm_mask, misccfg_pm_values[i]);
}

size_t gpio_get_index_in_group(gpio_t pad)
{
	const struct pad_community *comm;
	size_t pin;

	comm = gpio_get_community(pad);
	pin = relative_pad_in_comm(comm, pad);
	return gpio_within_group(comm, pin);
}

static uint32_t *snapshot;

static void *allocate_snapshot_space(void)
{
	size_t gpio_communities, total = 0, i;
	const struct pad_community *comm;

	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0; i < gpio_communities; i++, comm++)
		total += comm->last_pad - comm->first_pad + 1;

	if (total == 0)
		return NULL;

	return malloc(total * GPIO_NUM_PAD_CFG_REGS * sizeof(uint32_t));
}

void gpio_snapshot(void)
{
	size_t gpio_communities, index, i, pad, reg;
	const struct pad_community *comm;
	uint16_t config_offset;

	if (snapshot == NULL) {
		snapshot = allocate_snapshot_space();
		if (snapshot == NULL)
			return;
	}

	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0, index = 0; i < gpio_communities; i++, comm++) {
		for (pad = comm->first_pad; pad <= comm->last_pad; pad++) {
			config_offset = pad_config_offset(comm, pad);
			for (reg = 0; reg < GPIO_NUM_PAD_CFG_REGS; reg++) {
				snapshot[index] = pcr_read32(comm->port,
							PAD_CFG_OFFSET(config_offset, reg));
				index++;
			}
		}
	}
}

size_t gpio_verify_snapshot(void)
{
	size_t gpio_communities, index, i, pad, reg;
	const struct pad_community *comm;
	uint32_t curr_val;
	uint16_t config_offset;
	size_t changes = 0;

	if (snapshot == NULL)
		return 0;

	comm = soc_gpio_get_community(&gpio_communities);
	for (i = 0, index = 0; i < gpio_communities; i++, comm++) {
		for (pad = comm->first_pad; pad <= comm->last_pad; pad++) {
			config_offset = pad_config_offset(comm, pad);
			for (reg = 0; reg < GPIO_NUM_PAD_CFG_REGS; reg++) {
				curr_val = pcr_read32(comm->port,
						      PAD_CFG_OFFSET(config_offset, reg));
				if (curr_val != snapshot[index]) {
					printk(BIOS_SPEW,
					       "%zd(DW%zd): Changed from 0x%x to 0x%x\n",
					       pad, reg, snapshot[index], curr_val);
					changes++;
				}
				index++;
			}
		}
	}

	return changes;
}

static void snapshot_cleanup(void *unused)
{
	free(snapshot);
}

BOOT_STATE_INIT_ENTRY(BS_OS_RESUME, BS_ON_ENTRY, snapshot_cleanup, NULL);
BOOT_STATE_INIT_ENTRY(BS_PAYLOAD_LOAD, BS_ON_EXIT, snapshot_cleanup, NULL);

bool gpio_get_vw_info(gpio_t pad, unsigned int *vw_index, unsigned int *vw_bit)
{
	const struct pad_community *comm;
	unsigned int offset = 0;
	size_t i;

	comm = gpio_get_community(pad);
	for (i = 0; i < comm->num_vw_entries; i++) {
		if (pad >= comm->vw_entries[i].first_pad && pad <= comm->vw_entries[i].last_pad)
			break;

		offset += 1 + comm->vw_entries[i].last_pad - comm->vw_entries[i].first_pad;
	}

	if (i == comm->num_vw_entries)
		return false;

	offset += pad - comm->vw_entries[i].first_pad;
	*vw_index = comm->vw_base + offset / 8;
	*vw_bit = offset % 8;

	return true;
}

unsigned int gpio_get_pad_cpu_portid(gpio_t pad)
{
	const struct pad_community *comm = gpio_get_community(pad);
	return comm->cpu_port;
}