drivers/sysreset/sysreset_sandbox.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2015 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <errno.h>
  10 #include <sysreset.h>
  11 #include <asm/state.h>
  12 #include <asm/test.h>
  13
  14 static int sandbox_warm_sysreset_request(struct udevice *dev,
  15                                          enum sysreset_t type)
  16 {
  17         struct sandbox_state *state = state_get_current();
  18
  19         switch (type) {
  20         case SYSRESET_WARM:
  21                 state->last_sysreset = type;
  22                 break;
  23         default:
  24                 return -ENOSYS;
  25         }
  26         if (!state->sysreset_allowed[type])
  27                 return -EACCES;
  28
  29         return -EINPROGRESS;
  30 }
  31
  32 int sandbox_warm_sysreset_get_status(struct udevice *dev, char *buf, int size)
  33 {
  34         strlcpy(buf, "Reset Status: WARM", size);
  35
  36         return 0;
  37 }
  38
  39 int sandbox_warm_sysreset_get_last(struct udevice *dev)
  40 {
  41         return SYSRESET_WARM;
  42 }
  43
  44 static int sandbox_sysreset_request(struct udevice *dev, enum sysreset_t type)
  45 {
  46         struct sandbox_state *state = state_get_current();
  47
  48         /*
  49          * If we have a device tree, the device we created from platform data
  50          * (see the U_BOOT_DRVINFO() declaration below) should not do anything.
  51          * If we are that device, return an error.
  52          */
  53         if (state->fdt_fname && !dev_has_ofnode(dev))
  54                 return -ENODEV;
  55
  56         switch (type) {
  57         case SYSRESET_COLD:
  58                 state->last_sysreset = type;
  59                 if (!state->sysreset_allowed[type])
  60                         return -EACCES;
  61                 sandbox_reset();
  62                 break;
  63         case SYSRESET_POWER_OFF:
  64                 state->last_sysreset = type;
  65                 if (!state->sysreset_allowed[type])
  66                         return -EACCES;
  67                 sandbox_exit();
  68                 break;
  69         case SYSRESET_POWER:
  70                 if (!state->sysreset_allowed[type])
  71                         return -EACCES;
  72                 sandbox_exit();
  73         default:
  74                 return -ENOSYS;
  75         }
  76         if (!state->sysreset_allowed[type])
  77                 return -EACCES;
  78
  79         return -EINPROGRESS;
  80 }
  81
  82 int sandbox_sysreset_get_status(struct udevice *dev, char *buf, int size)
  83 {
  84         strlcpy(buf, "Reset Status: COLD", size);
  85
  86         return 0;
  87 }
  88
  89 int sandbox_sysreset_get_last(struct udevice *dev)
  90 {
  91         struct sandbox_state *state = state_get_current();
  92
  93         /*
  94          * The first phase is a power reset, after that we assume we don't
  95          * know.
  96          */
  97         return state->jumped_fname ? SYSRESET_WARM : SYSRESET_POWER;
  98 }
  99
 100 static struct sysreset_ops sandbox_sysreset_ops = {
 101         .request        = sandbox_sysreset_request,
 102         .get_status     = sandbox_sysreset_get_status,
 103         .get_last       = sandbox_sysreset_get_last,
 104 };
 105
 106 static const struct udevice_id sandbox_sysreset_ids[] = {
 107         { .compatible = "sandbox,reset" },
 108         { }
 109 };
 110
 111 U_BOOT_DRIVER(sysreset_sandbox) = {
 112         .name           = "sysreset_sandbox",
 113         .id             = UCLASS_SYSRESET,
 114         .of_match       = sandbox_sysreset_ids,
 115         .ops            = &sandbox_sysreset_ops,
 116 };
 117
 118 static struct sysreset_ops sandbox_warm_sysreset_ops = {
 119         .request        = sandbox_warm_sysreset_request,
 120         .get_status     = sandbox_warm_sysreset_get_status,
 121         .get_last       = sandbox_warm_sysreset_get_last,
 122 };
 123
 124 static const struct udevice_id sandbox_warm_sysreset_ids[] = {
 125         { .compatible = "sandbox,warm-reset" },
 126         { }
 127 };
 128
 129 U_BOOT_DRIVER(warm_sysreset_sandbox) = {
 130         .name           = "warm_sysreset_sandbox",
 131         .id             = UCLASS_SYSRESET,
 132         .of_match       = sandbox_warm_sysreset_ids,
 133         .ops            = &sandbox_warm_sysreset_ops,
 134 };
 135
 136 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
 137 /* This is here in case we don't have a device tree */
 138 U_BOOT_DRVINFO(sysreset_sandbox_non_fdt) = {
 139         .name = "sysreset_sandbox",
 140 };
 141 #endif