drivers/staging/greybus/arche-apb-ctrl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Arche Platform driver to control APB.
   4  *
   5  * Copyright 2014-2015 Google Inc.
   6  * Copyright 2014-2015 Linaro Ltd.
   7  */
   8
   9 #include <linux/clk.h>
  10 #include <linux/delay.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/of_irq.h>
  14 #include <linux/module.h>
  15 #include <linux/pinctrl/consumer.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/pm.h>
  18 #include <linux/regulator/consumer.h>
  19 #include <linux/spinlock.h>
  20 #include "arche_platform.h"
  21
  22 static void apb_bootret_deassert(struct device *dev);
  23
  24 struct arche_apb_ctrl_drvdata {
  25         /* Control GPIO signals to and from AP <=> AP Bridges */
  26         struct gpio_desc *resetn;
  27         struct gpio_desc *boot_ret;
  28         struct gpio_desc *pwroff;
  29         struct gpio_desc *wake_in;
  30         struct gpio_desc *wake_out;
  31         struct gpio_desc *pwrdn;
  32
  33         enum arche_platform_state state;
  34         bool init_disabled;
  35
  36         struct regulator *vcore;
  37         struct regulator *vio;
  38
  39         struct gpio_desc *clk_en;
  40         struct clk *clk;
  41
  42         struct pinctrl *pinctrl;
  43         struct pinctrl_state *pin_default;
  44
  45         /* V2: SPI Bus control  */
  46         struct gpio_desc *spi_en;
  47         bool spi_en_polarity_high;
  48 };
  49
  50 /*
  51  * Note that these low level api's are active high
  52  */
  53 static inline void deassert_reset(struct gpio_desc *gpio)
  54 {
  55         gpiod_set_raw_value(gpio, 1);
  56 }
  57
  58 static inline void assert_reset(struct gpio_desc *gpio)
  59 {
  60         gpiod_set_raw_value(gpio, 0);
  61 }
  62
  63 /*
  64  * Note: Please do not modify the below sequence, as it is as per the spec
  65  */
  66 static int coldboot_seq(struct platform_device *pdev)
  67 {
  68         struct device *dev = &pdev->dev;
  69         struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
  70         int ret;
  71
  72         if (apb->init_disabled ||
  73             apb->state == ARCHE_PLATFORM_STATE_ACTIVE)
  74                 return 0;
  75
  76         /* Hold APB in reset state */
  77         assert_reset(apb->resetn);
  78
  79         if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && apb->spi_en)
  80                 devm_gpiod_put(dev, apb->spi_en);
  81
  82         /* Enable power to APB */
  83         if (!IS_ERR(apb->vcore)) {
  84                 ret = regulator_enable(apb->vcore);
  85                 if (ret) {
  86                         dev_err(dev, "failed to enable core regulator\n");
  87                         return ret;
  88                 }
  89         }
  90
  91         if (!IS_ERR(apb->vio)) {
  92                 ret = regulator_enable(apb->vio);
  93                 if (ret) {
  94                         dev_err(dev, "failed to enable IO regulator\n");
  95                         return ret;
  96                 }
  97         }
  98
  99         apb_bootret_deassert(dev);
 100
 101         /* On DB3 clock was not mandatory */
 102         if (apb->clk_en)
 103                 gpiod_set_value(apb->clk_en, 1);
 104
 105         usleep_range(100, 200);
 106
 107         /* deassert reset to APB : Active-low signal */
 108         deassert_reset(apb->resetn);
 109
 110         apb->state = ARCHE_PLATFORM_STATE_ACTIVE;
 111
 112         return 0;
 113 }
 114
 115 static int fw_flashing_seq(struct platform_device *pdev)
 116 {
 117         struct device *dev = &pdev->dev;
 118         struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
 119         int ret;
 120
 121         if (apb->init_disabled ||
 122             apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
 123                 return 0;
 124
 125         ret = regulator_enable(apb->vcore);
 126         if (ret) {
 127                 dev_err(dev, "failed to enable core regulator\n");
 128                 return ret;
 129         }
 130
 131         ret = regulator_enable(apb->vio);
 132         if (ret) {
 133                 dev_err(dev, "failed to enable IO regulator\n");
 134                 return ret;
 135         }
 136
 137         if (apb->spi_en) {
 138                 unsigned long flags;
 139
 140                 if (apb->spi_en_polarity_high)
 141                         flags = GPIOD_OUT_HIGH;
 142                 else
 143                         flags = GPIOD_OUT_LOW;
 144
 145                 apb->spi_en = devm_gpiod_get(dev, "spi-en", flags);
 146                 if (IS_ERR(apb->spi_en)) {
 147                         ret = PTR_ERR(apb->spi_en);
 148                         dev_err(dev, "Failed requesting SPI bus en GPIO: %d\n",
 149                                 ret);
 150                         return ret;
 151                 }
 152         }
 153
 154         /* for flashing device should be in reset state */
 155         assert_reset(apb->resetn);
 156         apb->state = ARCHE_PLATFORM_STATE_FW_FLASHING;
 157
 158         return 0;
 159 }
 160
 161 static int standby_boot_seq(struct platform_device *pdev)
 162 {
 163         struct device *dev = &pdev->dev;
 164         struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
 165
 166         if (apb->init_disabled)
 167                 return 0;
 168
 169         /*
 170          * Even if it is in OFF state,
 171          * then we do not want to change the state
 172          */
 173         if (apb->state == ARCHE_PLATFORM_STATE_STANDBY ||
 174             apb->state == ARCHE_PLATFORM_STATE_OFF)
 175                 return 0;
 176
 177         if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && apb->spi_en)
 178                 devm_gpiod_put(dev, apb->spi_en);
 179
 180         /*
 181          * As per WDM spec, do nothing
 182          *
 183          * Pasted from WDM spec,
 184          *  - A falling edge on POWEROFF_L is detected (a)
 185          *  - WDM enters standby mode, but no output signals are changed
 186          */
 187
 188         /* TODO: POWEROFF_L is input to WDM module  */
 189         apb->state = ARCHE_PLATFORM_STATE_STANDBY;
 190         return 0;
 191 }
 192
 193 static void poweroff_seq(struct platform_device *pdev)
 194 {
 195         struct device *dev = &pdev->dev;
 196         struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
 197
 198         if (apb->init_disabled || apb->state == ARCHE_PLATFORM_STATE_OFF)
 199                 return;
 200
 201         if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && apb->spi_en)
 202                 devm_gpiod_put(dev, apb->spi_en);
 203
 204         /* disable the clock */
 205         if (apb->clk_en)
 206                 gpiod_set_value(apb->clk_en, 0);
 207
 208         if (!IS_ERR(apb->vcore) && regulator_is_enabled(apb->vcore) > 0)
 209                 regulator_disable(apb->vcore);
 210
 211         if (!IS_ERR(apb->vio) && regulator_is_enabled(apb->vio) > 0)
 212                 regulator_disable(apb->vio);
 213
 214         /* As part of exit, put APB back in reset state */
 215         assert_reset(apb->resetn);
 216         apb->state = ARCHE_PLATFORM_STATE_OFF;
 217
 218         /* TODO: May have to send an event to SVC about this exit */
 219 }
 220
 221 static void apb_bootret_deassert(struct device *dev)
 222 {
 223         struct arche_apb_ctrl_drvdata *apb = dev_get_drvdata(dev);
 224
 225         gpiod_set_value(apb->boot_ret, 0);
 226 }
 227
 228 int apb_ctrl_coldboot(struct device *dev)
 229 {
 230         return coldboot_seq(to_platform_device(dev));
 231 }
 232
 233 int apb_ctrl_fw_flashing(struct device *dev)
 234 {
 235         return fw_flashing_seq(to_platform_device(dev));
 236 }
 237
 238 int apb_ctrl_standby_boot(struct device *dev)
 239 {
 240         return standby_boot_seq(to_platform_device(dev));
 241 }
 242
 243 void apb_ctrl_poweroff(struct device *dev)
 244 {
 245         poweroff_seq(to_platform_device(dev));
 246 }
 247
 248 static ssize_t state_store(struct device *dev,
 249                            struct device_attribute *attr,
 250                            const char *buf, size_t count)
 251 {
 252         struct platform_device *pdev = to_platform_device(dev);
 253         struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
 254         int ret = 0;
 255         bool is_disabled;
 256
 257         if (sysfs_streq(buf, "off")) {
 258                 if (apb->state == ARCHE_PLATFORM_STATE_OFF)
 259                         return count;
 260
 261                 poweroff_seq(pdev);
 262         } else if (sysfs_streq(buf, "active")) {
 263                 if (apb->state == ARCHE_PLATFORM_STATE_ACTIVE)
 264                         return count;
 265
 266                 poweroff_seq(pdev);
 267                 is_disabled = apb->init_disabled;
 268                 apb->init_disabled = false;
 269                 ret = coldboot_seq(pdev);
 270                 if (ret)
 271                         apb->init_disabled = is_disabled;
 272         } else if (sysfs_streq(buf, "standby")) {
 273                 if (apb->state == ARCHE_PLATFORM_STATE_STANDBY)
 274                         return count;
 275
 276                 ret = standby_boot_seq(pdev);
 277         } else if (sysfs_streq(buf, "fw_flashing")) {
 278                 if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
 279                         return count;
 280
 281                 /*
 282                  * First we want to make sure we power off everything
 283                  * and then enter FW flashing state
 284                  */
 285                 poweroff_seq(pdev);
 286                 ret = fw_flashing_seq(pdev);
 287         } else {
 288                 dev_err(dev, "unknown state\n");
 289                 ret = -EINVAL;
 290         }
 291
 292         return ret ? ret : count;
 293 }
 294
 295 static ssize_t state_show(struct device *dev,
 296                           struct device_attribute *attr, char *buf)
 297 {
 298         struct arche_apb_ctrl_drvdata *apb = dev_get_drvdata(dev);
 299
 300         switch (apb->state) {
 301         case ARCHE_PLATFORM_STATE_OFF:
 302                 return sprintf(buf, "off%s\n",
 303                                 apb->init_disabled ? ",disabled" : "");
 304         case ARCHE_PLATFORM_STATE_ACTIVE:
 305                 return sprintf(buf, "active\n");
 306         case ARCHE_PLATFORM_STATE_STANDBY:
 307                 return sprintf(buf, "standby\n");
 308         case ARCHE_PLATFORM_STATE_FW_FLASHING:
 309                 return sprintf(buf, "fw_flashing\n");
 310         default:
 311                 return sprintf(buf, "unknown state\n");
 312         }
 313 }
 314
 315 static DEVICE_ATTR_RW(state);
 316
 317 static int apb_ctrl_get_devtree_data(struct platform_device *pdev,
 318                                      struct arche_apb_ctrl_drvdata *apb)
 319 {
 320         struct device *dev = &pdev->dev;
 321         int ret;
 322
 323         apb->resetn = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
 324         if (IS_ERR(apb->resetn)) {
 325                 ret = PTR_ERR(apb->resetn);
 326                 dev_err(dev, "Failed requesting reset GPIO: %d\n", ret);
 327                 return ret;
 328         }
 329
 330         apb->boot_ret = devm_gpiod_get(dev, "boot-ret", GPIOD_OUT_LOW);
 331         if (IS_ERR(apb->boot_ret)) {
 332                 ret = PTR_ERR(apb->boot_ret);
 333                 dev_err(dev, "Failed requesting bootret GPIO: %d\n", ret);
 334                 return ret;
 335         }
 336
 337         /* It's not mandatory to support power management interface */
 338         apb->pwroff = devm_gpiod_get_optional(dev, "pwr-off", GPIOD_IN);
 339         if (IS_ERR(apb->pwroff)) {
 340                 ret = PTR_ERR(apb->pwroff);
 341                 dev_err(dev, "Failed requesting pwroff_n GPIO: %d\n", ret);
 342                 return ret;
 343         }
 344
 345         /* Do not make clock mandatory as of now (for DB3) */
 346         apb->clk_en = devm_gpiod_get_optional(dev, "clock-en", GPIOD_OUT_LOW);
 347         if (IS_ERR(apb->clk_en)) {
 348                 ret = PTR_ERR(apb->clk_en);
 349                 dev_err(dev, "Failed requesting APB clock en GPIO: %d\n", ret);
 350                 return ret;
 351         }
 352
 353         apb->pwrdn = devm_gpiod_get(dev, "pwr-down", GPIOD_OUT_LOW);
 354         if (IS_ERR(apb->pwrdn)) {
 355                 ret = PTR_ERR(apb->pwrdn);
 356                 dev_warn(dev, "Failed requesting power down GPIO: %d\n", ret);
 357                 return ret;
 358         }
 359
 360         /* Regulators are optional, as we may have fixed supply coming in */
 361         apb->vcore = devm_regulator_get(dev, "vcore");
 362         if (IS_ERR(apb->vcore))
 363                 dev_warn(dev, "no core regulator found\n");
 364
 365         apb->vio = devm_regulator_get(dev, "vio");
 366         if (IS_ERR(apb->vio))
 367                 dev_warn(dev, "no IO regulator found\n");
 368
 369         apb->pinctrl = devm_pinctrl_get(&pdev->dev);
 370         if (IS_ERR(apb->pinctrl)) {
 371                 dev_err(&pdev->dev, "could not get pinctrl handle\n");
 372                 return PTR_ERR(apb->pinctrl);
 373         }
 374         apb->pin_default = pinctrl_lookup_state(apb->pinctrl, "default");
 375         if (IS_ERR(apb->pin_default)) {
 376                 dev_err(&pdev->dev, "could not get default pin state\n");
 377                 return PTR_ERR(apb->pin_default);
 378         }
 379
 380         /* Only applicable for platform >= V2 */
 381         if (of_property_read_bool(pdev->dev.of_node, "gb,spi-en-active-high"))
 382                 apb->spi_en_polarity_high = true;
 383
 384         return 0;
 385 }
 386
 387 static int arche_apb_ctrl_probe(struct platform_device *pdev)
 388 {
 389         int ret;
 390         struct arche_apb_ctrl_drvdata *apb;
 391         struct device *dev = &pdev->dev;
 392
 393         apb = devm_kzalloc(&pdev->dev, sizeof(*apb), GFP_KERNEL);
 394         if (!apb)
 395                 return -ENOMEM;
 396
 397         ret = apb_ctrl_get_devtree_data(pdev, apb);
 398         if (ret) {
 399                 dev_err(dev, "failed to get apb devicetree data %d\n", ret);
 400                 return ret;
 401         }
 402
 403         /* Initially set APB to OFF state */
 404         apb->state = ARCHE_PLATFORM_STATE_OFF;
 405         /* Check whether device needs to be enabled on boot */
 406         if (of_property_read_bool(pdev->dev.of_node, "arche,init-disable"))
 407                 apb->init_disabled = true;
 408
 409         platform_set_drvdata(pdev, apb);
 410
 411         /* Create sysfs interface to allow user to change state dynamically */
 412         ret = device_create_file(dev, &dev_attr_state);
 413         if (ret) {
 414                 dev_err(dev, "failed to create state file in sysfs\n");
 415                 return ret;
 416         }
 417
 418         dev_info(&pdev->dev, "Device registered successfully\n");
 419         return 0;
 420 }
 421
 422 static int arche_apb_ctrl_remove(struct platform_device *pdev)
 423 {
 424         device_remove_file(&pdev->dev, &dev_attr_state);
 425         poweroff_seq(pdev);
 426         platform_set_drvdata(pdev, NULL);
 427
 428         return 0;
 429 }
 430
 431 static int __maybe_unused arche_apb_ctrl_suspend(struct device *dev)
 432 {
 433         /*
 434          * If timing profile permits, we may shutdown bridge
 435          * completely
 436          *
 437          * TODO: sequence ??
 438          *
 439          * Also, need to make sure we meet precondition for unipro suspend
 440          * Precondition: Definition ???
 441          */
 442         return 0;
 443 }
 444
 445 static int __maybe_unused arche_apb_ctrl_resume(struct device *dev)
 446 {
 447         /*
 448          * Atleast for ES2 we have to meet the delay requirement between
 449          * unipro switch and AP bridge init, depending on whether bridge is in
 450          * OFF state or standby state.
 451          *
 452          * Based on whether bridge is in standby or OFF state we may have to
 453          * assert multiple signals. Please refer to WDM spec, for more info.
 454          *
 455          */
 456         return 0;
 457 }
 458
 459 static void arche_apb_ctrl_shutdown(struct platform_device *pdev)
 460 {
 461         apb_ctrl_poweroff(&pdev->dev);
 462 }
 463
 464 static SIMPLE_DEV_PM_OPS(arche_apb_ctrl_pm_ops, arche_apb_ctrl_suspend,
 465                          arche_apb_ctrl_resume);
 466
 467 static const struct of_device_id arche_apb_ctrl_of_match[] = {
 468         { .compatible = "usbffff,2", },
 469         { },
 470 };
 471
 472 static struct platform_driver arche_apb_ctrl_device_driver = {
 473         .probe          = arche_apb_ctrl_probe,
 474         .remove         = arche_apb_ctrl_remove,
 475         .shutdown       = arche_apb_ctrl_shutdown,
 476         .driver         = {
 477                 .name   = "arche-apb-ctrl",
 478                 .pm     = &arche_apb_ctrl_pm_ops,
 479                 .of_match_table = arche_apb_ctrl_of_match,
 480         }
 481 };
 482
 483 int __init arche_apb_init(void)
 484 {
 485         return platform_driver_register(&arche_apb_ctrl_device_driver);
 486 }
 487
 488 void __exit arche_apb_exit(void)
 489 {
 490         platform_driver_unregister(&arche_apb_ctrl_device_driver);
 491 }