git.sur5r.net Git - u-boot/blob - drivers/remoteproc/ti_power_proc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2015-2016
   4  * Texas Instruments Incorporated - http://www.ti.com/
   5  */
   6 #define pr_fmt(fmt) "%s: " fmt, __func__
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <errno.h>
  10 #include <fdtdec.h>
  11 #include <remoteproc.h>
  12 #include <mach/psc_defs.h>
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 /**
  17  * struct ti_powerproc_privdata - power processor private data
  18  * @loadaddr:   base address for loading the power processor
  19  * @psc_module: psc module address.
  20  */
  21 struct ti_powerproc_privdata {
  22         phys_addr_t loadaddr;
  23         u32 psc_module;
  24 };
  25
  26 /**
  27  * ti_of_to_priv() - generate private data from device tree
  28  * @dev:        corresponding ti remote processor device
  29  * @priv:       pointer to driver specific private data
  30  *
  31  * Return: 0 if all went ok, else corresponding -ve error
  32  */
  33 static int ti_of_to_priv(struct udevice *dev,
  34                          struct ti_powerproc_privdata *priv)
  35 {
  36         int node = dev_of_offset(dev);
  37         const void *blob = gd->fdt_blob;
  38         int tmp;
  39
  40         if (!blob) {
  41                 debug("'%s' no dt?\n", dev->name);
  42                 return -EINVAL;
  43         }
  44
  45         priv->loadaddr = fdtdec_get_addr(blob, node, "reg");
  46         if (priv->loadaddr == FDT_ADDR_T_NONE) {
  47                 debug("'%s': no 'reg' property\n", dev->name);
  48                 return -EINVAL;
  49         }
  50
  51         tmp = fdtdec_get_int(blob, node, "ti,lpsc_module", -EINVAL);
  52         if (tmp < 0) {
  53                 debug("'%s': no 'ti,lpsc_module' property\n", dev->name);
  54                 return tmp;
  55         }
  56         priv->psc_module = tmp;
  57
  58         return 0;
  59 }
  60
  61 /**
  62  * ti_powerproc_probe() - Basic probe
  63  * @dev:        corresponding ti remote processor device
  64  *
  65  * Return: 0 if all went ok, else corresponding -ve error
  66  */
  67 static int ti_powerproc_probe(struct udevice *dev)
  68 {
  69         struct dm_rproc_uclass_pdata *uc_pdata;
  70         struct ti_powerproc_privdata *priv;
  71         int ret;
  72
  73         uc_pdata = dev_get_uclass_platdata(dev);
  74         priv = dev_get_priv(dev);
  75
  76         ret = ti_of_to_priv(dev, priv);
  77
  78         debug("%s probed with slave_addr=0x%08lX module=%d(%d)\n",
  79               uc_pdata->name, priv->loadaddr, priv->psc_module, ret);
  80
  81         return ret;
  82 }
  83
  84 /**
  85  * ti_powerproc_load() - Loadup the TI remote processor
  86  * @dev:        corresponding ti remote processor device
  87  * @addr:       Address in memory where image binary is stored
  88  * @size:       Size in bytes of the image binary
  89  *
  90  * Return: 0 if all went ok, else corresponding -ve error
  91  */
  92 static int ti_powerproc_load(struct udevice *dev, ulong addr, ulong size)
  93 {
  94         struct dm_rproc_uclass_pdata *uc_pdata;
  95         struct ti_powerproc_privdata *priv;
  96         int ret;
  97
  98         uc_pdata = dev_get_uclass_platdata(dev);
  99         if (!uc_pdata) {
 100                 debug("%s: no uc pdata!\n", dev->name);
 101                 return -EINVAL;
 102         }
 103
 104         priv = dev_get_priv(dev);
 105         ret = psc_module_keep_in_reset_enabled(priv->psc_module, false);
 106         if (ret) {
 107                 debug("%s Unable to disable module '%d'(ret=%d)\n",
 108                       uc_pdata->name, priv->psc_module, ret);
 109                 return ret;
 110         }
 111
 112         debug("%s: Loading binary from 0x%08lX, size 0x%08lX to 0x%08lX\n",
 113               uc_pdata->name, addr, size, priv->loadaddr);
 114
 115         memcpy((void *)priv->loadaddr, (void *)addr, size);
 116
 117         debug("%s: Complete!\n", uc_pdata->name);
 118         return 0;
 119 }
 120
 121 /**
 122  * ti_powerproc_start() - (replace: short desc)
 123  * @dev:        corresponding ti remote processor device
 124  *
 125  * Return: 0 if all went ok, else corresponding -ve error
 126  */
 127 static int ti_powerproc_start(struct udevice *dev)
 128 {
 129         struct dm_rproc_uclass_pdata *uc_pdata;
 130         struct ti_powerproc_privdata *priv;
 131         int ret;
 132
 133         uc_pdata = dev_get_uclass_platdata(dev);
 134         if (!uc_pdata) {
 135                 debug("%s: no uc pdata!\n", dev->name);
 136                 return -EINVAL;
 137         }
 138
 139         priv = dev_get_priv(dev);
 140         ret = psc_disable_module(priv->psc_module);
 141         if (ret) {
 142                 debug("%s Unable to disable module '%d'(ret=%d)\n",
 143                       uc_pdata->name, priv->psc_module, ret);
 144                 return ret;
 145         }
 146
 147         ret = psc_module_release_from_reset(priv->psc_module);
 148         if (ret) {
 149                 debug("%s Failed to wait for module '%d'(ret=%d)\n",
 150                       uc_pdata->name, priv->psc_module, ret);
 151                 return ret;
 152         }
 153         ret = psc_enable_module(priv->psc_module);
 154         if (ret) {
 155                 debug("%s Unable to disable module '%d'(ret=%d)\n",
 156                       uc_pdata->name, priv->psc_module, ret);
 157                 return ret;
 158         }
 159
 160         return 0;
 161 }
 162
 163 static const struct dm_rproc_ops ti_powerproc_ops = {
 164         .load = ti_powerproc_load,
 165         .start = ti_powerproc_start,
 166 };
 167
 168 static const struct udevice_id ti_powerproc_ids[] = {
 169         {.compatible = "ti,power-processor"},
 170         {}
 171 };
 172
 173 U_BOOT_DRIVER(ti_powerproc) = {
 174         .name = "ti_power_proc",
 175         .of_match = ti_powerproc_ids,
 176         .id = UCLASS_REMOTEPROC,
 177         .ops = &ti_powerproc_ops,
 178         .probe = ti_powerproc_probe,
 179         .priv_auto_alloc_size = sizeof(struct ti_powerproc_privdata),
 180 };