drivers/misc/imx8/scu_api.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2018 NXP
   4  *
   5  * Peng Fan <peng.fan@nxp.com>
   6  */
   7
   8 #include <common.h>
   9 #include <asm/io.h>
  10 #include <dm.h>
  11 #include <asm/arch/sci/sci.h>
  12 #include <misc.h>
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 /* CLK and PM */
  17 int sc_pm_set_clock_rate(sc_ipc_t ipc, sc_rsrc_t resource, sc_pm_clk_t clk,
  18                          sc_pm_clock_rate_t *rate)
  19 {
  20         struct udevice *dev = gd->arch.scu_dev;
  21         int size = sizeof(struct sc_rpc_msg_s);
  22         struct sc_rpc_msg_s msg;
  23         int ret;
  24
  25         RPC_VER(&msg) = SC_RPC_VERSION;
  26         RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
  27         RPC_FUNC(&msg) = (u8)PM_FUNC_SET_CLOCK_RATE;
  28         RPC_U32(&msg, 0U) = *(u32 *)rate;
  29         RPC_U16(&msg, 4U) = (u16)resource;
  30         RPC_U8(&msg, 6U) = (u8)clk;
  31         RPC_SIZE(&msg) = 3U;
  32
  33         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
  34         if (ret)
  35                 printf("%s: rate:%u resource:%u: clk:%u res:%d\n",
  36                        __func__, *rate, resource, clk, RPC_R8(&msg));
  37
  38         *rate = RPC_U32(&msg, 0U);
  39
  40         return ret;
  41 }
  42
  43 int sc_pm_get_clock_rate(sc_ipc_t ipc, sc_rsrc_t resource, sc_pm_clk_t clk,
  44                          sc_pm_clock_rate_t *rate)
  45 {
  46         struct udevice *dev = gd->arch.scu_dev;
  47         int size = sizeof(struct sc_rpc_msg_s);
  48         struct sc_rpc_msg_s msg;
  49         int ret;
  50
  51         RPC_VER(&msg) = SC_RPC_VERSION;
  52         RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
  53         RPC_FUNC(&msg) = (u8)PM_FUNC_GET_CLOCK_RATE;
  54         RPC_U16(&msg, 0U) = (u16)resource;
  55         RPC_U8(&msg, 2U) = (u8)clk;
  56         RPC_SIZE(&msg) = 2U;
  57
  58         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
  59         if (ret) {
  60                 printf("%s: resource:%d clk:%d: res:%d\n",
  61                        __func__, resource, clk, RPC_R8(&msg));
  62                 return ret;
  63         }
  64
  65         if (rate)
  66                 *rate = RPC_U32(&msg, 0U);
  67
  68         return 0;
  69 }
  70
  71 int sc_pm_clock_enable(sc_ipc_t ipc, sc_rsrc_t resource, sc_pm_clk_t clk,
  72                        sc_bool_t enable, sc_bool_t autog)
  73 {
  74         struct udevice *dev = gd->arch.scu_dev;
  75         int size = sizeof(struct sc_rpc_msg_s);
  76         struct sc_rpc_msg_s msg;
  77         int ret;
  78
  79         RPC_VER(&msg) = SC_RPC_VERSION;
  80         RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
  81         RPC_FUNC(&msg) = (u8)PM_FUNC_CLOCK_ENABLE;
  82         RPC_U16(&msg, 0U) = (u16)resource;
  83         RPC_U8(&msg, 2U) = (u8)clk;
  84         RPC_U8(&msg, 3U) = (u8)enable;
  85         RPC_U8(&msg, 4U) = (u8)autog;
  86         RPC_SIZE(&msg) = 3U;
  87
  88         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
  89         if (ret)
  90                 printf("%s: resource:%d clk:%d: enable:%d autog: %d, res:%d\n",
  91                        __func__, resource, clk, enable, autog, RPC_R8(&msg));
  92
  93         return ret;
  94 }
  95
  96 int sc_pm_set_resource_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
  97                                   sc_pm_power_mode_t mode)
  98 {
  99         struct udevice *dev = gd->arch.scu_dev;
 100         int size = sizeof(struct sc_rpc_msg_s);
 101         struct sc_rpc_msg_s msg;
 102         int ret;
 103
 104         if (!dev)
 105                 hang();
 106
 107         RPC_VER(&msg) = SC_RPC_VERSION;
 108         RPC_SVC(&msg) = (u8)SC_RPC_SVC_PM;
 109         RPC_FUNC(&msg) = (u8)PM_FUNC_SET_RESOURCE_POWER_MODE;
 110         RPC_U16(&msg, 0U) = (u16)resource;
 111         RPC_U8(&msg, 2U) = (u8)mode;
 112         RPC_SIZE(&msg) = 2U;
 113
 114         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 115         if (ret)
 116                 printf("%s: resource:%d mode:%d: res:%d\n",
 117                        __func__, resource, mode, RPC_R8(&msg));
 118
 119         return ret;
 120 }
 121
 122 /* PAD */
 123 int sc_pad_set(sc_ipc_t ipc, sc_pad_t pad, u32 val)
 124 {
 125         struct udevice *dev = gd->arch.scu_dev;
 126         int size = sizeof(struct sc_rpc_msg_s);
 127         struct sc_rpc_msg_s msg;
 128         int ret;
 129
 130         if (!dev)
 131                 hang();
 132
 133         RPC_VER(&msg) = SC_RPC_VERSION;
 134         RPC_SVC(&msg) = (u8)SC_RPC_SVC_PAD;
 135         RPC_FUNC(&msg) = (u8)PAD_FUNC_SET;
 136         RPC_U32(&msg, 0U) = (u32)val;
 137         RPC_U16(&msg, 4U) = (u16)pad;
 138         RPC_SIZE(&msg) = 3U;
 139
 140         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 141         if (ret)
 142                 printf("%s: val:%d pad:%d: res:%d\n",
 143                        __func__, val, pad, RPC_R8(&msg));
 144
 145         return ret;
 146 }
 147
 148 /* MISC */
 149 int sc_misc_get_control(sc_ipc_t ipc, sc_rsrc_t resource, sc_ctrl_t ctrl,
 150                         u32 *val)
 151 {
 152         struct udevice *dev = gd->arch.scu_dev;
 153         int size = sizeof(struct sc_rpc_msg_s);
 154         struct sc_rpc_msg_s msg;
 155         int ret;
 156
 157         if (!dev)
 158                 hang();
 159
 160         RPC_VER(&msg) = SC_RPC_VERSION;
 161         RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
 162         RPC_FUNC(&msg) = (u8)MISC_FUNC_GET_CONTROL;
 163         RPC_U32(&msg, 0U) = (u32)ctrl;
 164         RPC_U16(&msg, 4U) = (u16)resource;
 165         RPC_SIZE(&msg) = 3U;
 166
 167         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 168         if (ret)
 169                 printf("%s: ctrl:%d resource:%d: res:%d\n",
 170                        __func__, ctrl, resource, RPC_R8(&msg));
 171
 172         if (!val)
 173                 *val = RPC_U32(&msg, 0U);
 174
 175         return ret;
 176 }
 177
 178 void sc_misc_get_boot_dev(sc_ipc_t ipc, sc_rsrc_t *boot_dev)
 179 {
 180         struct udevice *dev = gd->arch.scu_dev;
 181         int size = sizeof(struct sc_rpc_msg_s);
 182         struct sc_rpc_msg_s msg;
 183         int ret;
 184
 185         if (!dev)
 186                 hang();
 187
 188         RPC_VER(&msg) = SC_RPC_VERSION;
 189         RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
 190         RPC_FUNC(&msg) = (u8)MISC_FUNC_GET_BOOT_DEV;
 191         RPC_SIZE(&msg) = 1U;
 192
 193         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 194         if (ret)
 195                 printf("%s: res:%d\n", __func__, RPC_R8(&msg));
 196
 197         if (!boot_dev)
 198                 *boot_dev = RPC_U16(&msg, 0U);
 199 }
 200
 201 void sc_misc_boot_status(sc_ipc_t ipc, sc_misc_boot_status_t status)
 202 {
 203         struct udevice *dev = gd->arch.scu_dev;
 204         int size = sizeof(struct sc_rpc_msg_s);
 205         struct sc_rpc_msg_s msg;
 206         int ret;
 207
 208         if (!dev)
 209                 hang();
 210
 211         RPC_VER(&msg) = SC_RPC_VERSION;
 212         RPC_SVC(&msg) = (u8)SC_RPC_SVC_MISC;
 213         RPC_FUNC(&msg) = (u8)MISC_FUNC_BOOT_STATUS;
 214         RPC_U8(&msg, 0U) = (u8)status;
 215         RPC_SIZE(&msg) = 2U;
 216
 217         ret = misc_call(dev, SC_TRUE, &msg, size, &msg, size);
 218         if (ret)
 219                 printf("%s: status:%d res:%d\n",
 220                        __func__, status, RPC_R8(&msg));
 221 }
 222
 223 void sc_misc_build_info(sc_ipc_t ipc, u32 *build, u32 *commit)
 224 {
 225         struct udevice *dev = gd->arch.scu_dev;
 226         int size = sizeof(struct sc_rpc_msg_s);
 227         struct sc_rpc_msg_s msg;
 228         int ret;
 229
 230         if (!dev)
 231                 hang();
 232
 233         RPC_VER(&msg) = SC_RPC_VERSION;
 234         RPC_SVC(&msg) = SC_RPC_SVC_MISC;
 235         RPC_FUNC(&msg) = MISC_FUNC_BUILD_INFO;
 236         RPC_SIZE(&msg) = 1;
 237
 238         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 239         if (ret < 0) {
 240                 printf("%s: err: %d\n", __func__, ret);
 241                 return;
 242         }
 243
 244         if (build)
 245                 *build = RPC_U32(&msg, 0);
 246         if (commit)
 247                 *commit = RPC_U32(&msg, 4);
 248 }
 249
 250 int sc_misc_otp_fuse_read(sc_ipc_t ipc, u32 word, u32 *val)
 251 {
 252         struct udevice *dev = gd->arch.scu_dev;
 253         int size = sizeof(struct sc_rpc_msg_s);
 254         struct sc_rpc_msg_s msg;
 255         int ret;
 256
 257         if (!dev)
 258                 hang();
 259
 260         RPC_VER(&msg) = SC_RPC_VERSION;
 261         RPC_SVC(&msg) = SC_RPC_SVC_MISC;
 262         RPC_FUNC(&msg) = MISC_FUNC_OTP_FUSE_READ;
 263         RPC_U32(&msg, 0) = word;
 264         RPC_SIZE(&msg) = 2;
 265
 266         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 267         if (ret < 0)
 268                 return ret;
 269
 270         if (val)
 271                 *val = RPC_U32(&msg, 0U);
 272
 273         return 0;
 274 }
 275
 276 /* RM */
 277 sc_bool_t sc_rm_is_memreg_owned(sc_ipc_t ipc, sc_rm_mr_t mr)
 278 {
 279         struct udevice *dev = gd->arch.scu_dev;
 280         int size = sizeof(struct sc_rpc_msg_s);
 281         struct sc_rpc_msg_s msg;
 282         int ret;
 283         sc_err_t result;
 284
 285         if (!dev)
 286                 hang();
 287
 288         RPC_VER(&msg) = SC_RPC_VERSION;
 289         RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
 290         RPC_FUNC(&msg) = (u8)RM_FUNC_IS_MEMREG_OWNED;
 291         RPC_U8(&msg, 0U) = (u8)mr;
 292         RPC_SIZE(&msg) = 2U;
 293
 294         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 295         result = RPC_R8(&msg);
 296
 297         if (result != 0 && result != 1) {
 298                 printf("%s: mr:%d res:%d\n", __func__, mr, RPC_R8(&msg));
 299                 if (ret)
 300                         printf("%s: mr:%d res:%d\n", __func__, mr,
 301                                RPC_R8(&msg));
 302         }
 303
 304         return (sc_bool_t)result;
 305 }
 306
 307 int sc_rm_get_memreg_info(sc_ipc_t ipc, sc_rm_mr_t mr, sc_faddr_t *addr_start,
 308                           sc_faddr_t *addr_end)
 309 {
 310         struct udevice *dev = gd->arch.scu_dev;
 311         int size = sizeof(struct sc_rpc_msg_s);
 312         struct sc_rpc_msg_s msg;
 313         int ret;
 314
 315         if (!dev)
 316                 hang();
 317
 318         RPC_VER(&msg) = SC_RPC_VERSION;
 319         RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
 320         RPC_FUNC(&msg) = (u8)RM_FUNC_GET_MEMREG_INFO;
 321         RPC_U8(&msg, 0U) = (u8)mr;
 322         RPC_SIZE(&msg) = 2U;
 323
 324         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 325         if (ret)
 326                 printf("%s: mr:%d res:%d\n", __func__, mr, RPC_R8(&msg));
 327
 328         if (addr_start)
 329                 *addr_start = ((u64)RPC_U32(&msg, 0U) << 32U) |
 330                         RPC_U32(&msg, 4U);
 331
 332         if (addr_end)
 333                 *addr_end = ((u64)RPC_U32(&msg, 8U) << 32U) |
 334                         RPC_U32(&msg, 12U);
 335
 336         return ret;
 337 }
 338
 339 sc_bool_t sc_rm_is_resource_owned(sc_ipc_t ipc, sc_rsrc_t resource)
 340 {
 341         struct udevice *dev = gd->arch.scu_dev;
 342         int size = sizeof(struct sc_rpc_msg_s);
 343         struct sc_rpc_msg_s msg;
 344         int ret;
 345         u8 result;
 346
 347         if (!dev)
 348                 hang();
 349
 350         RPC_VER(&msg) = SC_RPC_VERSION;
 351         RPC_SVC(&msg) = (u8)SC_RPC_SVC_RM;
 352         RPC_FUNC(&msg) = (u8)RM_FUNC_IS_RESOURCE_OWNED;
 353         RPC_U16(&msg, 0U) = (u16)resource;
 354         RPC_SIZE(&msg) = 2U;
 355
 356         ret = misc_call(dev, SC_FALSE, &msg, size, &msg, size);
 357         result = RPC_R8(&msg);
 358         if (result != 0 && result != 1) {
 359                 printf("%s: resource:%d res:%d\n",
 360                        __func__, resource, RPC_R8(&msg));
 361                 if (ret)
 362                         printf("%s: res:%d res:%d\n", __func__, resource,
 363                                RPC_R8(&msg));
 364         }
 365
 366         return !!result;
 367 }