xref: /OK3568_Linux_fs/kernel/drivers/soc/rockchip/rockchip_pm_config.c (revision 4882a59341e53eb6f0b4789bf948001014eff981)

/*
 * Rockchip Generic power configuration support.
 *
 * Copyright (c) 2017 ROCKCHIP, Co. Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/arm-smccc.h>
#include <linux/bitops.h>
#include <linux/cpu.h>
#include <linux/module.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/rockchip/rockchip_sip.h>
#include <linux/suspend.h>
#include <dt-bindings/input/input.h>
#include <../drivers/regulator/internal.h>

#define PM_INVALID_GPIO			0xffff
#define MAX_ON_OFF_REG_NUM		30
#define MAX_ON_OFF_REG_PROP_NAME_LEN	60
#define MAX_CONFIG_PROP_NAME_LEN	60

enum rk_pm_state {
	RK_PM_MEM = 0,
	RK_PM_MEM_LITE,
	RK_PM_MEM_ULTRA,
	RK_PM_STATE_MAX
};

#ifndef MODULE
static const char * const pm_state_str[RK_PM_STATE_MAX] = {
	[RK_PM_MEM] = "mem",
	[RK_PM_MEM_LITE] = "mem-lite",
	[RK_PM_MEM_ULTRA] = "mem-ultra",
};

static struct rk_on_off_regulator_list {
	struct regulator_dev *on_reg_list[MAX_ON_OFF_REG_NUM];
	struct regulator_dev *off_reg_list[MAX_ON_OFF_REG_NUM];
} on_off_regs_list[RK_PM_STATE_MAX];
#endif

static struct rk_sleep_config {
	u32 mode_config;
	u32 wakeup_config;
} sleep_config[RK_PM_STATE_MAX];

static const struct of_device_id pm_match_table[] = {
	{ .compatible = "rockchip,pm-px30",},
	{ .compatible = "rockchip,pm-rk1808",},
	{ .compatible = "rockchip,pm-rk322x",},
	{ .compatible = "rockchip,pm-rk3288",},
	{ .compatible = "rockchip,pm-rk3308",},
	{ .compatible = "rockchip,pm-rk3328",},
	{ .compatible = "rockchip,pm-rk3368",},
	{ .compatible = "rockchip,pm-rk3399",},
	{ .compatible = "rockchip,pm-rk3528",},
	{ .compatible = "rockchip,pm-rk3562",},
	{ .compatible = "rockchip,pm-rk3568",},
	{ .compatible = "rockchip,pm-rk3588",},
	{ .compatible = "rockchip,pm-rv1126",},
	{ },
};

#ifndef MODULE
static void rockchip_pm_virt_pwroff_prepare(void)
{
	int error;

	regulator_suspend_prepare(PM_SUSPEND_MEM);

	error = suspend_disable_secondary_cpus();
	if (error) {
		pr_err("Disable nonboot cpus failed!\n");
		return;
	}

	sip_smc_set_suspend_mode(VIRTUAL_POWEROFF, 0, 1);
	sip_smc_virtual_poweroff();
}

static int parse_sleep_config(struct device_node *node, enum rk_pm_state state)
{
	char mode_prop_name[MAX_CONFIG_PROP_NAME_LEN];
	char wkup_prop_name[MAX_CONFIG_PROP_NAME_LEN];
	struct rk_sleep_config *config;

	if (state == RK_PM_MEM || state >= RK_PM_STATE_MAX)
		return -EINVAL;

	snprintf(mode_prop_name, sizeof(mode_prop_name),
		 "sleep-mode-config-%s", pm_state_str[state]);
	snprintf(wkup_prop_name, sizeof(wkup_prop_name),
		 "wakeup-config-%s", pm_state_str[state]);

	config = &sleep_config[state];

	if (of_property_read_u32_array(node,
				       mode_prop_name,
				       &config->mode_config, 1))
		pr_info("%s not set sleep-mode-config for %s\n",
			node->name, pm_state_str[state]);

	if (of_property_read_u32_array(node,
				       wkup_prop_name,
				       &config->wakeup_config, 1))
		pr_info("%s not set wakeup-config for %s\n",
			node->name, pm_state_str[state]);

	return 0;
}

static int parse_regulator_list(struct device_node *node,
				char *prop_name,
				struct regulator_dev **out_list)
{
	struct device_node *dn;
	struct regulator_dev *reg;
	int i, j;

	if (of_find_property(node, prop_name, NULL)) {
		for (i = 0, j = 0;
		     (dn = of_parse_phandle(node, prop_name, i)) && j < MAX_ON_OFF_REG_NUM;
		     i++) {
			reg = of_find_regulator_by_node(dn);
			if (reg == NULL) {
				pr_warn("failed to find regulator %s for %s\n",
					dn->name, prop_name);
			} else {
				pr_debug("%s %s regulator=%s\n", __func__,
					 prop_name,
					 reg->desc->name);
				out_list[j++] = reg;
			}
			of_node_put(dn);
		}
	}

	return 0;
}

static int parse_on_off_regulator(struct device_node *node, enum rk_pm_state state)
{
	char on_prop_name[MAX_ON_OFF_REG_PROP_NAME_LEN];
	char off_prop_name[MAX_ON_OFF_REG_PROP_NAME_LEN];

	if (state >= RK_PM_STATE_MAX)
		return -EINVAL;

	snprintf(on_prop_name, sizeof(on_prop_name),
		 "rockchip,regulator-on-in-%s", pm_state_str[state]);
	snprintf(off_prop_name, sizeof(off_prop_name),
		 "rockchip,regulator-off-in-%s", pm_state_str[state]);

	parse_regulator_list(node, on_prop_name, on_off_regs_list[state].on_reg_list);
	parse_regulator_list(node, off_prop_name, on_off_regs_list[state].off_reg_list);

	return 0;
}
#endif

static int pm_config_probe(struct platform_device *pdev)
{
	const struct of_device_id *match_id;
	struct device_node *node;
	struct rk_sleep_config *config = &sleep_config[RK_PM_MEM];
	u32 pwm_regulator_config = 0;
	int gpio_temp[10];
	u32 sleep_debug_en = 0;
	u32 apios_suspend = 0;
	u32 io_ret_config = 0;
	u32 sleep_pin_config[2] = {0};
#ifndef MODULE
	u32 virtual_poweroff_en = 0;
#endif
	enum of_gpio_flags flags;
	int i = 0;
	int length;
	int ret;

	match_id = of_match_node(pm_match_table, pdev->dev.of_node);
	if (!match_id)
		return -ENODEV;

	node = of_find_node_by_name(NULL, "rockchip-suspend");

	if (IS_ERR_OR_NULL(node)) {
		dev_err(&pdev->dev, "%s dev node err\n",  __func__);
		return -ENODEV;
	}

	if (of_property_read_u32_array(node,
				       "rockchip,sleep-mode-config",
				       &config->mode_config, 1))
		dev_warn(&pdev->dev, "not set sleep mode config\n");
	else
		sip_smc_set_suspend_mode(SUSPEND_MODE_CONFIG, config->mode_config, 0);

	if (of_property_read_u32_array(node,
				       "rockchip,wakeup-config",
				       &config->wakeup_config, 1))
		dev_warn(&pdev->dev, "not set wakeup-config\n");
	else
		sip_smc_set_suspend_mode(WKUP_SOURCE_CONFIG, config->wakeup_config, 0);

	if (of_property_read_u32_array(node,
				       "rockchip,pwm-regulator-config",
				       &pwm_regulator_config, 1))
		dev_warn(&pdev->dev, "not set pwm-regulator-config\n");
	else
		sip_smc_set_suspend_mode(PWM_REGULATOR_CONFIG,
					 pwm_regulator_config,
					 0);

	length = of_gpio_named_count(node, "rockchip,power-ctrl");

	if (length > 0 && length < 10) {
		for (i = 0; i < length; i++) {
			gpio_temp[i] = of_get_named_gpio_flags(node,
							     "rockchip,power-ctrl",
							     i,
							     &flags);
			if (!gpio_is_valid(gpio_temp[i]))
				break;
			sip_smc_set_suspend_mode(GPIO_POWER_CONFIG,
						 i,
						 gpio_temp[i]);
		}
	}
	sip_smc_set_suspend_mode(GPIO_POWER_CONFIG, i, PM_INVALID_GPIO);

	if (!of_property_read_u32_array(node,
					"rockchip,sleep-debug-en",
					&sleep_debug_en, 1))
		sip_smc_set_suspend_mode(SUSPEND_DEBUG_ENABLE,
					 sleep_debug_en,
					 0);

	if (!of_property_read_u32_array(node,
					"rockchip,apios-suspend",
					&apios_suspend, 1))
		sip_smc_set_suspend_mode(APIOS_SUSPEND_CONFIG,
					 apios_suspend,
					 0);

	if (!of_property_read_u32_array(node,
					"rockchip,sleep-io-ret-config",
					&io_ret_config, 1)) {
		ret = sip_smc_set_suspend_mode(SUSPEND_IO_RET_CONFIG, io_ret_config, 0);
		if (ret)
			dev_warn(&pdev->dev,
				 "sleep-io-ret-config failed (%d), check parameters or update trust\n",
				 ret);
	}

	if (!of_property_read_u32_array(node,
					"rockchip,sleep-pin-config",
					sleep_pin_config, 2)) {
		ret = sip_smc_set_suspend_mode(SLEEP_PIN_CONFIG, sleep_pin_config[0], sleep_pin_config[1]);
		if (ret)
			dev_warn(&pdev->dev,
				 "sleep-pin-config failed (%d), check parameters or update trust\n",
				 ret);
	}

#ifndef MODULE
	if (!of_property_read_u32_array(node,
					"rockchip,virtual-poweroff",
					&virtual_poweroff_en, 1) &&
	    virtual_poweroff_en)
		pm_power_off_prepare = rockchip_pm_virt_pwroff_prepare;

	for (i = RK_PM_MEM; i < RK_PM_STATE_MAX; i++) {
		parse_sleep_config(node, i);
		parse_on_off_regulator(node, i);
	}
#endif

	return 0;
}

#ifndef MODULE
static int pm_config_prepare(struct device *dev)
{
	int i;
	suspend_state_t suspend_state = mem_sleep_current;
	enum rk_pm_state state = suspend_state - PM_SUSPEND_MEM;
	struct regulator_dev **on_list;
	struct regulator_dev **off_list;
	struct rk_sleep_config *config, *def_config = &sleep_config[RK_PM_MEM];

	sip_smc_set_suspend_mode(LINUX_PM_STATE,
				 suspend_state,
				 0);

	if (state >= RK_PM_STATE_MAX)
		return 0;

	config = &sleep_config[state];

	if (config->mode_config)
		sip_smc_set_suspend_mode(SUSPEND_MODE_CONFIG,
					 config->mode_config, 0);
	else if (def_config->mode_config)
		sip_smc_set_suspend_mode(SUSPEND_MODE_CONFIG,
					 def_config->mode_config, 0);

	if (config->wakeup_config)
		sip_smc_set_suspend_mode(WKUP_SOURCE_CONFIG,
					 config->wakeup_config, 0);
	else if (def_config->wakeup_config)
		sip_smc_set_suspend_mode(WKUP_SOURCE_CONFIG,
					 def_config->wakeup_config, 0);

	on_list = on_off_regs_list[state].on_reg_list;
	off_list = on_off_regs_list[state].off_reg_list;

	for (i = 0; i < MAX_ON_OFF_REG_NUM && on_list[i]; i++)
		regulator_suspend_enable(on_list[i], PM_SUSPEND_MEM);

	for (i = 0; i < MAX_ON_OFF_REG_NUM && off_list[i]; i++)
		regulator_suspend_disable(off_list[i], PM_SUSPEND_MEM);

	return 0;
}

static const struct dev_pm_ops rockchip_pm_ops = {
	.prepare = pm_config_prepare,
};
#endif

static struct platform_driver pm_driver = {
	.probe = pm_config_probe,
	.driver = {
		.name = "rockchip-pm",
		.of_match_table = pm_match_table,
#ifndef MODULE
		.pm = &rockchip_pm_ops,
#endif
	},
};

static int __init rockchip_pm_drv_register(void)
{
	return platform_driver_register(&pm_driver);
}
late_initcall_sync(rockchip_pm_drv_register);
MODULE_DESCRIPTION("Rockchip suspend mode config");
MODULE_LICENSE("GPL");