| /* |
| * Arche Platform driver to control APB. |
| * |
| * Copyright 2014-2015 Google Inc. |
| * Copyright 2014-2015 Linaro Ltd. |
| * |
| * Released under the GPLv2 only. |
| */ |
| |
| #include <linux/clk.h> |
| #include <linux/delay.h> |
| #include <linux/gpio.h> |
| #include <linux/interrupt.h> |
| #include <linux/of_gpio.h> |
| #include <linux/of_irq.h> |
| #include <linux/module.h> |
| #include <linux/pinctrl/consumer.h> |
| #include <linux/platform_device.h> |
| #include <linux/pm.h> |
| #include <linux/regulator/consumer.h> |
| #include <linux/spinlock.h> |
| #include "arche_platform.h" |
| |
| |
| struct arche_apb_ctrl_drvdata { |
| /* Control GPIO signals to and from AP <=> AP Bridges */ |
| int resetn_gpio; |
| int boot_ret_gpio; |
| int pwroff_gpio; |
| int wake_in_gpio; |
| int wake_out_gpio; |
| int pwrdn_gpio; |
| |
| enum arche_platform_state state; |
| bool init_disabled; |
| |
| struct regulator *vcore; |
| struct regulator *vio; |
| |
| unsigned int clk_en_gpio; |
| struct clk *clk; |
| |
| struct pinctrl *pinctrl; |
| struct pinctrl_state *pin_default; |
| }; |
| |
| /* |
| * Note that these low level api's are active high |
| */ |
| static inline void deassert_reset(unsigned int gpio) |
| { |
| gpio_set_value(gpio, 1); |
| msleep(500); |
| } |
| |
| static inline void assert_reset(unsigned int gpio) |
| { |
| gpio_set_value(gpio, 0); |
| } |
| |
| /* |
| * Note: Please do not modify the below sequence, as it is as per the spec |
| */ |
| static int coldboot_seq(struct platform_device *pdev) |
| { |
| struct device *dev = &pdev->dev; |
| struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); |
| int ret; |
| |
| if (apb->init_disabled) |
| return 0; |
| |
| /* Hold APB in reset state */ |
| assert_reset(apb->resetn_gpio); |
| |
| /* Enable power to APB */ |
| if (!IS_ERR(apb->vcore)) { |
| ret = regulator_enable(apb->vcore); |
| if (ret) { |
| dev_err(dev, "failed to enable core regulator\n"); |
| return ret; |
| } |
| } |
| |
| if (!IS_ERR(apb->vio)) { |
| ret = regulator_enable(apb->vio); |
| if (ret) { |
| dev_err(dev, "failed to enable IO regulator\n"); |
| return ret; |
| } |
| } |
| |
| gpio_set_value(apb->boot_ret_gpio, 0); |
| |
| /* On DB3 clock was not mandatory */ |
| if (gpio_is_valid(apb->clk_en_gpio)) |
| gpio_set_value(apb->clk_en_gpio, 1); |
| |
| usleep_range(100, 200); |
| |
| /* deassert reset to APB : Active-low signal */ |
| deassert_reset(apb->resetn_gpio); |
| |
| apb->state = ARCHE_PLATFORM_STATE_ACTIVE; |
| |
| return 0; |
| } |
| |
| static int fw_flashing_seq(struct platform_device *pdev) |
| { |
| struct device *dev = &pdev->dev; |
| struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); |
| int ret; |
| |
| if (apb->init_disabled) |
| return 0; |
| |
| ret = regulator_enable(apb->vcore); |
| if (ret) { |
| dev_err(dev, "failed to enable core regulator\n"); |
| return ret; |
| } |
| |
| ret = regulator_enable(apb->vio); |
| if (ret) { |
| dev_err(dev, "failed to enable IO regulator\n"); |
| return ret; |
| } |
| |
| /* for flashing device should be in reset state */ |
| assert_reset(apb->resetn_gpio); |
| apb->state = ARCHE_PLATFORM_STATE_FW_FLASHING; |
| |
| return 0; |
| } |
| |
| static int standby_boot_seq(struct platform_device *pdev) |
| { |
| struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); |
| |
| if (apb->init_disabled) |
| return 0; |
| |
| /* If it is in OFF state, then we do not want to change the state */ |
| if (apb->state == ARCHE_PLATFORM_STATE_OFF) |
| return 0; |
| |
| /* |
| * As per WDM spec, do nothing |
| * |
| * Pasted from WDM spec, |
| * - A falling edge on POWEROFF_L is detected (a) |
| * - WDM enters standby mode, but no output signals are changed |
| * */ |
| |
| /* TODO: POWEROFF_L is input to WDM module */ |
| apb->state = ARCHE_PLATFORM_STATE_STANDBY; |
| return 0; |
| } |
| |
| static void poweroff_seq(struct platform_device *pdev) |
| { |
| struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); |
| |
| if (apb->init_disabled) |
| return; |
| |
| /* disable the clock */ |
| if (gpio_is_valid(apb->clk_en_gpio)) |
| gpio_set_value(apb->clk_en_gpio, 0); |
| |
| if (!IS_ERR(apb->vcore) && regulator_is_enabled(apb->vcore) > 0) |
| regulator_disable(apb->vcore); |
| |
| if (!IS_ERR(apb->vio) && regulator_is_enabled(apb->vio) > 0) |
| regulator_disable(apb->vio); |
| |
| /* As part of exit, put APB back in reset state */ |
| assert_reset(apb->resetn_gpio); |
| apb->state = ARCHE_PLATFORM_STATE_OFF; |
| |
| /* TODO: May have to send an event to SVC about this exit */ |
| } |
| |
| int apb_ctrl_coldboot(struct device *dev) |
| { |
| return coldboot_seq(to_platform_device(dev)); |
| } |
| |
| int apb_ctrl_fw_flashing(struct device *dev) |
| { |
| return fw_flashing_seq(to_platform_device(dev)); |
| } |
| |
| int apb_ctrl_standby_boot(struct device *dev) |
| { |
| return standby_boot_seq(to_platform_device(dev)); |
| } |
| |
| void apb_ctrl_poweroff(struct device *dev) |
| { |
| poweroff_seq(to_platform_device(dev)); |
| } |
| |
| static ssize_t state_store(struct device *dev, |
| struct device_attribute *attr, const char *buf, size_t count) |
| { |
| struct platform_device *pdev = to_platform_device(dev); |
| struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev); |
| int ret = 0; |
| bool is_disabled; |
| |
| if (sysfs_streq(buf, "off")) { |
| if (apb->state == ARCHE_PLATFORM_STATE_OFF) |
| return count; |
| |
| poweroff_seq(pdev); |
| } else if (sysfs_streq(buf, "active")) { |
| if (apb->state == ARCHE_PLATFORM_STATE_ACTIVE) |
| return count; |
| |
| poweroff_seq(pdev); |
| is_disabled = apb->init_disabled; |
| apb->init_disabled = false; |
| ret = coldboot_seq(pdev); |
| if (ret) |
| apb->init_disabled = is_disabled; |
| } else if (sysfs_streq(buf, "standby")) { |
| if (apb->state == ARCHE_PLATFORM_STATE_STANDBY) |
| return count; |
| |
| ret = standby_boot_seq(pdev); |
| } else if (sysfs_streq(buf, "fw_flashing")) { |
| if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING) |
| return count; |
| |
| /* First we want to make sure we power off everything |
| * and then enter FW flashing state */ |
| poweroff_seq(pdev); |
| ret = fw_flashing_seq(pdev); |
| } else { |
| dev_err(dev, "unknown state\n"); |
| ret = -EINVAL; |
| } |
| |
| return ret ? ret : count; |
| } |
| |
| static ssize_t state_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct arche_apb_ctrl_drvdata *apb = dev_get_drvdata(dev); |
| |
| switch (apb->state) { |
| case ARCHE_PLATFORM_STATE_OFF: |
| return sprintf(buf, "off%s\n", |
| apb->init_disabled ? ",disabled" : ""); |
| case ARCHE_PLATFORM_STATE_ACTIVE: |
| return sprintf(buf, "active\n"); |
| case ARCHE_PLATFORM_STATE_STANDBY: |
| return sprintf(buf, "standby\n"); |
| case ARCHE_PLATFORM_STATE_FW_FLASHING: |
| return sprintf(buf, "fw_flashing\n"); |
| default: |
| return sprintf(buf, "unknown state\n"); |
| } |
| } |
| |
| static DEVICE_ATTR_RW(state); |
| |
| static int apb_ctrl_get_devtree_data(struct platform_device *pdev, |
| struct arche_apb_ctrl_drvdata *apb) |
| { |
| struct device *dev = &pdev->dev; |
| struct device_node *np = dev->of_node; |
| int ret; |
| |
| apb->resetn_gpio = of_get_named_gpio(np, "reset-gpios", 0); |
| if (apb->resetn_gpio < 0) { |
| dev_err(dev, "failed to get reset gpio\n"); |
| return apb->resetn_gpio; |
| } |
| ret = devm_gpio_request_one(dev, apb->resetn_gpio, |
| GPIOF_OUT_INIT_LOW, "apb-reset"); |
| if (ret) { |
| dev_err(dev, "Failed requesting reset gpio %d\n", |
| apb->resetn_gpio); |
| return ret; |
| } |
| |
| apb->boot_ret_gpio = of_get_named_gpio(np, "boot-ret-gpios", 0); |
| if (apb->boot_ret_gpio < 0) { |
| dev_err(dev, "failed to get boot retention gpio\n"); |
| return apb->boot_ret_gpio; |
| } |
| ret = devm_gpio_request_one(dev, apb->boot_ret_gpio, |
| GPIOF_OUT_INIT_LOW, "boot retention"); |
| if (ret) { |
| dev_err(dev, "Failed requesting bootret gpio %d\n", |
| apb->boot_ret_gpio); |
| return ret; |
| } |
| |
| /* It's not mandatory to support power management interface */ |
| apb->pwroff_gpio = of_get_named_gpio(np, "pwr-off-gpios", 0); |
| if (apb->pwroff_gpio < 0) { |
| dev_err(dev, "failed to get power off gpio\n"); |
| return apb->pwroff_gpio; |
| } |
| ret = devm_gpio_request_one(dev, apb->pwroff_gpio, |
| GPIOF_IN, "pwroff_n"); |
| if (ret) { |
| dev_err(dev, "Failed requesting pwroff_n gpio %d\n", |
| apb->pwroff_gpio); |
| return ret; |
| } |
| |
| /* Do not make clock mandatory as of now (for DB3) */ |
| apb->clk_en_gpio = of_get_named_gpio(np, "clock-en-gpio", 0); |
| if (apb->clk_en_gpio < 0) { |
| dev_warn(dev, "failed to get clock en gpio\n"); |
| } else if (gpio_is_valid(apb->clk_en_gpio)) { |
| ret = devm_gpio_request_one(dev, apb->clk_en_gpio, |
| GPIOF_OUT_INIT_LOW, "apb_clk_en"); |
| if (ret) { |
| dev_warn(dev, "Failed requesting APB clock en gpio %d\n", |
| apb->clk_en_gpio); |
| return ret; |
| } |
| } |
| |
| apb->pwrdn_gpio = of_get_named_gpio(np, "pwr-down-gpios", 0); |
| if (apb->pwrdn_gpio < 0) |
| dev_warn(dev, "failed to get power down gpio\n"); |
| |
| /* Regulators are optional, as we may have fixed supply coming in */ |
| apb->vcore = devm_regulator_get(dev, "vcore"); |
| if (IS_ERR(apb->vcore)) |
| dev_warn(dev, "no core regulator found\n"); |
| |
| apb->vio = devm_regulator_get(dev, "vio"); |
| if (IS_ERR(apb->vio)) |
| dev_warn(dev, "no IO regulator found\n"); |
| |
| apb->pinctrl = devm_pinctrl_get(&pdev->dev); |
| if (IS_ERR(apb->pinctrl)) { |
| dev_err(&pdev->dev, "could not get pinctrl handle\n"); |
| return PTR_ERR(apb->pinctrl); |
| } |
| apb->pin_default = pinctrl_lookup_state(apb->pinctrl, "default"); |
| if (IS_ERR(apb->pin_default)) { |
| dev_err(&pdev->dev, "could not get default pin state\n"); |
| return PTR_ERR(apb->pin_default); |
| } |
| |
| return 0; |
| } |
| |
| int arche_apb_ctrl_probe(struct platform_device *pdev) |
| { |
| int ret; |
| struct arche_apb_ctrl_drvdata *apb; |
| struct device *dev = &pdev->dev; |
| |
| apb = devm_kzalloc(&pdev->dev, sizeof(*apb), GFP_KERNEL); |
| if (!apb) |
| return -ENOMEM; |
| |
| ret = apb_ctrl_get_devtree_data(pdev, apb); |
| if (ret) { |
| dev_err(dev, "failed to get apb devicetree data %d\n", ret); |
| return ret; |
| } |
| |
| /* Initially set APB to OFF state */ |
| apb->state = ARCHE_PLATFORM_STATE_OFF; |
| /* Check whether device needs to be enabled on boot */ |
| if (of_property_read_bool(pdev->dev.of_node, "ara,init-disable")) |
| apb->init_disabled = true; |
| |
| platform_set_drvdata(pdev, apb); |
| |
| /* Create sysfs interface to allow user to change state dynamically */ |
| ret = device_create_file(dev, &dev_attr_state); |
| if (ret) { |
| dev_err(dev, "failed to create state file in sysfs\n"); |
| return ret; |
| } |
| |
| ret = coldboot_seq(pdev); |
| if (ret) { |
| dev_err(dev, "failed to set init state of control signal %d\n", |
| ret); |
| device_remove_file(dev, &dev_attr_state); |
| platform_set_drvdata(pdev, NULL); |
| return ret; |
| } |
| |
| dev_info(&pdev->dev, "Device registered successfully\n"); |
| return 0; |
| } |
| |
| int arche_apb_ctrl_remove(struct platform_device *pdev) |
| { |
| device_remove_file(&pdev->dev, &dev_attr_state); |
| poweroff_seq(pdev); |
| platform_set_drvdata(pdev, NULL); |
| |
| return 0; |
| } |
| |
| static int arche_apb_ctrl_suspend(struct device *dev) |
| { |
| /* |
| * If timing profile permits, we may shutdown bridge |
| * completely |
| * |
| * TODO: sequence ?? |
| * |
| * Also, need to make sure we meet precondition for unipro suspend |
| * Precondition: Definition ??? |
| */ |
| return 0; |
| } |
| |
| static int arche_apb_ctrl_resume(struct device *dev) |
| { |
| /* |
| * Atleast for ES2 we have to meet the delay requirement between |
| * unipro switch and AP bridge init, depending on whether bridge is in |
| * OFF state or standby state. |
| * |
| * Based on whether bridge is in standby or OFF state we may have to |
| * assert multiple signals. Please refer to WDM spec, for more info. |
| * |
| */ |
| return 0; |
| } |
| |
| SIMPLE_DEV_PM_OPS(arche_apb_ctrl_pm_ops, |
| arche_apb_ctrl_suspend, |
| arche_apb_ctrl_resume); |