1 // SPDX-License-Identifier: GPL-2.0
3 * Arche Platform driver to control APB.
5 * Copyright 2014-2015 Google Inc.
6 * Copyright 2014-2015 Linaro Ltd.
10 #include <linux/delay.h>
11 #include <linux/gpio.h>
12 #include <linux/interrupt.h>
13 #include <linux/of_gpio.h>
14 #include <linux/of_irq.h>
15 #include <linux/module.h>
16 #include <linux/pinctrl/consumer.h>
17 #include <linux/platform_device.h>
19 #include <linux/regulator/consumer.h>
20 #include <linux/spinlock.h>
21 #include "arche_platform.h"
23 static void apb_bootret_deassert(struct device *dev);
25 struct arche_apb_ctrl_drvdata {
26 /* Control GPIO signals to and from AP <=> AP Bridges */
34 enum arche_platform_state state;
37 struct regulator *vcore;
38 struct regulator *vio;
43 struct pinctrl *pinctrl;
44 struct pinctrl_state *pin_default;
46 /* V2: SPI Bus control */
48 bool spi_en_polarity_high;
52 * Note that these low level api's are active high
54 static inline void deassert_reset(unsigned int gpio)
56 gpio_set_value(gpio, 1);
59 static inline void assert_reset(unsigned int gpio)
61 gpio_set_value(gpio, 0);
65 * Note: Please do not modify the below sequence, as it is as per the spec
67 static int coldboot_seq(struct platform_device *pdev)
69 struct device *dev = &pdev->dev;
70 struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
73 if (apb->init_disabled ||
74 apb->state == ARCHE_PLATFORM_STATE_ACTIVE)
77 /* Hold APB in reset state */
78 assert_reset(apb->resetn_gpio);
80 if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING &&
81 gpio_is_valid(apb->spi_en_gpio))
82 devm_gpio_free(dev, apb->spi_en_gpio);
84 /* Enable power to APB */
85 if (!IS_ERR(apb->vcore)) {
86 ret = regulator_enable(apb->vcore);
88 dev_err(dev, "failed to enable core regulator\n");
93 if (!IS_ERR(apb->vio)) {
94 ret = regulator_enable(apb->vio);
96 dev_err(dev, "failed to enable IO regulator\n");
101 apb_bootret_deassert(dev);
103 /* On DB3 clock was not mandatory */
104 if (gpio_is_valid(apb->clk_en_gpio))
105 gpio_set_value(apb->clk_en_gpio, 1);
107 usleep_range(100, 200);
109 /* deassert reset to APB : Active-low signal */
110 deassert_reset(apb->resetn_gpio);
112 apb->state = ARCHE_PLATFORM_STATE_ACTIVE;
117 static int fw_flashing_seq(struct platform_device *pdev)
119 struct device *dev = &pdev->dev;
120 struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
123 if (apb->init_disabled ||
124 apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
127 ret = regulator_enable(apb->vcore);
129 dev_err(dev, "failed to enable core regulator\n");
133 ret = regulator_enable(apb->vio);
135 dev_err(dev, "failed to enable IO regulator\n");
139 if (gpio_is_valid(apb->spi_en_gpio)) {
142 if (apb->spi_en_polarity_high)
143 flags = GPIOF_OUT_INIT_HIGH;
145 flags = GPIOF_OUT_INIT_LOW;
147 ret = devm_gpio_request_one(dev, apb->spi_en_gpio,
148 flags, "apb_spi_en");
150 dev_err(dev, "Failed requesting SPI bus en gpio %d\n",
156 /* for flashing device should be in reset state */
157 assert_reset(apb->resetn_gpio);
158 apb->state = ARCHE_PLATFORM_STATE_FW_FLASHING;
163 static int standby_boot_seq(struct platform_device *pdev)
165 struct device *dev = &pdev->dev;
166 struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
168 if (apb->init_disabled)
172 * Even if it is in OFF state,
173 * then we do not want to change the state
175 if (apb->state == ARCHE_PLATFORM_STATE_STANDBY ||
176 apb->state == ARCHE_PLATFORM_STATE_OFF)
179 if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING &&
180 gpio_is_valid(apb->spi_en_gpio))
181 devm_gpio_free(dev, apb->spi_en_gpio);
184 * As per WDM spec, do nothing
186 * Pasted from WDM spec,
187 * - A falling edge on POWEROFF_L is detected (a)
188 * - WDM enters standby mode, but no output signals are changed
191 /* TODO: POWEROFF_L is input to WDM module */
192 apb->state = ARCHE_PLATFORM_STATE_STANDBY;
196 static void poweroff_seq(struct platform_device *pdev)
198 struct device *dev = &pdev->dev;
199 struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
201 if (apb->init_disabled || apb->state == ARCHE_PLATFORM_STATE_OFF)
204 if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING &&
205 gpio_is_valid(apb->spi_en_gpio))
206 devm_gpio_free(dev, apb->spi_en_gpio);
208 /* disable the clock */
209 if (gpio_is_valid(apb->clk_en_gpio))
210 gpio_set_value(apb->clk_en_gpio, 0);
212 if (!IS_ERR(apb->vcore) && regulator_is_enabled(apb->vcore) > 0)
213 regulator_disable(apb->vcore);
215 if (!IS_ERR(apb->vio) && regulator_is_enabled(apb->vio) > 0)
216 regulator_disable(apb->vio);
218 /* As part of exit, put APB back in reset state */
219 assert_reset(apb->resetn_gpio);
220 apb->state = ARCHE_PLATFORM_STATE_OFF;
222 /* TODO: May have to send an event to SVC about this exit */
225 static void apb_bootret_deassert(struct device *dev)
227 struct arche_apb_ctrl_drvdata *apb = dev_get_drvdata(dev);
229 gpio_set_value(apb->boot_ret_gpio, 0);
232 int apb_ctrl_coldboot(struct device *dev)
234 return coldboot_seq(to_platform_device(dev));
237 int apb_ctrl_fw_flashing(struct device *dev)
239 return fw_flashing_seq(to_platform_device(dev));
242 int apb_ctrl_standby_boot(struct device *dev)
244 return standby_boot_seq(to_platform_device(dev));
247 void apb_ctrl_poweroff(struct device *dev)
249 poweroff_seq(to_platform_device(dev));
252 static ssize_t state_store(struct device *dev,
253 struct device_attribute *attr,
254 const char *buf, size_t count)
256 struct platform_device *pdev = to_platform_device(dev);
257 struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
261 if (sysfs_streq(buf, "off")) {
262 if (apb->state == ARCHE_PLATFORM_STATE_OFF)
266 } else if (sysfs_streq(buf, "active")) {
267 if (apb->state == ARCHE_PLATFORM_STATE_ACTIVE)
271 is_disabled = apb->init_disabled;
272 apb->init_disabled = false;
273 ret = coldboot_seq(pdev);
275 apb->init_disabled = is_disabled;
276 } else if (sysfs_streq(buf, "standby")) {
277 if (apb->state == ARCHE_PLATFORM_STATE_STANDBY)
280 ret = standby_boot_seq(pdev);
281 } else if (sysfs_streq(buf, "fw_flashing")) {
282 if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
286 * First we want to make sure we power off everything
287 * and then enter FW flashing state
290 ret = fw_flashing_seq(pdev);
292 dev_err(dev, "unknown state\n");
296 return ret ? ret : count;
299 static ssize_t state_show(struct device *dev,
300 struct device_attribute *attr, char *buf)
302 struct arche_apb_ctrl_drvdata *apb = dev_get_drvdata(dev);
304 switch (apb->state) {
305 case ARCHE_PLATFORM_STATE_OFF:
306 return sprintf(buf, "off%s\n",
307 apb->init_disabled ? ",disabled" : "");
308 case ARCHE_PLATFORM_STATE_ACTIVE:
309 return sprintf(buf, "active\n");
310 case ARCHE_PLATFORM_STATE_STANDBY:
311 return sprintf(buf, "standby\n");
312 case ARCHE_PLATFORM_STATE_FW_FLASHING:
313 return sprintf(buf, "fw_flashing\n");
315 return sprintf(buf, "unknown state\n");
319 static DEVICE_ATTR_RW(state);
321 static int apb_ctrl_get_devtree_data(struct platform_device *pdev,
322 struct arche_apb_ctrl_drvdata *apb)
324 struct device *dev = &pdev->dev;
325 struct device_node *np = dev->of_node;
328 apb->resetn_gpio = of_get_named_gpio(np, "reset-gpios", 0);
329 if (apb->resetn_gpio < 0) {
330 dev_err(dev, "failed to get reset gpio\n");
331 return apb->resetn_gpio;
333 ret = devm_gpio_request_one(dev, apb->resetn_gpio,
334 GPIOF_OUT_INIT_LOW, "apb-reset");
336 dev_err(dev, "Failed requesting reset gpio %d\n",
341 apb->boot_ret_gpio = of_get_named_gpio(np, "boot-ret-gpios", 0);
342 if (apb->boot_ret_gpio < 0) {
343 dev_err(dev, "failed to get boot retention gpio\n");
344 return apb->boot_ret_gpio;
346 ret = devm_gpio_request_one(dev, apb->boot_ret_gpio,
347 GPIOF_OUT_INIT_LOW, "boot retention");
349 dev_err(dev, "Failed requesting bootret gpio %d\n",
354 /* It's not mandatory to support power management interface */
355 apb->pwroff_gpio = of_get_named_gpio(np, "pwr-off-gpios", 0);
356 if (apb->pwroff_gpio < 0) {
357 dev_err(dev, "failed to get power off gpio\n");
358 return apb->pwroff_gpio;
360 ret = devm_gpio_request_one(dev, apb->pwroff_gpio,
361 GPIOF_IN, "pwroff_n");
363 dev_err(dev, "Failed requesting pwroff_n gpio %d\n",
368 /* Do not make clock mandatory as of now (for DB3) */
369 apb->clk_en_gpio = of_get_named_gpio(np, "clock-en-gpio", 0);
370 if (apb->clk_en_gpio < 0) {
371 dev_warn(dev, "failed to get clock en gpio\n");
372 } else if (gpio_is_valid(apb->clk_en_gpio)) {
373 ret = devm_gpio_request_one(dev, apb->clk_en_gpio,
374 GPIOF_OUT_INIT_LOW, "apb_clk_en");
376 dev_warn(dev, "Failed requesting APB clock en gpio %d\n",
382 apb->pwrdn_gpio = of_get_named_gpio(np, "pwr-down-gpios", 0);
383 if (apb->pwrdn_gpio < 0)
384 dev_warn(dev, "failed to get power down gpio\n");
386 /* Regulators are optional, as we may have fixed supply coming in */
387 apb->vcore = devm_regulator_get(dev, "vcore");
388 if (IS_ERR(apb->vcore))
389 dev_warn(dev, "no core regulator found\n");
391 apb->vio = devm_regulator_get(dev, "vio");
392 if (IS_ERR(apb->vio))
393 dev_warn(dev, "no IO regulator found\n");
395 apb->pinctrl = devm_pinctrl_get(&pdev->dev);
396 if (IS_ERR(apb->pinctrl)) {
397 dev_err(&pdev->dev, "could not get pinctrl handle\n");
398 return PTR_ERR(apb->pinctrl);
400 apb->pin_default = pinctrl_lookup_state(apb->pinctrl, "default");
401 if (IS_ERR(apb->pin_default)) {
402 dev_err(&pdev->dev, "could not get default pin state\n");
403 return PTR_ERR(apb->pin_default);
406 /* Only applicable for platform >= V2 */
407 apb->spi_en_gpio = of_get_named_gpio(np, "spi-en-gpio", 0);
408 if (apb->spi_en_gpio >= 0) {
409 if (of_property_read_bool(pdev->dev.of_node,
410 "spi-en-active-high"))
411 apb->spi_en_polarity_high = true;
417 static int arche_apb_ctrl_probe(struct platform_device *pdev)
420 struct arche_apb_ctrl_drvdata *apb;
421 struct device *dev = &pdev->dev;
423 apb = devm_kzalloc(&pdev->dev, sizeof(*apb), GFP_KERNEL);
427 ret = apb_ctrl_get_devtree_data(pdev, apb);
429 dev_err(dev, "failed to get apb devicetree data %d\n", ret);
433 /* Initially set APB to OFF state */
434 apb->state = ARCHE_PLATFORM_STATE_OFF;
435 /* Check whether device needs to be enabled on boot */
436 if (of_property_read_bool(pdev->dev.of_node, "arche,init-disable"))
437 apb->init_disabled = true;
439 platform_set_drvdata(pdev, apb);
441 /* Create sysfs interface to allow user to change state dynamically */
442 ret = device_create_file(dev, &dev_attr_state);
444 dev_err(dev, "failed to create state file in sysfs\n");
448 dev_info(&pdev->dev, "Device registered successfully\n");
452 static int arche_apb_ctrl_remove(struct platform_device *pdev)
454 device_remove_file(&pdev->dev, &dev_attr_state);
456 platform_set_drvdata(pdev, NULL);
461 static int __maybe_unused arche_apb_ctrl_suspend(struct device *dev)
464 * If timing profile permits, we may shutdown bridge
469 * Also, need to make sure we meet precondition for unipro suspend
470 * Precondition: Definition ???
475 static int __maybe_unused arche_apb_ctrl_resume(struct device *dev)
478 * Atleast for ES2 we have to meet the delay requirement between
479 * unipro switch and AP bridge init, depending on whether bridge is in
480 * OFF state or standby state.
482 * Based on whether bridge is in standby or OFF state we may have to
483 * assert multiple signals. Please refer to WDM spec, for more info.
489 static void arche_apb_ctrl_shutdown(struct platform_device *pdev)
491 apb_ctrl_poweroff(&pdev->dev);
494 static SIMPLE_DEV_PM_OPS(arche_apb_ctrl_pm_ops, arche_apb_ctrl_suspend,
495 arche_apb_ctrl_resume);
497 static const struct of_device_id arche_apb_ctrl_of_match[] = {
498 { .compatible = "usbffff,2", },
502 static struct platform_driver arche_apb_ctrl_device_driver = {
503 .probe = arche_apb_ctrl_probe,
504 .remove = arche_apb_ctrl_remove,
505 .shutdown = arche_apb_ctrl_shutdown,
507 .name = "arche-apb-ctrl",
508 .pm = &arche_apb_ctrl_pm_ops,
509 .of_match_table = arche_apb_ctrl_of_match,
513 int __init arche_apb_init(void)
515 return platform_driver_register(&arche_apb_ctrl_device_driver);
518 void __exit arche_apb_exit(void)
520 platform_driver_unregister(&arche_apb_ctrl_device_driver);