LXR uboot/drivers/firmware/scmi/scmi

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2020 Linaro Limited.
   4 */
   5
   6#define LOG_CATEGORY UCLASS_SCMI_AGENT
   7
   8#include <common.h>
   9#include <dm.h>
  10#include <errno.h>
  11#include <scmi_agent-uclass.h>
  12#include <scmi_protocols.h>
  13#include <dm/device_compat.h>
  14#include <dm/device-internal.h>
  15#include <linux/compat.h>
  16
  17/**
  18 * struct error_code - Helper structure for SCMI error code conversion
  19 * @scmi:       SCMI error code
  20 * @errno:      Related standard error number
  21 */
  22struct error_code {
  23        int scmi;
  24        int errno;
  25};
  26
  27static const struct error_code scmi_linux_errmap[] = {
  28        { .scmi = SCMI_NOT_SUPPORTED, .errno = -EOPNOTSUPP, },
  29        { .scmi = SCMI_INVALID_PARAMETERS, .errno = -EINVAL, },
  30        { .scmi = SCMI_DENIED, .errno = -EACCES, },
  31        { .scmi = SCMI_NOT_FOUND, .errno = -ENOENT, },
  32        { .scmi = SCMI_OUT_OF_RANGE, .errno = -ERANGE, },
  33        { .scmi = SCMI_BUSY, .errno = -EBUSY, },
  34        { .scmi = SCMI_COMMS_ERROR, .errno = -ECOMM, },
  35        { .scmi = SCMI_GENERIC_ERROR, .errno = -EIO, },
  36        { .scmi = SCMI_HARDWARE_ERROR, .errno = -EREMOTEIO, },
  37        { .scmi = SCMI_PROTOCOL_ERROR, .errno = -EPROTO, },
  38};
  39
  40int scmi_to_linux_errno(s32 scmi_code)
  41{
  42        int n;
  43
  44        if (!scmi_code)
  45                return 0;
  46
  47        for (n = 0; n < ARRAY_SIZE(scmi_linux_errmap); n++)
  48                if (scmi_code == scmi_linux_errmap[n].scmi)
  49                        return scmi_linux_errmap[1].errno;
  50
  51        return -EPROTO;
  52}
  53
  54/*
  55 * SCMI agent devices binds devices of various uclasses depeding on
  56 * the FDT description. scmi_bind_protocol() is a generic bind sequence
  57 * called by the uclass at bind stage, that is uclass post_bind.
  58 */
  59static int scmi_bind_protocols(struct udevice *dev)
  60{
  61        int ret = 0;
  62        ofnode node;
  63        const char *name;
  64
  65        dev_for_each_subnode(node, dev) {
  66                struct driver *drv = NULL;
  67                u32 protocol_id;
  68
  69                if (!ofnode_is_enabled(node))
  70                        continue;
  71
  72                if (ofnode_read_u32(node, "reg", &protocol_id))
  73                        continue;
  74
  75                name = ofnode_get_name(node);
  76                switch (protocol_id) {
  77                case SCMI_PROTOCOL_ID_CLOCK:
  78                        if (IS_ENABLED(CONFIG_CLK_SCMI))
  79                                drv = DM_DRIVER_GET(scmi_clock);
  80                        break;
  81                case SCMI_PROTOCOL_ID_RESET_DOMAIN:
  82                        if (IS_ENABLED(CONFIG_RESET_SCMI))
  83                                drv = DM_DRIVER_GET(scmi_reset_domain);
  84                        break;
  85                case SCMI_PROTOCOL_ID_VOLTAGE_DOMAIN:
  86                        if (IS_ENABLED(CONFIG_DM_REGULATOR_SCMI)) {
  87                                node = ofnode_find_subnode(node, "regulators");
  88                                if (!ofnode_valid(node)) {
  89                                        dev_err(dev, "no regulators node\n");
  90                                        return -ENXIO;
  91                                }
  92                                drv = DM_DRIVER_GET(scmi_voltage_domain);
  93                        }
  94                        break;
  95                default:
  96                        break;
  97                }
  98
  99                if (!drv) {
 100                        dev_dbg(dev, "Ignore unsupported SCMI protocol %#x\n",
 101                                protocol_id);
 102                        continue;
 103                }
 104
 105                ret = device_bind(dev, drv, name, NULL, node, NULL);
 106                if (ret)
 107                        break;
 108        }
 109
 110        return ret;
 111}
 112
 113static struct udevice *find_scmi_transport_device(struct udevice *dev)
 114{
 115        struct udevice *parent = dev;
 116
 117        do {
 118                parent = dev_get_parent(parent);
 119        } while (parent && device_get_uclass_id(parent) != UCLASS_SCMI_AGENT);
 120
 121        if (!parent)
 122                dev_err(dev, "Invalid SCMI device, agent not found\n");
 123
 124        return parent;
 125}
 126
 127static const struct scmi_agent_ops *transport_dev_ops(struct udevice *dev)
 128{
 129        return (const struct scmi_agent_ops *)dev->driver->ops;
 130}
 131
 132int devm_scmi_of_get_channel(struct udevice *dev, struct scmi_channel **channel)
 133{
 134        struct udevice *parent;
 135
 136        parent = find_scmi_transport_device(dev);
 137        if (!parent)
 138                return -ENODEV;
 139
 140        if (transport_dev_ops(parent)->of_get_channel)
 141                return transport_dev_ops(parent)->of_get_channel(parent, channel);
 142
 143        /* Drivers without a get_channel operator don't need a channel ref */
 144        *channel = NULL;
 145
 146        return 0;
 147}
 148
 149int devm_scmi_process_msg(struct udevice *dev, struct scmi_channel *channel,
 150                          struct scmi_msg *msg)
 151{
 152        const struct scmi_agent_ops *ops;
 153        struct udevice *parent;
 154
 155        parent = find_scmi_transport_device(dev);
 156        if (!parent)
 157                return -ENODEV;
 158
 159        ops = transport_dev_ops(parent);
 160
 161        if (ops->process_msg)
 162                return ops->process_msg(parent, channel, msg);
 163
 164        return -EPROTONOSUPPORT;
 165}
 166
 167UCLASS_DRIVER(scmi_agent) = {
 168        .id             = UCLASS_SCMI_AGENT,
 169        .name           = "scmi_agent",
 170        .post_bind      = scmi_bind_protocols,
 171};
 172