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

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