drivers/firmware/ti_sci.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Texas Instruments System Control Interface Protocol Driver
   4  * Based on drivers/firmware/ti_sci.c from Linux.
   5  *
   6  * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/
   7  *      Lokesh Vutla <lokeshvutla@ti.com>
   8  */
   9
  10 #include <common.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <mailbox.h>
  14 #include <malloc.h>
  15 #include <dm/device.h>
  16 #include <dm/device_compat.h>
  17 #include <dm/devres.h>
  18 #include <linux/compat.h>
  19 #include <linux/err.h>
  20 #include <linux/soc/ti/k3-sec-proxy.h>
  21 #include <linux/soc/ti/ti_sci_protocol.h>
  22
  23 #include "ti_sci.h"
  24
  25 /* List of all TI SCI devices active in system */
  26 static LIST_HEAD(ti_sci_list);
  27
  28 /**
  29  * struct ti_sci_xfer - Structure representing a message flow
  30  * @tx_message: Transmit message
  31  * @rx_len:     Receive message length
  32  */
  33 struct ti_sci_xfer {
  34         struct k3_sec_proxy_msg tx_message;
  35         u8 rx_len;
  36 };
  37
  38 /**
  39  * struct ti_sci_rm_type_map - Structure representing TISCI Resource
  40  *                              management representation of dev_ids.
  41  * @dev_id:     TISCI device ID
  42  * @type:       Corresponding id as identified by TISCI RM.
  43  *
  44  * Note: This is used only as a work around for using RM range apis
  45  *      for AM654 SoC. For future SoCs dev_id will be used as type
  46  *      for RM range APIs. In order to maintain ABI backward compatibility
  47  *      type is not being changed for AM654 SoC.
  48  */
  49 struct ti_sci_rm_type_map {
  50         u32 dev_id;
  51         u16 type;
  52 };
  53
  54 /**
  55  * struct ti_sci_desc - Description of SoC integration
  56  * @default_host_id:    Host identifier representing the compute entity
  57  * @max_rx_timeout_ms:  Timeout for communication with SoC (in Milliseconds)
  58  * @max_msgs: Maximum number of messages that can be pending
  59  *                simultaneously in the system
  60  * @max_msg_size: Maximum size of data per message that can be handled.
  61  * @rm_type_map: RM resource type mapping structure.
  62  */
  63 struct ti_sci_desc {
  64         u8 default_host_id;
  65         int max_rx_timeout_ms;
  66         int max_msgs;
  67         int max_msg_size;
  68         struct ti_sci_rm_type_map *rm_type_map;
  69 };
  70
  71 /**
  72  * struct ti_sci_info - Structure representing a TI SCI instance
  73  * @dev:        Device pointer
  74  * @desc:       SoC description for this instance
  75  * @handle:     Instance of TI SCI handle to send to clients.
  76  * @chan_tx:    Transmit mailbox channel
  77  * @chan_rx:    Receive mailbox channel
  78  * @xfer:       xfer info
  79  * @list:       list head
  80  * @is_secure:  Determines if the communication is through secure threads.
  81  * @host_id:    Host identifier representing the compute entity
  82  * @seq:        Seq id used for verification for tx and rx message.
  83  */
  84 struct ti_sci_info {
  85         struct udevice *dev;
  86         const struct ti_sci_desc *desc;
  87         struct ti_sci_handle handle;
  88         struct mbox_chan chan_tx;
  89         struct mbox_chan chan_rx;
  90         struct mbox_chan chan_notify;
  91         struct ti_sci_xfer xfer;
  92         struct list_head list;
  93         struct list_head dev_list;
  94         bool is_secure;
  95         u8 host_id;
  96         u8 seq;
  97 };
  98
  99 struct ti_sci_exclusive_dev {
 100         u32 id;
 101         u32 count;
 102         struct list_head list;
 103 };
 104
 105 #define handle_to_ti_sci_info(h) container_of(h, struct ti_sci_info, handle)
 106
 107 /**
 108  * ti_sci_setup_one_xfer() - Setup one message type
 109  * @info:       Pointer to SCI entity information
 110  * @msg_type:   Message type
 111  * @msg_flags:  Flag to set for the message
 112  * @buf:        Buffer to be send to mailbox channel
 113  * @tx_message_size: transmit message size
 114  * @rx_message_size: receive message size. may be set to zero for send-only
 115  *                   transactions.
 116  *
 117  * Helper function which is used by various command functions that are
 118  * exposed to clients of this driver for allocating a message traffic event.
 119  *
 120  * Return: Corresponding ti_sci_xfer pointer if all went fine,
 121  *         else appropriate error pointer.
 122  */
 123 static struct ti_sci_xfer *ti_sci_setup_one_xfer(struct ti_sci_info *info,
 124                                                  u16 msg_type, u32 msg_flags,
 125                                                  u32 *buf,
 126                                                  size_t tx_message_size,
 127                                                  size_t rx_message_size)
 128 {
 129         struct ti_sci_xfer *xfer = &info->xfer;
 130         struct ti_sci_msg_hdr *hdr;
 131
 132         /* Ensure we have sane transfer sizes */
 133         if (rx_message_size > info->desc->max_msg_size ||
 134             tx_message_size > info->desc->max_msg_size ||
 135             (rx_message_size > 0 && rx_message_size < sizeof(*hdr)) ||
 136             tx_message_size < sizeof(*hdr))
 137                 return ERR_PTR(-ERANGE);
 138
 139         info->seq = ~info->seq;
 140         xfer->tx_message.buf = buf;
 141         xfer->tx_message.len = tx_message_size;
 142         xfer->rx_len = (u8)rx_message_size;
 143
 144         hdr = (struct ti_sci_msg_hdr *)buf;
 145         hdr->seq = info->seq;
 146         hdr->type = msg_type;
 147         hdr->host = info->host_id;
 148         hdr->flags = msg_flags;
 149
 150         return xfer;
 151 }
 152
 153 /**
 154  * ti_sci_get_response() - Receive response from mailbox channel
 155  * @info:       Pointer to SCI entity information
 156  * @xfer:       Transfer to initiate and wait for response
 157  * @chan:       Channel to receive the response
 158  *
 159  * Return: -ETIMEDOUT in case of no response, if transmit error,
 160  *         return corresponding error, else if all goes well,
 161  *         return 0.
 162  */
 163 static inline int ti_sci_get_response(struct ti_sci_info *info,
 164                                       struct ti_sci_xfer *xfer,
 165                                       struct mbox_chan *chan)
 166 {
 167         struct k3_sec_proxy_msg *msg = &xfer->tx_message;
 168         struct ti_sci_secure_msg_hdr *secure_hdr;
 169         struct ti_sci_msg_hdr *hdr;
 170         int ret;
 171
 172         /* Receive the response */
 173         ret = mbox_recv(chan, msg, info->desc->max_rx_timeout_ms * 1000);
 174         if (ret) {
 175                 dev_err(info->dev, "%s: Message receive failed. ret = %d\n",
 176                         __func__, ret);
 177                 return ret;
 178         }
 179
 180         /* ToDo: Verify checksum */
 181         if (info->is_secure) {
 182                 secure_hdr = (struct ti_sci_secure_msg_hdr *)msg->buf;
 183                 msg->buf = (u32 *)((void *)msg->buf + sizeof(*secure_hdr));
 184         }
 185
 186         /* msg is updated by mailbox driver */
 187         hdr = (struct ti_sci_msg_hdr *)msg->buf;
 188
 189         /* Sanity check for message response */
 190         if (hdr->seq != info->seq) {
 191                 dev_dbg(info->dev, "%s: Message for %d is not expected\n",
 192                         __func__, hdr->seq);
 193                 return ret;
 194         }
 195
 196         if (msg->len > info->desc->max_msg_size) {
 197                 dev_err(info->dev, "%s: Unable to handle %zu xfer (max %d)\n",
 198                         __func__, msg->len, info->desc->max_msg_size);
 199                 return -EINVAL;
 200         }
 201
 202         if (msg->len < xfer->rx_len) {
 203                 dev_err(info->dev, "%s: Recv xfer %zu < expected %d length\n",
 204                         __func__, msg->len, xfer->rx_len);
 205         }
 206
 207         return ret;
 208 }
 209
 210 /**
 211  * ti_sci_do_xfer() - Do one transfer
 212  * @info:       Pointer to SCI entity information
 213  * @xfer:       Transfer to initiate and wait for response
 214  *
 215  * Return: 0 if all went fine, else return appropriate error.
 216  */
 217 static inline int ti_sci_do_xfer(struct ti_sci_info *info,
 218                                  struct ti_sci_xfer *xfer)
 219 {
 220         struct k3_sec_proxy_msg *msg = &xfer->tx_message;
 221         u8 secure_buf[info->desc->max_msg_size];
 222         struct ti_sci_secure_msg_hdr secure_hdr;
 223         int ret;
 224
 225         if (info->is_secure) {
 226                 /* ToDo: get checksum of the entire message */
 227                 secure_hdr.checksum = 0;
 228                 secure_hdr.reserved = 0;
 229                 memcpy(&secure_buf[sizeof(secure_hdr)], xfer->tx_message.buf,
 230                        xfer->tx_message.len);
 231
 232                 xfer->tx_message.buf = (u32 *)secure_buf;
 233                 xfer->tx_message.len += sizeof(secure_hdr);
 234
 235                 if (xfer->rx_len)
 236                         xfer->rx_len += sizeof(secure_hdr);
 237         }
 238
 239         /* Send the message */
 240         ret = mbox_send(&info->chan_tx, msg);
 241         if (ret) {
 242                 dev_err(info->dev, "%s: Message sending failed. ret = %d\n",
 243                         __func__, ret);
 244                 return ret;
 245         }
 246
 247         /* Get response if requested */
 248         if (xfer->rx_len)
 249                 ret = ti_sci_get_response(info, xfer, &info->chan_rx);
 250
 251         return ret;
 252 }
 253
 254 /**
 255  * ti_sci_cmd_get_revision() - command to get the revision of the SCI entity
 256  * @handle:     pointer to TI SCI handle
 257  *
 258  * Updates the SCI information in the internal data structure.
 259  *
 260  * Return: 0 if all went fine, else return appropriate error.
 261  */
 262 static int ti_sci_cmd_get_revision(struct ti_sci_handle *handle)
 263 {
 264         struct ti_sci_msg_resp_version *rev_info;
 265         struct ti_sci_version_info *ver;
 266         struct ti_sci_msg_hdr hdr;
 267         struct ti_sci_info *info;
 268         struct ti_sci_xfer *xfer;
 269         int ret;
 270
 271         if (IS_ERR(handle))
 272                 return PTR_ERR(handle);
 273         if (!handle)
 274                 return -EINVAL;
 275
 276         info = handle_to_ti_sci_info(handle);
 277
 278         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_VERSION,
 279                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
 280                                      (u32 *)&hdr, sizeof(struct ti_sci_msg_hdr),
 281                                      sizeof(*rev_info));
 282         if (IS_ERR(xfer)) {
 283                 ret = PTR_ERR(xfer);
 284                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
 285                 return ret;
 286         }
 287
 288         ret = ti_sci_do_xfer(info, xfer);
 289         if (ret) {
 290                 dev_err(info->dev, "Mbox communication fail %d\n", ret);
 291                 return ret;
 292         }
 293
 294         rev_info = (struct ti_sci_msg_resp_version *)xfer->tx_message.buf;
 295
 296         ver = &handle->version;
 297         ver->abi_major = rev_info->abi_major;
 298         ver->abi_minor = rev_info->abi_minor;
 299         ver->firmware_revision = rev_info->firmware_revision;
 300         strncpy(ver->firmware_description, rev_info->firmware_description,
 301                 sizeof(ver->firmware_description));
 302
 303         return 0;
 304 }
 305
 306 /**
 307  * ti_sci_is_response_ack() - Generic ACK/NACK message checkup
 308  * @r:  pointer to response buffer
 309  *
 310  * Return: true if the response was an ACK, else returns false.
 311  */
 312 static inline bool ti_sci_is_response_ack(void *r)
 313 {
 314         struct ti_sci_msg_hdr *hdr = r;
 315
 316         return hdr->flags & TI_SCI_FLAG_RESP_GENERIC_ACK ? true : false;
 317 }
 318
 319 /**
 320  * cmd_set_board_config_using_msg() - Common command to send board configuration
 321  *                                    message
 322  * @handle:     pointer to TI SCI handle
 323  * @msg_type:   One of the TISCI message types to set board configuration
 324  * @addr:       Address where the board config structure is located
 325  * @size:       Size of the board config structure
 326  *
 327  * Return: 0 if all went well, else returns appropriate error value.
 328  */
 329 static int cmd_set_board_config_using_msg(const struct ti_sci_handle *handle,
 330                                           u16 msg_type, u64 addr, u32 size)
 331 {
 332         struct ti_sci_msg_board_config req;
 333         struct ti_sci_msg_hdr *resp;
 334         struct ti_sci_info *info;
 335         struct ti_sci_xfer *xfer;
 336         int ret = 0;
 337
 338         if (IS_ERR(handle))
 339                 return PTR_ERR(handle);
 340         if (!handle)
 341                 return -EINVAL;
 342
 343         info = handle_to_ti_sci_info(handle);
 344
 345         xfer = ti_sci_setup_one_xfer(info, msg_type,
 346                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
 347                                      (u32 *)&req, sizeof(req), sizeof(*resp));
 348         if (IS_ERR(xfer)) {
 349                 ret = PTR_ERR(xfer);
 350                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
 351                 return ret;
 352         }
 353         req.boardcfgp_high = (addr >> 32) & 0xffffffff;
 354         req.boardcfgp_low = addr & 0xffffffff;
 355         req.boardcfg_size = size;
 356
 357         ret = ti_sci_do_xfer(info, xfer);
 358         if (ret) {
 359                 dev_err(info->dev, "Mbox send fail %d\n", ret);
 360                 return ret;
 361         }
 362
 363         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
 364
 365         if (!ti_sci_is_response_ack(resp))
 366                 return -ENODEV;
 367
 368         return ret;
 369 }
 370
 371 /**
 372  * ti_sci_cmd_set_board_config() - Command to send board configuration message
 373  * @handle:     pointer to TI SCI handle
 374  * @addr:       Address where the board config structure is located
 375  * @size:       Size of the board config structure
 376  *
 377  * Return: 0 if all went well, else returns appropriate error value.
 378  */
 379 static int ti_sci_cmd_set_board_config(const struct ti_sci_handle *handle,
 380                                        u64 addr, u32 size)
 381 {
 382         return cmd_set_board_config_using_msg(handle,
 383                                               TI_SCI_MSG_BOARD_CONFIG,
 384                                               addr, size);
 385 }
 386
 387 /**
 388  * ti_sci_cmd_set_board_config_rm() - Command to send board resource
 389  *                                    management configuration
 390  * @handle:     pointer to TI SCI handle
 391  * @addr:       Address where the board RM config structure is located
 392  * @size:       Size of the RM config structure
 393  *
 394  * Return: 0 if all went well, else returns appropriate error value.
 395  */
 396 static
 397 int ti_sci_cmd_set_board_config_rm(const struct ti_sci_handle *handle,
 398                                    u64 addr, u32 size)
 399 {
 400         return cmd_set_board_config_using_msg(handle,
 401                                               TI_SCI_MSG_BOARD_CONFIG_RM,
 402                                               addr, size);
 403 }
 404
 405 /**
 406  * ti_sci_cmd_set_board_config_security() - Command to send board security
 407  *                                          configuration message
 408  * @handle:     pointer to TI SCI handle
 409  * @addr:       Address where the board security config structure is located
 410  * @size:       Size of the security config structure
 411  *
 412  * Return: 0 if all went well, else returns appropriate error value.
 413  */
 414 static
 415 int ti_sci_cmd_set_board_config_security(const struct ti_sci_handle *handle,
 416                                          u64 addr, u32 size)
 417 {
 418         return cmd_set_board_config_using_msg(handle,
 419                                               TI_SCI_MSG_BOARD_CONFIG_SECURITY,
 420                                               addr, size);
 421 }
 422
 423 /**
 424  * ti_sci_cmd_set_board_config_pm() - Command to send board power and clock
 425  *                                    configuration message
 426  * @handle:     pointer to TI SCI handle
 427  * @addr:       Address where the board PM config structure is located
 428  * @size:       Size of the PM config structure
 429  *
 430  * Return: 0 if all went well, else returns appropriate error value.
 431  */
 432 static int ti_sci_cmd_set_board_config_pm(const struct ti_sci_handle *handle,
 433                                           u64 addr, u32 size)
 434 {
 435         return cmd_set_board_config_using_msg(handle,
 436                                               TI_SCI_MSG_BOARD_CONFIG_PM,
 437                                               addr, size);
 438 }
 439
 440 static struct ti_sci_exclusive_dev
 441 *ti_sci_get_exclusive_dev(struct list_head *dev_list, u32 id)
 442 {
 443         struct ti_sci_exclusive_dev *dev;
 444
 445         list_for_each_entry(dev, dev_list, list)
 446                 if (dev->id == id)
 447                         return dev;
 448
 449         return NULL;
 450 }
 451
 452 static void ti_sci_add_exclusive_dev(struct ti_sci_info *info, u32 id)
 453 {
 454         struct ti_sci_exclusive_dev *dev;
 455
 456         dev = ti_sci_get_exclusive_dev(&info->dev_list, id);
 457         if (dev) {
 458                 dev->count++;
 459                 return;
 460         }
 461
 462         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 463         dev->id = id;
 464         dev->count = 1;
 465         INIT_LIST_HEAD(&dev->list);
 466         list_add_tail(&dev->list, &info->dev_list);
 467 }
 468
 469 static void ti_sci_delete_exclusive_dev(struct ti_sci_info *info, u32 id)
 470 {
 471         struct ti_sci_exclusive_dev *dev;
 472
 473         dev = ti_sci_get_exclusive_dev(&info->dev_list, id);
 474         if (!dev)
 475                 return;
 476
 477         if (dev->count > 0)
 478                 dev->count--;
 479 }
 480
 481 /**
 482  * ti_sci_set_device_state() - Set device state helper
 483  * @handle:     pointer to TI SCI handle
 484  * @id:         Device identifier
 485  * @flags:      flags to setup for the device
 486  * @state:      State to move the device to
 487  *
 488  * Return: 0 if all went well, else returns appropriate error value.
 489  */
 490 static int ti_sci_set_device_state(const struct ti_sci_handle *handle,
 491                                    u32 id, u32 flags, u8 state)
 492 {
 493         struct ti_sci_msg_req_set_device_state req;
 494         struct ti_sci_msg_hdr *resp;
 495         struct ti_sci_info *info;
 496         struct ti_sci_xfer *xfer;
 497         int ret = 0;
 498
 499         if (IS_ERR(handle))
 500                 return PTR_ERR(handle);
 501         if (!handle)
 502                 return -EINVAL;
 503
 504         info = handle_to_ti_sci_info(handle);
 505
 506         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_SET_DEVICE_STATE,
 507                                      flags | TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
 508                                      (u32 *)&req, sizeof(req), sizeof(*resp));
 509         if (IS_ERR(xfer)) {
 510                 ret = PTR_ERR(xfer);
 511                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
 512                 return ret;
 513         }
 514         req.id = id;
 515         req.state = state;
 516
 517         ret = ti_sci_do_xfer(info, xfer);
 518         if (ret) {
 519                 dev_err(info->dev, "Mbox send fail %d\n", ret);
 520                 return ret;
 521         }
 522
 523         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
 524
 525         if (!ti_sci_is_response_ack(resp))
 526                 return -ENODEV;
 527
 528         if (state == MSG_DEVICE_SW_STATE_AUTO_OFF)
 529                 ti_sci_delete_exclusive_dev(info, id);
 530         else if (flags & MSG_FLAG_DEVICE_EXCLUSIVE)
 531                 ti_sci_add_exclusive_dev(info, id);
 532
 533         return ret;
 534 }
 535
 536 /**
 537  * ti_sci_set_device_state_no_wait() - Set device state helper without
 538  *                                     requesting or waiting for a response.
 539  * @handle:     pointer to TI SCI handle
 540  * @id:         Device identifier
 541  * @flags:      flags to setup for the device
 542  * @state:      State to move the device to
 543  *
 544  * Return: 0 if all went well, else returns appropriate error value.
 545  */
 546 static int ti_sci_set_device_state_no_wait(const struct ti_sci_handle *handle,
 547                                            u32 id, u32 flags, u8 state)
 548 {
 549         struct ti_sci_msg_req_set_device_state req;
 550         struct ti_sci_info *info;
 551         struct ti_sci_xfer *xfer;
 552         int ret = 0;
 553
 554         if (IS_ERR(handle))
 555                 return PTR_ERR(handle);
 556         if (!handle)
 557                 return -EINVAL;
 558
 559         info = handle_to_ti_sci_info(handle);
 560
 561         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_SET_DEVICE_STATE,
 562                                      flags | TI_SCI_FLAG_REQ_GENERIC_NORESPONSE,
 563                                      (u32 *)&req, sizeof(req), 0);
 564         if (IS_ERR(xfer)) {
 565                 ret = PTR_ERR(xfer);
 566                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
 567                 return ret;
 568         }
 569         req.id = id;
 570         req.state = state;
 571
 572         ret = ti_sci_do_xfer(info, xfer);
 573         if (ret)
 574                 dev_err(info->dev, "Mbox send fail %d\n", ret);
 575
 576         return ret;
 577 }
 578
 579 /**
 580  * ti_sci_get_device_state() - Get device state helper
 581  * @handle:     Handle to the device
 582  * @id:         Device Identifier
 583  * @clcnt:      Pointer to Context Loss Count
 584  * @resets:     pointer to resets
 585  * @p_state:    pointer to p_state
 586  * @c_state:    pointer to c_state
 587  *
 588  * Return: 0 if all went fine, else return appropriate error.
 589  */
 590 static int ti_sci_get_device_state(const struct ti_sci_handle *handle,
 591                                    u32 id,  u32 *clcnt,  u32 *resets,
 592                                    u8 *p_state,  u8 *c_state)
 593 {
 594         struct ti_sci_msg_resp_get_device_state *resp;
 595         struct ti_sci_msg_req_get_device_state req;
 596         struct ti_sci_info *info;
 597         struct ti_sci_xfer *xfer;
 598         int ret = 0;
 599
 600         if (IS_ERR(handle))
 601                 return PTR_ERR(handle);
 602         if (!handle)
 603                 return -EINVAL;
 604
 605         if (!clcnt && !resets && !p_state && !c_state)
 606                 return -EINVAL;
 607
 608         info = handle_to_ti_sci_info(handle);
 609
 610         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_GET_DEVICE_STATE,
 611                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
 612                                      (u32 *)&req, sizeof(req), sizeof(*resp));
 613         if (IS_ERR(xfer)) {
 614                 ret = PTR_ERR(xfer);
 615                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
 616                 return ret;
 617         }
 618         req.id = id;
 619
 620         ret = ti_sci_do_xfer(info, xfer);
 621         if (ret) {
 622                 dev_err(dev, "Mbox send fail %d\n", ret);
 623                 return ret;
 624         }
 625
 626         resp = (struct ti_sci_msg_resp_get_device_state *)xfer->tx_message.buf;
 627         if (!ti_sci_is_response_ack(resp))
 628                 return -ENODEV;
 629
 630         if (clcnt)
 631                 *clcnt = resp->context_loss_count;
 632         if (resets)
 633                 *resets = resp->resets;
 634         if (p_state)
 635                 *p_state = resp->programmed_state;
 636         if (c_state)
 637                 *c_state = resp->current_state;
 638
 639         return ret;
 640 }
 641
 642 /**
 643  * ti_sci_cmd_get_device() - command to request for device managed by TISCI
 644  * @handle:     Pointer to TISCI handle as retrieved by *ti_sci_get_handle
 645  * @id:         Device Identifier
 646  *
 647  * Request for the device - NOTE: the client MUST maintain integrity of
 648  * usage count by balancing get_device with put_device. No refcounting is
 649  * managed by driver for that purpose.
 650  *
 651  * NOTE: The request is for exclusive access for the processor.
 652  *
 653  * Return: 0 if all went fine, else return appropriate error.
 654  */
 655 static int ti_sci_cmd_get_device(const struct ti_sci_handle *handle, u32 id)
 656 {
 657         return ti_sci_set_device_state(handle, id, 0,
 658                                        MSG_DEVICE_SW_STATE_ON);
 659 }
 660
 661 static int ti_sci_cmd_get_device_exclusive(const struct ti_sci_handle *handle,
 662                                            u32 id)
 663 {
 664         return ti_sci_set_device_state(handle, id, MSG_FLAG_DEVICE_EXCLUSIVE,
 665                                        MSG_DEVICE_SW_STATE_ON);
 666 }
 667
 668 /**
 669  * ti_sci_cmd_idle_device() - Command to idle a device managed by TISCI
 670  * @handle:     Pointer to TISCI handle as retrieved by *ti_sci_get_handle
 671  * @id:         Device Identifier
 672  *
 673  * Request for the device - NOTE: the client MUST maintain integrity of
 674  * usage count by balancing get_device with put_device. No refcounting is
 675  * managed by driver for that purpose.
 676  *
 677  * Return: 0 if all went fine, else return appropriate error.
 678  */
 679 static int ti_sci_cmd_idle_device(const struct ti_sci_handle *handle, u32 id)
 680 {
 681         return ti_sci_set_device_state(handle, id,
 682                                        0,
 683                                        MSG_DEVICE_SW_STATE_RETENTION);
 684 }
 685
 686 static int ti_sci_cmd_idle_device_exclusive(const struct ti_sci_handle *handle,
 687                                             u32 id)
 688 {
 689         return ti_sci_set_device_state(handle, id, MSG_FLAG_DEVICE_EXCLUSIVE,
 690                                        MSG_DEVICE_SW_STATE_RETENTION);
 691 }
 692
 693 /**
 694  * ti_sci_cmd_put_device() - command to release a device managed by TISCI
 695  * @handle:     Pointer to TISCI handle as retrieved by *ti_sci_get_handle
 696  * @id:         Device Identifier
 697  *
 698  * Request for the device - NOTE: the client MUST maintain integrity of
 699  * usage count by balancing get_device with put_device. No refcounting is
 700  * managed by driver for that purpose.
 701  *
 702  * Return: 0 if all went fine, else return appropriate error.
 703  */
 704 static int ti_sci_cmd_put_device(const struct ti_sci_handle *handle, u32 id)
 705 {
 706         return ti_sci_set_device_state(handle, id, 0,
 707                                        MSG_DEVICE_SW_STATE_AUTO_OFF);
 708 }
 709
 710 static
 711 int ti_sci_cmd_release_exclusive_devices(const struct ti_sci_handle *handle)
 712 {
 713         struct ti_sci_exclusive_dev *dev, *tmp;
 714         struct ti_sci_info *info;
 715         int i, cnt;
 716
 717         info = handle_to_ti_sci_info(handle);
 718
 719         list_for_each_entry_safe(dev, tmp, &info->dev_list, list) {
 720                 cnt = dev->count;
 721                 debug("%s: id = %d, cnt = %d\n", __func__, dev->id, cnt);
 722                 for (i = 0; i < cnt; i++)
 723                         ti_sci_cmd_put_device(handle, dev->id);
 724         }
 725
 726         return 0;
 727 }
 728
 729 /**
 730  * ti_sci_cmd_dev_is_valid() - Is the device valid
 731  * @handle:     Pointer to TISCI handle as retrieved by *ti_sci_get_handle
 732  * @id:         Device Identifier
 733  *
 734  * Return: 0 if all went fine and the device ID is valid, else return
 735  * appropriate error.
 736  */
 737 static int ti_sci_cmd_dev_is_valid(const struct ti_sci_handle *handle, u32 id)
 738 {
 739         u8 unused;
 740
 741         /* check the device state which will also tell us if the ID is valid */
 742         return ti_sci_get_device_state(handle, id, NULL, NULL, NULL, &unused);
 743 }
 744
 745 /**
 746  * ti_sci_cmd_dev_get_clcnt() - Get context loss counter
 747  * @handle:     Pointer to TISCI handle
 748  * @id:         Device Identifier
 749  * @count:      Pointer to Context Loss counter to populate
 750  *
 751  * Return: 0 if all went fine, else return appropriate error.
 752  */
 753 static int ti_sci_cmd_dev_get_clcnt(const struct ti_sci_handle *handle, u32 id,
 754                                     u32 *count)
 755 {
 756         return ti_sci_get_device_state(handle, id, count, NULL, NULL, NULL);
 757 }
 758
 759 /**
 760  * ti_sci_cmd_dev_is_idle() - Check if the device is requested to be idle
 761  * @handle:     Pointer to TISCI handle
 762  * @id:         Device Identifier
 763  * @r_state:    true if requested to be idle
 764  *
 765  * Return: 0 if all went fine, else return appropriate error.
 766  */
 767 static int ti_sci_cmd_dev_is_idle(const struct ti_sci_handle *handle, u32 id,
 768                                   bool *r_state)
 769 {
 770         int ret;
 771         u8 state;
 772
 773         if (!r_state)
 774                 return -EINVAL;
 775
 776         ret = ti_sci_get_device_state(handle, id, NULL, NULL, &state, NULL);
 777         if (ret)
 778                 return ret;
 779
 780         *r_state = (state == MSG_DEVICE_SW_STATE_RETENTION);
 781
 782         return 0;
 783 }
 784
 785 /**
 786  * ti_sci_cmd_dev_is_stop() - Check if the device is requested to be stopped
 787  * @handle:     Pointer to TISCI handle
 788  * @id:         Device Identifier
 789  * @r_state:    true if requested to be stopped
 790  * @curr_state: true if currently stopped.
 791  *
 792  * Return: 0 if all went fine, else return appropriate error.
 793  */
 794 static int ti_sci_cmd_dev_is_stop(const struct ti_sci_handle *handle, u32 id,
 795                                   bool *r_state,  bool *curr_state)
 796 {
 797         int ret;
 798         u8 p_state, c_state;
 799
 800         if (!r_state && !curr_state)
 801                 return -EINVAL;
 802
 803         ret =
 804             ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);
 805         if (ret)
 806                 return ret;
 807
 808         if (r_state)
 809                 *r_state = (p_state == MSG_DEVICE_SW_STATE_AUTO_OFF);
 810         if (curr_state)
 811                 *curr_state = (c_state == MSG_DEVICE_HW_STATE_OFF);
 812
 813         return 0;
 814 }
 815
 816 /**
 817  * ti_sci_cmd_dev_is_on() - Check if the device is requested to be ON
 818  * @handle:     Pointer to TISCI handle
 819  * @id:         Device Identifier
 820  * @r_state:    true if requested to be ON
 821  * @curr_state: true if currently ON and active
 822  *
 823  * Return: 0 if all went fine, else return appropriate error.
 824  */
 825 static int ti_sci_cmd_dev_is_on(const struct ti_sci_handle *handle, u32 id,
 826                                 bool *r_state,  bool *curr_state)
 827 {
 828         int ret;
 829         u8 p_state, c_state;
 830
 831         if (!r_state && !curr_state)
 832                 return -EINVAL;
 833
 834         ret =
 835             ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);
 836         if (ret)
 837                 return ret;
 838
 839         if (r_state)
 840                 *r_state = (p_state == MSG_DEVICE_SW_STATE_ON);
 841         if (curr_state)
 842                 *curr_state = (c_state == MSG_DEVICE_HW_STATE_ON);
 843
 844         return 0;
 845 }
 846
 847 /**
 848  * ti_sci_cmd_dev_is_trans() - Check if the device is currently transitioning
 849  * @handle:     Pointer to TISCI handle
 850  * @id:         Device Identifier
 851  * @curr_state: true if currently transitioning.
 852  *
 853  * Return: 0 if all went fine, else return appropriate error.
 854  */
 855 static int ti_sci_cmd_dev_is_trans(const struct ti_sci_handle *handle, u32 id,
 856                                    bool *curr_state)
 857 {
 858         int ret;
 859         u8 state;
 860
 861         if (!curr_state)
 862                 return -EINVAL;
 863
 864         ret = ti_sci_get_device_state(handle, id, NULL, NULL, NULL, &state);
 865         if (ret)
 866                 return ret;
 867
 868         *curr_state = (state == MSG_DEVICE_HW_STATE_TRANS);
 869
 870         return 0;
 871 }
 872
 873 /**
 874  * ti_sci_cmd_set_device_resets() - command to set resets for device managed
 875  *                                  by TISCI
 876  * @handle:     Pointer to TISCI handle as retrieved by *ti_sci_get_handle
 877  * @id:         Device Identifier
 878  * @reset_state: Device specific reset bit field
 879  *
 880  * Return: 0 if all went fine, else return appropriate error.
 881  */
 882 static int ti_sci_cmd_set_device_resets(const struct ti_sci_handle *handle,
 883                                         u32 id, u32 reset_state)
 884 {
 885         struct ti_sci_msg_req_set_device_resets req;
 886         struct ti_sci_msg_hdr *resp;
 887         struct ti_sci_info *info;
 888         struct ti_sci_xfer *xfer;
 889         int ret = 0;
 890
 891         if (IS_ERR(handle))
 892                 return PTR_ERR(handle);
 893         if (!handle)
 894                 return -EINVAL;
 895
 896         info = handle_to_ti_sci_info(handle);
 897
 898         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_SET_DEVICE_RESETS,
 899                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
 900                                      (u32 *)&req, sizeof(req), sizeof(*resp));
 901         if (IS_ERR(xfer)) {
 902                 ret = PTR_ERR(xfer);
 903                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
 904                 return ret;
 905         }
 906         req.id = id;
 907         req.resets = reset_state;
 908
 909         ret = ti_sci_do_xfer(info, xfer);
 910         if (ret) {
 911                 dev_err(info->dev, "Mbox send fail %d\n", ret);
 912                 return ret;
 913         }
 914
 915         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
 916
 917         if (!ti_sci_is_response_ack(resp))
 918                 return -ENODEV;
 919
 920         return ret;
 921 }
 922
 923 /**
 924  * ti_sci_cmd_get_device_resets() - Get reset state for device managed
 925  *                                  by TISCI
 926  * @handle:             Pointer to TISCI handle
 927  * @id:                 Device Identifier
 928  * @reset_state:        Pointer to reset state to populate
 929  *
 930  * Return: 0 if all went fine, else return appropriate error.
 931  */
 932 static int ti_sci_cmd_get_device_resets(const struct ti_sci_handle *handle,
 933                                         u32 id, u32 *reset_state)
 934 {
 935         return ti_sci_get_device_state(handle, id, NULL, reset_state, NULL,
 936                                        NULL);
 937 }
 938
 939 /**
 940  * ti_sci_set_clock_state() - Set clock state helper
 941  * @handle:     pointer to TI SCI handle
 942  * @dev_id:     Device identifier this request is for
 943  * @clk_id:     Clock identifier for the device for this request.
 944  *              Each device has it's own set of clock inputs. This indexes
 945  *              which clock input to modify.
 946  * @flags:      Header flags as needed
 947  * @state:      State to request for the clock.
 948  *
 949  * Return: 0 if all went well, else returns appropriate error value.
 950  */
 951 static int ti_sci_set_clock_state(const struct ti_sci_handle *handle,
 952                                   u32 dev_id, u8 clk_id,
 953                                   u32 flags, u8 state)
 954 {
 955         struct ti_sci_msg_req_set_clock_state req;
 956         struct ti_sci_msg_hdr *resp;
 957         struct ti_sci_info *info;
 958         struct ti_sci_xfer *xfer;
 959         int ret = 0;
 960
 961         if (IS_ERR(handle))
 962                 return PTR_ERR(handle);
 963         if (!handle)
 964                 return -EINVAL;
 965
 966         info = handle_to_ti_sci_info(handle);
 967
 968         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_SET_CLOCK_STATE,
 969                                      flags | TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
 970                                      (u32 *)&req, sizeof(req), sizeof(*resp));
 971         if (IS_ERR(xfer)) {
 972                 ret = PTR_ERR(xfer);
 973                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
 974                 return ret;
 975         }
 976         req.dev_id = dev_id;
 977         req.clk_id = clk_id;
 978         req.request_state = state;
 979
 980         ret = ti_sci_do_xfer(info, xfer);
 981         if (ret) {
 982                 dev_err(info->dev, "Mbox send fail %d\n", ret);
 983                 return ret;
 984         }
 985
 986         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
 987
 988         if (!ti_sci_is_response_ack(resp))
 989                 return -ENODEV;
 990
 991         return ret;
 992 }
 993
 994 /**
 995  * ti_sci_cmd_get_clock_state() - Get clock state helper
 996  * @handle:     pointer to TI SCI handle
 997  * @dev_id:     Device identifier this request is for
 998  * @clk_id:     Clock identifier for the device for this request.
 999  *              Each device has it's own set of clock inputs. This indexes
1000  *              which clock input to modify.
1001  * @programmed_state:   State requested for clock to move to
1002  * @current_state:      State that the clock is currently in
1003  *
1004  * Return: 0 if all went well, else returns appropriate error value.
1005  */
1006 static int ti_sci_cmd_get_clock_state(const struct ti_sci_handle *handle,
1007                                       u32 dev_id, u8 clk_id,
1008                                       u8 *programmed_state, u8 *current_state)
1009 {
1010         struct ti_sci_msg_resp_get_clock_state *resp;
1011         struct ti_sci_msg_req_get_clock_state req;
1012         struct ti_sci_info *info;
1013         struct ti_sci_xfer *xfer;
1014         int ret = 0;
1015
1016         if (IS_ERR(handle))
1017                 return PTR_ERR(handle);
1018         if (!handle)
1019                 return -EINVAL;
1020
1021         if (!programmed_state && !current_state)
1022                 return -EINVAL;
1023
1024         info = handle_to_ti_sci_info(handle);
1025
1026         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_GET_CLOCK_STATE,
1027                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1028                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1029         if (IS_ERR(xfer)) {
1030                 ret = PTR_ERR(xfer);
1031                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1032                 return ret;
1033         }
1034         req.dev_id = dev_id;
1035         req.clk_id = clk_id;
1036
1037         ret = ti_sci_do_xfer(info, xfer);
1038         if (ret) {
1039                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1040                 return ret;
1041         }
1042
1043         resp = (struct ti_sci_msg_resp_get_clock_state *)xfer->tx_message.buf;
1044
1045         if (!ti_sci_is_response_ack(resp))
1046                 return -ENODEV;
1047
1048         if (programmed_state)
1049                 *programmed_state = resp->programmed_state;
1050         if (current_state)
1051                 *current_state = resp->current_state;
1052
1053         return ret;
1054 }
1055
1056 /**
1057  * ti_sci_cmd_get_clock() - Get control of a clock from TI SCI
1058  * @handle:     pointer to TI SCI handle
1059  * @dev_id:     Device identifier this request is for
1060  * @clk_id:     Clock identifier for the device for this request.
1061  *              Each device has it's own set of clock inputs. This indexes
1062  *              which clock input to modify.
1063  * @needs_ssc: 'true' if Spread Spectrum clock is desired, else 'false'
1064  * @can_change_freq: 'true' if frequency change is desired, else 'false'
1065  * @enable_input_term: 'true' if input termination is desired, else 'false'
1066  *
1067  * Return: 0 if all went well, else returns appropriate error value.
1068  */
1069 static int ti_sci_cmd_get_clock(const struct ti_sci_handle *handle, u32 dev_id,
1070                                 u8 clk_id, bool needs_ssc, bool can_change_freq,
1071                                 bool enable_input_term)
1072 {
1073         u32 flags = 0;
1074
1075         flags |= needs_ssc ? MSG_FLAG_CLOCK_ALLOW_SSC : 0;
1076         flags |= can_change_freq ? MSG_FLAG_CLOCK_ALLOW_FREQ_CHANGE : 0;
1077         flags |= enable_input_term ? MSG_FLAG_CLOCK_INPUT_TERM : 0;
1078
1079         return ti_sci_set_clock_state(handle, dev_id, clk_id, flags,
1080                                       MSG_CLOCK_SW_STATE_REQ);
1081 }
1082
1083 /**
1084  * ti_sci_cmd_idle_clock() - Idle a clock which is in our control
1085  * @handle:     pointer to TI SCI handle
1086  * @dev_id:     Device identifier this request is for
1087  * @clk_id:     Clock identifier for the device for this request.
1088  *              Each device has it's own set of clock inputs. This indexes
1089  *              which clock input to modify.
1090  *
1091  * NOTE: This clock must have been requested by get_clock previously.
1092  *
1093  * Return: 0 if all went well, else returns appropriate error value.
1094  */
1095 static int ti_sci_cmd_idle_clock(const struct ti_sci_handle *handle,
1096                                  u32 dev_id, u8 clk_id)
1097 {
1098         return ti_sci_set_clock_state(handle, dev_id, clk_id, 0,
1099                                       MSG_CLOCK_SW_STATE_UNREQ);
1100 }
1101
1102 /**
1103  * ti_sci_cmd_put_clock() - Release a clock from our control back to TISCI
1104  * @handle:     pointer to TI SCI handle
1105  * @dev_id:     Device identifier this request is for
1106  * @clk_id:     Clock identifier for the device for this request.
1107  *              Each device has it's own set of clock inputs. This indexes
1108  *              which clock input to modify.
1109  *
1110  * NOTE: This clock must have been requested by get_clock previously.
1111  *
1112  * Return: 0 if all went well, else returns appropriate error value.
1113  */
1114 static int ti_sci_cmd_put_clock(const struct ti_sci_handle *handle,
1115                                 u32 dev_id, u8 clk_id)
1116 {
1117         return ti_sci_set_clock_state(handle, dev_id, clk_id, 0,
1118                                       MSG_CLOCK_SW_STATE_AUTO);
1119 }
1120
1121 /**
1122  * ti_sci_cmd_clk_is_auto() - Is the clock being auto managed
1123  * @handle:     pointer to TI SCI handle
1124  * @dev_id:     Device identifier this request is for
1125  * @clk_id:     Clock identifier for the device for this request.
1126  *              Each device has it's own set of clock inputs. This indexes
1127  *              which clock input to modify.
1128  * @req_state: state indicating if the clock is auto managed
1129  *
1130  * Return: 0 if all went well, else returns appropriate error value.
1131  */
1132 static int ti_sci_cmd_clk_is_auto(const struct ti_sci_handle *handle,
1133                                   u32 dev_id, u8 clk_id, bool *req_state)
1134 {
1135         u8 state = 0;
1136         int ret;
1137
1138         if (!req_state)
1139                 return -EINVAL;
1140
1141         ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id, &state, NULL);
1142         if (ret)
1143                 return ret;
1144
1145         *req_state = (state == MSG_CLOCK_SW_STATE_AUTO);
1146         return 0;
1147 }
1148
1149 /**
1150  * ti_sci_cmd_clk_is_on() - Is the clock ON
1151  * @handle:     pointer to TI SCI handle
1152  * @dev_id:     Device identifier this request is for
1153  * @clk_id:     Clock identifier for the device for this request.
1154  *              Each device has it's own set of clock inputs. This indexes
1155  *              which clock input to modify.
1156  * @req_state: state indicating if the clock is managed by us and enabled
1157  * @curr_state: state indicating if the clock is ready for operation
1158  *
1159  * Return: 0 if all went well, else returns appropriate error value.
1160  */
1161 static int ti_sci_cmd_clk_is_on(const struct ti_sci_handle *handle, u32 dev_id,
1162                                 u8 clk_id, bool *req_state, bool *curr_state)
1163 {
1164         u8 c_state = 0, r_state = 0;
1165         int ret;
1166
1167         if (!req_state && !curr_state)
1168                 return -EINVAL;
1169
1170         ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,
1171                                          &r_state, &c_state);
1172         if (ret)
1173                 return ret;
1174
1175         if (req_state)
1176                 *req_state = (r_state == MSG_CLOCK_SW_STATE_REQ);
1177         if (curr_state)
1178                 *curr_state = (c_state == MSG_CLOCK_HW_STATE_READY);
1179         return 0;
1180 }
1181
1182 /**
1183  * ti_sci_cmd_clk_is_off() - Is the clock OFF
1184  * @handle:     pointer to TI SCI handle
1185  * @dev_id:     Device identifier this request is for
1186  * @clk_id:     Clock identifier for the device for this request.
1187  *              Each device has it's own set of clock inputs. This indexes
1188  *              which clock input to modify.
1189  * @req_state: state indicating if the clock is managed by us and disabled
1190  * @curr_state: state indicating if the clock is NOT ready for operation
1191  *
1192  * Return: 0 if all went well, else returns appropriate error value.
1193  */
1194 static int ti_sci_cmd_clk_is_off(const struct ti_sci_handle *handle, u32 dev_id,
1195                                  u8 clk_id, bool *req_state, bool *curr_state)
1196 {
1197         u8 c_state = 0, r_state = 0;
1198         int ret;
1199
1200         if (!req_state && !curr_state)
1201                 return -EINVAL;
1202
1203         ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,
1204                                          &r_state, &c_state);
1205         if (ret)
1206                 return ret;
1207
1208         if (req_state)
1209                 *req_state = (r_state == MSG_CLOCK_SW_STATE_UNREQ);
1210         if (curr_state)
1211                 *curr_state = (c_state == MSG_CLOCK_HW_STATE_NOT_READY);
1212         return 0;
1213 }
1214
1215 /**
1216  * ti_sci_cmd_clk_set_parent() - Set the clock source of a specific device clock
1217  * @handle:     pointer to TI SCI handle
1218  * @dev_id:     Device identifier this request is for
1219  * @clk_id:     Clock identifier for the device for this request.
1220  *              Each device has it's own set of clock inputs. This indexes
1221  *              which clock input to modify.
1222  * @parent_id:  Parent clock identifier to set
1223  *
1224  * Return: 0 if all went well, else returns appropriate error value.
1225  */
1226 static int ti_sci_cmd_clk_set_parent(const struct ti_sci_handle *handle,
1227                                      u32 dev_id, u8 clk_id, u8 parent_id)
1228 {
1229         struct ti_sci_msg_req_set_clock_parent req;
1230         struct ti_sci_msg_hdr *resp;
1231         struct ti_sci_info *info;
1232         struct ti_sci_xfer *xfer;
1233         int ret = 0;
1234
1235         if (IS_ERR(handle))
1236                 return PTR_ERR(handle);
1237         if (!handle)
1238                 return -EINVAL;
1239
1240         info = handle_to_ti_sci_info(handle);
1241
1242         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_SET_CLOCK_PARENT,
1243                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1244                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1245         if (IS_ERR(xfer)) {
1246                 ret = PTR_ERR(xfer);
1247                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1248                 return ret;
1249         }
1250         req.dev_id = dev_id;
1251         req.clk_id = clk_id;
1252         req.parent_id = parent_id;
1253
1254         ret = ti_sci_do_xfer(info, xfer);
1255         if (ret) {
1256                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1257                 return ret;
1258         }
1259
1260         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1261
1262         if (!ti_sci_is_response_ack(resp))
1263                 return -ENODEV;
1264
1265         return ret;
1266 }
1267
1268 /**
1269  * ti_sci_cmd_clk_get_parent() - Get current parent clock source
1270  * @handle:     pointer to TI SCI handle
1271  * @dev_id:     Device identifier this request is for
1272  * @clk_id:     Clock identifier for the device for this request.
1273  *              Each device has it's own set of clock inputs. This indexes
1274  *              which clock input to modify.
1275  * @parent_id:  Current clock parent
1276  *
1277  * Return: 0 if all went well, else returns appropriate error value.
1278  */
1279 static int ti_sci_cmd_clk_get_parent(const struct ti_sci_handle *handle,
1280                                      u32 dev_id, u8 clk_id, u8 *parent_id)
1281 {
1282         struct ti_sci_msg_resp_get_clock_parent *resp;
1283         struct ti_sci_msg_req_get_clock_parent req;
1284         struct ti_sci_info *info;
1285         struct ti_sci_xfer *xfer;
1286         int ret = 0;
1287
1288         if (IS_ERR(handle))
1289                 return PTR_ERR(handle);
1290         if (!handle || !parent_id)
1291                 return -EINVAL;
1292
1293         info = handle_to_ti_sci_info(handle);
1294
1295         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_GET_CLOCK_PARENT,
1296                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1297                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1298         if (IS_ERR(xfer)) {
1299                 ret = PTR_ERR(xfer);
1300                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1301                 return ret;
1302         }
1303         req.dev_id = dev_id;
1304         req.clk_id = clk_id;
1305
1306         ret = ti_sci_do_xfer(info, xfer);
1307         if (ret) {
1308                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1309                 return ret;
1310         }
1311
1312         resp = (struct ti_sci_msg_resp_get_clock_parent *)xfer->tx_message.buf;
1313
1314         if (!ti_sci_is_response_ack(resp))
1315                 ret = -ENODEV;
1316         else
1317                 *parent_id = resp->parent_id;
1318
1319         return ret;
1320 }
1321
1322 /**
1323  * ti_sci_cmd_clk_get_num_parents() - Get num parents of the current clk source
1324  * @handle:     pointer to TI SCI handle
1325  * @dev_id:     Device identifier this request is for
1326  * @clk_id:     Clock identifier for the device for this request.
1327  *              Each device has it's own set of clock inputs. This indexes
1328  *              which clock input to modify.
1329  * @num_parents: Returns he number of parents to the current clock.
1330  *
1331  * Return: 0 if all went well, else returns appropriate error value.
1332  */
1333 static int ti_sci_cmd_clk_get_num_parents(const struct ti_sci_handle *handle,
1334                                           u32 dev_id, u8 clk_id,
1335                                           u8 *num_parents)
1336 {
1337         struct ti_sci_msg_resp_get_clock_num_parents *resp;
1338         struct ti_sci_msg_req_get_clock_num_parents req;
1339         struct ti_sci_info *info;
1340         struct ti_sci_xfer *xfer;
1341         int ret = 0;
1342
1343         if (IS_ERR(handle))
1344                 return PTR_ERR(handle);
1345         if (!handle || !num_parents)
1346                 return -EINVAL;
1347
1348         info = handle_to_ti_sci_info(handle);
1349
1350         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_GET_NUM_CLOCK_PARENTS,
1351                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1352                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1353         if (IS_ERR(xfer)) {
1354                 ret = PTR_ERR(xfer);
1355                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1356                 return ret;
1357         }
1358         req.dev_id = dev_id;
1359         req.clk_id = clk_id;
1360
1361         ret = ti_sci_do_xfer(info, xfer);
1362         if (ret) {
1363                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1364                 return ret;
1365         }
1366
1367         resp = (struct ti_sci_msg_resp_get_clock_num_parents *)
1368                                                         xfer->tx_message.buf;
1369
1370         if (!ti_sci_is_response_ack(resp))
1371                 ret = -ENODEV;
1372         else
1373                 *num_parents = resp->num_parents;
1374
1375         return ret;
1376 }
1377
1378 /**
1379  * ti_sci_cmd_clk_get_match_freq() - Find a good match for frequency
1380  * @handle:     pointer to TI SCI handle
1381  * @dev_id:     Device identifier this request is for
1382  * @clk_id:     Clock identifier for the device for this request.
1383  *              Each device has it's own set of clock inputs. This indexes
1384  *              which clock input to modify.
1385  * @min_freq:   The minimum allowable frequency in Hz. This is the minimum
1386  *              allowable programmed frequency and does not account for clock
1387  *              tolerances and jitter.
1388  * @target_freq: The target clock frequency in Hz. A frequency will be
1389  *              processed as close to this target frequency as possible.
1390  * @max_freq:   The maximum allowable frequency in Hz. This is the maximum
1391  *              allowable programmed frequency and does not account for clock
1392  *              tolerances and jitter.
1393  * @match_freq: Frequency match in Hz response.
1394  *
1395  * Return: 0 if all went well, else returns appropriate error value.
1396  */
1397 static int ti_sci_cmd_clk_get_match_freq(const struct ti_sci_handle *handle,
1398                                          u32 dev_id, u8 clk_id, u64 min_freq,
1399                                          u64 target_freq, u64 max_freq,
1400                                          u64 *match_freq)
1401 {
1402         struct ti_sci_msg_resp_query_clock_freq *resp;
1403         struct ti_sci_msg_req_query_clock_freq req;
1404         struct ti_sci_info *info;
1405         struct ti_sci_xfer *xfer;
1406         int ret = 0;
1407
1408         if (IS_ERR(handle))
1409                 return PTR_ERR(handle);
1410         if (!handle || !match_freq)
1411                 return -EINVAL;
1412
1413         info = handle_to_ti_sci_info(handle);
1414
1415         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_QUERY_CLOCK_FREQ,
1416                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1417                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1418         if (IS_ERR(xfer)) {
1419                 ret = PTR_ERR(xfer);
1420                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1421                 return ret;
1422         }
1423         req.dev_id = dev_id;
1424         req.clk_id = clk_id;
1425         req.min_freq_hz = min_freq;
1426         req.target_freq_hz = target_freq;
1427         req.max_freq_hz = max_freq;
1428
1429         ret = ti_sci_do_xfer(info, xfer);
1430         if (ret) {
1431                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1432                 return ret;
1433         }
1434
1435         resp = (struct ti_sci_msg_resp_query_clock_freq *)xfer->tx_message.buf;
1436
1437         if (!ti_sci_is_response_ack(resp))
1438                 ret = -ENODEV;
1439         else
1440                 *match_freq = resp->freq_hz;
1441
1442         return ret;
1443 }
1444
1445 /**
1446  * ti_sci_cmd_clk_set_freq() - Set a frequency for clock
1447  * @handle:     pointer to TI SCI handle
1448  * @dev_id:     Device identifier this request is for
1449  * @clk_id:     Clock identifier for the device for this request.
1450  *              Each device has it's own set of clock inputs. This indexes
1451  *              which clock input to modify.
1452  * @min_freq:   The minimum allowable frequency in Hz. This is the minimum
1453  *              allowable programmed frequency and does not account for clock
1454  *              tolerances and jitter.
1455  * @target_freq: The target clock frequency in Hz. A frequency will be
1456  *              processed as close to this target frequency as possible.
1457  * @max_freq:   The maximum allowable frequency in Hz. This is the maximum
1458  *              allowable programmed frequency and does not account for clock
1459  *              tolerances and jitter.
1460  *
1461  * Return: 0 if all went well, else returns appropriate error value.
1462  */
1463 static int ti_sci_cmd_clk_set_freq(const struct ti_sci_handle *handle,
1464                                    u32 dev_id, u8 clk_id, u64 min_freq,
1465                                    u64 target_freq, u64 max_freq)
1466 {
1467         struct ti_sci_msg_req_set_clock_freq req;
1468         struct ti_sci_msg_hdr *resp;
1469         struct ti_sci_info *info;
1470         struct ti_sci_xfer *xfer;
1471         int ret = 0;
1472
1473         if (IS_ERR(handle))
1474                 return PTR_ERR(handle);
1475         if (!handle)
1476                 return -EINVAL;
1477
1478         info = handle_to_ti_sci_info(handle);
1479
1480         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_SET_CLOCK_FREQ,
1481                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1482                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1483         if (IS_ERR(xfer)) {
1484                 ret = PTR_ERR(xfer);
1485                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1486                 return ret;
1487         }
1488         req.dev_id = dev_id;
1489         req.clk_id = clk_id;
1490         req.min_freq_hz = min_freq;
1491         req.target_freq_hz = target_freq;
1492         req.max_freq_hz = max_freq;
1493
1494         ret = ti_sci_do_xfer(info, xfer);
1495         if (ret) {
1496                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1497                 return ret;
1498         }
1499
1500         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1501
1502         if (!ti_sci_is_response_ack(resp))
1503                 return -ENODEV;
1504
1505         return ret;
1506 }
1507
1508 /**
1509  * ti_sci_cmd_clk_get_freq() - Get current frequency
1510  * @handle:     pointer to TI SCI handle
1511  * @dev_id:     Device identifier this request is for
1512  * @clk_id:     Clock identifier for the device for this request.
1513  *              Each device has it's own set of clock inputs. This indexes
1514  *              which clock input to modify.
1515  * @freq:       Currently frequency in Hz
1516  *
1517  * Return: 0 if all went well, else returns appropriate error value.
1518  */
1519 static int ti_sci_cmd_clk_get_freq(const struct ti_sci_handle *handle,
1520                                    u32 dev_id, u8 clk_id, u64 *freq)
1521 {
1522         struct ti_sci_msg_resp_get_clock_freq *resp;
1523         struct ti_sci_msg_req_get_clock_freq req;
1524         struct ti_sci_info *info;
1525         struct ti_sci_xfer *xfer;
1526         int ret = 0;
1527
1528         if (IS_ERR(handle))
1529                 return PTR_ERR(handle);
1530         if (!handle || !freq)
1531                 return -EINVAL;
1532
1533         info = handle_to_ti_sci_info(handle);
1534
1535         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_GET_CLOCK_FREQ,
1536                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1537                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1538         if (IS_ERR(xfer)) {
1539                 ret = PTR_ERR(xfer);
1540                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1541                 return ret;
1542         }
1543         req.dev_id = dev_id;
1544         req.clk_id = clk_id;
1545
1546         ret = ti_sci_do_xfer(info, xfer);
1547         if (ret) {
1548                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1549                 return ret;
1550         }
1551
1552         resp = (struct ti_sci_msg_resp_get_clock_freq *)xfer->tx_message.buf;
1553
1554         if (!ti_sci_is_response_ack(resp))
1555                 ret = -ENODEV;
1556         else
1557                 *freq = resp->freq_hz;
1558
1559         return ret;
1560 }
1561
1562 /**
1563  * ti_sci_cmd_core_reboot() - Command to request system reset
1564  * @handle:     pointer to TI SCI handle
1565  *
1566  * Return: 0 if all went well, else returns appropriate error value.
1567  */
1568 static int ti_sci_cmd_core_reboot(const struct ti_sci_handle *handle)
1569 {
1570         struct ti_sci_msg_req_reboot req;
1571         struct ti_sci_msg_hdr *resp;
1572         struct ti_sci_info *info;
1573         struct ti_sci_xfer *xfer;
1574         int ret = 0;
1575
1576         if (IS_ERR(handle))
1577                 return PTR_ERR(handle);
1578         if (!handle)
1579                 return -EINVAL;
1580
1581         info = handle_to_ti_sci_info(handle);
1582
1583         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_SYS_RESET,
1584                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1585                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1586         if (IS_ERR(xfer)) {
1587                 ret = PTR_ERR(xfer);
1588                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1589                 return ret;
1590         }
1591
1592         ret = ti_sci_do_xfer(info, xfer);
1593         if (ret) {
1594                 dev_err(dev, "Mbox send fail %d\n", ret);
1595                 return ret;
1596         }
1597
1598         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1599
1600         if (!ti_sci_is_response_ack(resp))
1601                 return -ENODEV;
1602
1603         return ret;
1604 }
1605
1606 static int ti_sci_get_resource_type(struct ti_sci_info *info, u16 dev_id,
1607                                     u16 *type)
1608 {
1609         struct ti_sci_rm_type_map *rm_type_map = info->desc->rm_type_map;
1610         bool found = false;
1611         int i;
1612
1613         /* If map is not provided then assume dev_id is used as type */
1614         if (!rm_type_map) {
1615                 *type = dev_id;
1616                 return 0;
1617         }
1618
1619         for (i = 0; rm_type_map[i].dev_id; i++) {
1620                 if (rm_type_map[i].dev_id == dev_id) {
1621                         *type = rm_type_map[i].type;
1622                         found = true;
1623                         break;
1624                 }
1625         }
1626
1627         if (!found)
1628                 return -EINVAL;
1629
1630         return 0;
1631 }
1632
1633 /**
1634  * ti_sci_get_resource_range - Helper to get a range of resources assigned
1635  *                             to a host. Resource is uniquely identified by
1636  *                             type and subtype.
1637  * @handle:             Pointer to TISCI handle.
1638  * @dev_id:             TISCI device ID.
1639  * @subtype:            Resource assignment subtype that is being requested
1640  *                      from the given device.
1641  * @s_host:             Host processor ID to which the resources are allocated
1642  * @range_start:        Start index of the resource range
1643  * @range_num:          Number of resources in the range
1644  *
1645  * Return: 0 if all went fine, else return appropriate error.
1646  */
1647 static int ti_sci_get_resource_range(const struct ti_sci_handle *handle,
1648                                      u32 dev_id, u8 subtype, u8 s_host,
1649                                      u16 *range_start, u16 *range_num)
1650 {
1651         struct ti_sci_msg_resp_get_resource_range *resp;
1652         struct ti_sci_msg_req_get_resource_range req;
1653         struct ti_sci_xfer *xfer;
1654         struct ti_sci_info *info;
1655         u16 type;
1656         int ret = 0;
1657
1658         if (IS_ERR(handle))
1659                 return PTR_ERR(handle);
1660         if (!handle)
1661                 return -EINVAL;
1662
1663         info = handle_to_ti_sci_info(handle);
1664
1665         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_GET_RESOURCE_RANGE,
1666                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1667                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1668         if (IS_ERR(xfer)) {
1669                 ret = PTR_ERR(xfer);
1670                 dev_err(dev, "Message alloc failed(%d)\n", ret);
1671                 return ret;
1672         }
1673
1674         ret = ti_sci_get_resource_type(info, dev_id, &type);
1675         if (ret) {
1676                 dev_err(dev, "rm type lookup failed for %u\n", dev_id);
1677                 goto fail;
1678         }
1679
1680         req.secondary_host = s_host;
1681         req.type = type & MSG_RM_RESOURCE_TYPE_MASK;
1682         req.subtype = subtype & MSG_RM_RESOURCE_SUBTYPE_MASK;
1683
1684         ret = ti_sci_do_xfer(info, xfer);
1685         if (ret) {
1686                 dev_err(dev, "Mbox send fail %d\n", ret);
1687                 goto fail;
1688         }
1689
1690         resp = (struct ti_sci_msg_resp_get_resource_range *)xfer->tx_message.buf;
1691         if (!ti_sci_is_response_ack(resp)) {
1692                 ret = -ENODEV;
1693         } else if (!resp->range_start && !resp->range_num) {
1694                 ret = -ENODEV;
1695         } else {
1696                 *range_start = resp->range_start;
1697                 *range_num = resp->range_num;
1698         };
1699
1700 fail:
1701         return ret;
1702 }
1703
1704 /**
1705  * ti_sci_cmd_get_resource_range - Get a range of resources assigned to host
1706  *                                 that is same as ti sci interface host.
1707  * @handle:             Pointer to TISCI handle.
1708  * @dev_id:             TISCI device ID.
1709  * @subtype:            Resource assignment subtype that is being requested
1710  *                      from the given device.
1711  * @range_start:        Start index of the resource range
1712  * @range_num:          Number of resources in the range
1713  *
1714  * Return: 0 if all went fine, else return appropriate error.
1715  */
1716 static int ti_sci_cmd_get_resource_range(const struct ti_sci_handle *handle,
1717                                          u32 dev_id, u8 subtype,
1718                                          u16 *range_start, u16 *range_num)
1719 {
1720         return ti_sci_get_resource_range(handle, dev_id, subtype,
1721                                          TI_SCI_IRQ_SECONDARY_HOST_INVALID,
1722                                          range_start, range_num);
1723 }
1724
1725 /**
1726  * ti_sci_cmd_get_resource_range_from_shost - Get a range of resources
1727  *                                            assigned to a specified host.
1728  * @handle:             Pointer to TISCI handle.
1729  * @dev_id:             TISCI device ID.
1730  * @subtype:            Resource assignment subtype that is being requested
1731  *                      from the given device.
1732  * @s_host:             Host processor ID to which the resources are allocated
1733  * @range_start:        Start index of the resource range
1734  * @range_num:          Number of resources in the range
1735  *
1736  * Return: 0 if all went fine, else return appropriate error.
1737  */
1738 static
1739 int ti_sci_cmd_get_resource_range_from_shost(const struct ti_sci_handle *handle,
1740                                              u32 dev_id, u8 subtype, u8 s_host,
1741                                              u16 *range_start, u16 *range_num)
1742 {
1743         return ti_sci_get_resource_range(handle, dev_id, subtype, s_host,
1744                                          range_start, range_num);
1745 }
1746
1747 /**
1748  * ti_sci_cmd_query_msmc() - Command to query currently available msmc memory
1749  * @handle:             pointer to TI SCI handle
1750  * @msms_start:         MSMC start as returned by tisci
1751  * @msmc_end:           MSMC end as returned by tisci
1752  *
1753  * Return: 0 if all went well, else returns appropriate error value.
1754  */
1755 static int ti_sci_cmd_query_msmc(const struct ti_sci_handle *handle,
1756                                  u64 *msmc_start, u64 *msmc_end)
1757 {
1758         struct ti_sci_msg_resp_query_msmc *resp;
1759         struct ti_sci_msg_hdr req;
1760         struct ti_sci_info *info;
1761         struct ti_sci_xfer *xfer;
1762         int ret = 0;
1763
1764         if (IS_ERR(handle))
1765                 return PTR_ERR(handle);
1766         if (!handle)
1767                 return -EINVAL;
1768
1769         info = handle_to_ti_sci_info(handle);
1770
1771         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_QUERY_MSMC,
1772                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1773                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1774         if (IS_ERR(xfer)) {
1775                 ret = PTR_ERR(xfer);
1776                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1777                 return ret;
1778         }
1779
1780         ret = ti_sci_do_xfer(info, xfer);
1781         if (ret) {
1782                 dev_err(dev, "Mbox send fail %d\n", ret);
1783                 return ret;
1784         }
1785
1786         resp = (struct ti_sci_msg_resp_query_msmc *)xfer->tx_message.buf;
1787
1788         if (!ti_sci_is_response_ack(resp))
1789                 return -ENODEV;
1790
1791         *msmc_start = ((u64)resp->msmc_start_high << TISCI_ADDR_HIGH_SHIFT) |
1792                         resp->msmc_start_low;
1793         *msmc_end = ((u64)resp->msmc_end_high << TISCI_ADDR_HIGH_SHIFT) |
1794                         resp->msmc_end_low;
1795
1796         return ret;
1797 }
1798
1799 /**
1800  * ti_sci_cmd_proc_request() - Command to request a physical processor control
1801  * @handle:     Pointer to TI SCI handle
1802  * @proc_id:    Processor ID this request is for
1803  *
1804  * Return: 0 if all went well, else returns appropriate error value.
1805  */
1806 static int ti_sci_cmd_proc_request(const struct ti_sci_handle *handle,
1807                                    u8 proc_id)
1808 {
1809         struct ti_sci_msg_req_proc_request req;
1810         struct ti_sci_msg_hdr *resp;
1811         struct ti_sci_info *info;
1812         struct ti_sci_xfer *xfer;
1813         int ret = 0;
1814
1815         if (IS_ERR(handle))
1816                 return PTR_ERR(handle);
1817         if (!handle)
1818                 return -EINVAL;
1819
1820         info = handle_to_ti_sci_info(handle);
1821
1822         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_REQUEST,
1823                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1824                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1825         if (IS_ERR(xfer)) {
1826                 ret = PTR_ERR(xfer);
1827                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1828                 return ret;
1829         }
1830         req.processor_id = proc_id;
1831
1832         ret = ti_sci_do_xfer(info, xfer);
1833         if (ret) {
1834                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1835                 return ret;
1836         }
1837
1838         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1839
1840         if (!ti_sci_is_response_ack(resp))
1841                 ret = -ENODEV;
1842
1843         return ret;
1844 }
1845
1846 /**
1847  * ti_sci_cmd_proc_release() - Command to release a physical processor control
1848  * @handle:     Pointer to TI SCI handle
1849  * @proc_id:    Processor ID this request is for
1850  *
1851  * Return: 0 if all went well, else returns appropriate error value.
1852  */
1853 static int ti_sci_cmd_proc_release(const struct ti_sci_handle *handle,
1854                                    u8 proc_id)
1855 {
1856         struct ti_sci_msg_req_proc_release req;
1857         struct ti_sci_msg_hdr *resp;
1858         struct ti_sci_info *info;
1859         struct ti_sci_xfer *xfer;
1860         int ret = 0;
1861
1862         if (IS_ERR(handle))
1863                 return PTR_ERR(handle);
1864         if (!handle)
1865                 return -EINVAL;
1866
1867         info = handle_to_ti_sci_info(handle);
1868
1869         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_RELEASE,
1870                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1871                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1872         if (IS_ERR(xfer)) {
1873                 ret = PTR_ERR(xfer);
1874                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1875                 return ret;
1876         }
1877         req.processor_id = proc_id;
1878
1879         ret = ti_sci_do_xfer(info, xfer);
1880         if (ret) {
1881                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1882                 return ret;
1883         }
1884
1885         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1886
1887         if (!ti_sci_is_response_ack(resp))
1888                 ret = -ENODEV;
1889
1890         return ret;
1891 }
1892
1893 /**
1894  * ti_sci_cmd_proc_handover() - Command to handover a physical processor
1895  *                              control to a host in the processor's access
1896  *                              control list.
1897  * @handle:     Pointer to TI SCI handle
1898  * @proc_id:    Processor ID this request is for
1899  * @host_id:    Host ID to get the control of the processor
1900  *
1901  * Return: 0 if all went well, else returns appropriate error value.
1902  */
1903 static int ti_sci_cmd_proc_handover(const struct ti_sci_handle *handle,
1904                                     u8 proc_id, u8 host_id)
1905 {
1906         struct ti_sci_msg_req_proc_handover req;
1907         struct ti_sci_msg_hdr *resp;
1908         struct ti_sci_info *info;
1909         struct ti_sci_xfer *xfer;
1910         int ret = 0;
1911
1912         if (IS_ERR(handle))
1913                 return PTR_ERR(handle);
1914         if (!handle)
1915                 return -EINVAL;
1916
1917         info = handle_to_ti_sci_info(handle);
1918
1919         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_HANDOVER,
1920                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1921                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1922         if (IS_ERR(xfer)) {
1923                 ret = PTR_ERR(xfer);
1924                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1925                 return ret;
1926         }
1927         req.processor_id = proc_id;
1928         req.host_id = host_id;
1929
1930         ret = ti_sci_do_xfer(info, xfer);
1931         if (ret) {
1932                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1933                 return ret;
1934         }
1935
1936         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1937
1938         if (!ti_sci_is_response_ack(resp))
1939                 ret = -ENODEV;
1940
1941         return ret;
1942 }
1943
1944 /**
1945  * ti_sci_cmd_set_proc_boot_cfg() - Command to set the processor boot
1946  *                                  configuration flags
1947  * @handle:             Pointer to TI SCI handle
1948  * @proc_id:            Processor ID this request is for
1949  * @config_flags_set:   Configuration flags to be set
1950  * @config_flags_clear: Configuration flags to be cleared.
1951  *
1952  * Return: 0 if all went well, else returns appropriate error value.
1953  */
1954 static int ti_sci_cmd_set_proc_boot_cfg(const struct ti_sci_handle *handle,
1955                                         u8 proc_id, u64 bootvector,
1956                                         u32 config_flags_set,
1957                                         u32 config_flags_clear)
1958 {
1959         struct ti_sci_msg_req_set_proc_boot_config req;
1960         struct ti_sci_msg_hdr *resp;
1961         struct ti_sci_info *info;
1962         struct ti_sci_xfer *xfer;
1963         int ret = 0;
1964
1965         if (IS_ERR(handle))
1966                 return PTR_ERR(handle);
1967         if (!handle)
1968                 return -EINVAL;
1969
1970         info = handle_to_ti_sci_info(handle);
1971
1972         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_SET_PROC_BOOT_CONFIG,
1973                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1974                                      (u32 *)&req, sizeof(req), sizeof(*resp));
1975         if (IS_ERR(xfer)) {
1976                 ret = PTR_ERR(xfer);
1977                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1978                 return ret;
1979         }
1980         req.processor_id = proc_id;
1981         req.bootvector_low = bootvector & TISCI_ADDR_LOW_MASK;
1982         req.bootvector_high = (bootvector & TISCI_ADDR_HIGH_MASK) >>
1983                                 TISCI_ADDR_HIGH_SHIFT;
1984         req.config_flags_set = config_flags_set;
1985         req.config_flags_clear = config_flags_clear;
1986
1987         ret = ti_sci_do_xfer(info, xfer);
1988         if (ret) {
1989                 dev_err(info->dev, "Mbox send fail %d\n", ret);
1990                 return ret;
1991         }
1992
1993         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1994
1995         if (!ti_sci_is_response_ack(resp))
1996                 ret = -ENODEV;
1997
1998         return ret;
1999 }
2000
2001 /**
2002  * ti_sci_cmd_set_proc_boot_ctrl() - Command to set the processor boot
2003  *                                   control flags
2004  * @handle:                     Pointer to TI SCI handle
2005  * @proc_id:                    Processor ID this request is for
2006  * @control_flags_set:          Control flags to be set
2007  * @control_flags_clear:        Control flags to be cleared
2008  *
2009  * Return: 0 if all went well, else returns appropriate error value.
2010  */
2011 static int ti_sci_cmd_set_proc_boot_ctrl(const struct ti_sci_handle *handle,
2012                                          u8 proc_id, u32 control_flags_set,
2013                                          u32 control_flags_clear)
2014 {
2015         struct ti_sci_msg_req_set_proc_boot_ctrl req;
2016         struct ti_sci_msg_hdr *resp;
2017         struct ti_sci_info *info;
2018         struct ti_sci_xfer *xfer;
2019         int ret = 0;
2020
2021         if (IS_ERR(handle))
2022                 return PTR_ERR(handle);
2023         if (!handle)
2024                 return -EINVAL;
2025
2026         info = handle_to_ti_sci_info(handle);
2027
2028         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_SET_PROC_BOOT_CTRL,
2029                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2030                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2031         if (IS_ERR(xfer)) {
2032                 ret = PTR_ERR(xfer);
2033                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2034                 return ret;
2035         }
2036         req.processor_id = proc_id;
2037         req.control_flags_set = control_flags_set;
2038         req.control_flags_clear = control_flags_clear;
2039
2040         ret = ti_sci_do_xfer(info, xfer);
2041         if (ret) {
2042                 dev_err(info->dev, "Mbox send fail %d\n", ret);
2043                 return ret;
2044         }
2045
2046         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2047
2048         if (!ti_sci_is_response_ack(resp))
2049                 ret = -ENODEV;
2050
2051         return ret;
2052 }
2053
2054 /**
2055  * ti_sci_cmd_proc_auth_boot_image() - Command to authenticate and load the
2056  *                      image and then set the processor configuration flags.
2057  * @handle:     Pointer to TI SCI handle
2058  * @image_addr: Memory address at which payload image and certificate is
2059  *              located in memory, this is updated if the image data is
2060  *              moved during authentication.
2061  * @image_size: This is updated with the final size of the image after
2062  *              authentication.
2063  *
2064  * Return: 0 if all went well, else returns appropriate error value.
2065  */
2066 static int ti_sci_cmd_proc_auth_boot_image(const struct ti_sci_handle *handle,
2067                                            u64 *image_addr, u32 *image_size)
2068 {
2069         struct ti_sci_msg_req_proc_auth_boot_image req;
2070         struct ti_sci_msg_resp_proc_auth_boot_image *resp;
2071         struct ti_sci_info *info;
2072         struct ti_sci_xfer *xfer;
2073         int ret = 0;
2074
2075         if (IS_ERR(handle))
2076                 return PTR_ERR(handle);
2077         if (!handle)
2078                 return -EINVAL;
2079
2080         info = handle_to_ti_sci_info(handle);
2081
2082         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_AUTH_BOOT_IMIAGE,
2083                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2084                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2085         if (IS_ERR(xfer)) {
2086                 ret = PTR_ERR(xfer);
2087                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2088                 return ret;
2089         }
2090         req.cert_addr_low = *image_addr & TISCI_ADDR_LOW_MASK;
2091         req.cert_addr_high = (*image_addr & TISCI_ADDR_HIGH_MASK) >>
2092                                 TISCI_ADDR_HIGH_SHIFT;
2093
2094         ret = ti_sci_do_xfer(info, xfer);
2095         if (ret) {
2096                 dev_err(info->dev, "Mbox send fail %d\n", ret);
2097                 return ret;
2098         }
2099
2100         resp = (struct ti_sci_msg_resp_proc_auth_boot_image *)xfer->tx_message.buf;
2101
2102         if (!ti_sci_is_response_ack(resp))
2103                 return -ENODEV;
2104
2105         *image_addr = (resp->image_addr_low & TISCI_ADDR_LOW_MASK) |
2106                         (((u64)resp->image_addr_high <<
2107                           TISCI_ADDR_HIGH_SHIFT) & TISCI_ADDR_HIGH_MASK);
2108         *image_size = resp->image_size;
2109
2110         return ret;
2111 }
2112
2113 /**
2114  * ti_sci_cmd_get_proc_boot_status() - Command to get the processor boot status
2115  * @handle:     Pointer to TI SCI handle
2116  * @proc_id:    Processor ID this request is for
2117  *
2118  * Return: 0 if all went well, else returns appropriate error value.
2119  */
2120 static int ti_sci_cmd_get_proc_boot_status(const struct ti_sci_handle *handle,
2121                                            u8 proc_id, u64 *bv, u32 *cfg_flags,
2122                                            u32 *ctrl_flags, u32 *sts_flags)
2123 {
2124         struct ti_sci_msg_resp_get_proc_boot_status *resp;
2125         struct ti_sci_msg_req_get_proc_boot_status req;
2126         struct ti_sci_info *info;
2127         struct ti_sci_xfer *xfer;
2128         int ret = 0;
2129
2130         if (IS_ERR(handle))
2131                 return PTR_ERR(handle);
2132         if (!handle)
2133                 return -EINVAL;
2134
2135         info = handle_to_ti_sci_info(handle);
2136
2137         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_GET_PROC_BOOT_STATUS,
2138                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2139                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2140         if (IS_ERR(xfer)) {
2141                 ret = PTR_ERR(xfer);
2142                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2143                 return ret;
2144         }
2145         req.processor_id = proc_id;
2146
2147         ret = ti_sci_do_xfer(info, xfer);
2148         if (ret) {
2149                 dev_err(info->dev, "Mbox send fail %d\n", ret);
2150                 return ret;
2151         }
2152
2153         resp = (struct ti_sci_msg_resp_get_proc_boot_status *)
2154                                                         xfer->tx_message.buf;
2155
2156         if (!ti_sci_is_response_ack(resp))
2157                 return -ENODEV;
2158         *bv = (resp->bootvector_low & TISCI_ADDR_LOW_MASK) |
2159                         (((u64)resp->bootvector_high  <<
2160                           TISCI_ADDR_HIGH_SHIFT) & TISCI_ADDR_HIGH_MASK);
2161         *cfg_flags = resp->config_flags;
2162         *ctrl_flags = resp->control_flags;
2163         *sts_flags = resp->status_flags;
2164
2165         return ret;
2166 }
2167
2168 /**
2169  * ti_sci_proc_wait_boot_status_no_wait() - Helper function to wait for a
2170  *                              processor boot status without requesting or
2171  *                              waiting for a response.
2172  * @proc_id:                    Processor ID this request is for
2173  * @num_wait_iterations:        Total number of iterations we will check before
2174  *                              we will timeout and give up
2175  * @num_match_iterations:       How many iterations should we have continued
2176  *                              status to account for status bits glitching.
2177  *                              This is to make sure that match occurs for
2178  *                              consecutive checks. This implies that the
2179  *                              worst case should consider that the stable
2180  *                              time should at the worst be num_wait_iterations
2181  *                              num_match_iterations to prevent timeout.
2182  * @delay_per_iteration_us:     Specifies how long to wait (in micro seconds)
2183  *                              between each status checks. This is the minimum
2184  *                              duration, and overhead of register reads and
2185  *                              checks are on top of this and can vary based on
2186  *                              varied conditions.
2187  * @delay_before_iterations_us: Specifies how long to wait (in micro seconds)
2188  *                              before the very first check in the first
2189  *                              iteration of status check loop. This is the
2190  *                              minimum duration, and overhead of register
2191  *                              reads and checks are.
2192  * @status_flags_1_set_all_wait:If non-zero, Specifies that all bits of the
2193  *                              status matching this field requested MUST be 1.
2194  * @status_flags_1_set_any_wait:If non-zero, Specifies that at least one of the
2195  *                              bits matching this field requested MUST be 1.
2196  * @status_flags_1_clr_all_wait:If non-zero, Specifies that all bits of the
2197  *                              status matching this field requested MUST be 0.
2198  * @status_flags_1_clr_any_wait:If non-zero, Specifies that at least one of the
2199  *                              bits matching this field requested MUST be 0.
2200  *
2201  * Return: 0 if all goes well, else appropriate error message
2202  */
2203 static int
2204 ti_sci_proc_wait_boot_status_no_wait(const struct ti_sci_handle *handle,
2205                                      u8 proc_id,
2206                                      u8 num_wait_iterations,
2207                                      u8 num_match_iterations,
2208                                      u8 delay_per_iteration_us,
2209                                      u8 delay_before_iterations_us,
2210                                      u32 status_flags_1_set_all_wait,
2211                                      u32 status_flags_1_set_any_wait,
2212                                      u32 status_flags_1_clr_all_wait,
2213                                      u32 status_flags_1_clr_any_wait)
2214 {
2215         struct ti_sci_msg_req_wait_proc_boot_status req;
2216         struct ti_sci_info *info;
2217         struct ti_sci_xfer *xfer;
2218         int ret = 0;
2219
2220         if (IS_ERR(handle))
2221                 return PTR_ERR(handle);
2222         if (!handle)
2223                 return -EINVAL;
2224
2225         info = handle_to_ti_sci_info(handle);
2226
2227         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_WAIT_PROC_BOOT_STATUS,
2228                                      TI_SCI_FLAG_REQ_GENERIC_NORESPONSE,
2229                                      (u32 *)&req, sizeof(req), 0);
2230         if (IS_ERR(xfer)) {
2231                 ret = PTR_ERR(xfer);
2232                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2233                 return ret;
2234         }
2235         req.processor_id = proc_id;
2236         req.num_wait_iterations = num_wait_iterations;
2237         req.num_match_iterations = num_match_iterations;
2238         req.delay_per_iteration_us = delay_per_iteration_us;
2239         req.delay_before_iterations_us = delay_before_iterations_us;
2240         req.status_flags_1_set_all_wait = status_flags_1_set_all_wait;
2241         req.status_flags_1_set_any_wait = status_flags_1_set_any_wait;
2242         req.status_flags_1_clr_all_wait = status_flags_1_clr_all_wait;
2243         req.status_flags_1_clr_any_wait = status_flags_1_clr_any_wait;
2244
2245         ret = ti_sci_do_xfer(info, xfer);
2246         if (ret)
2247                 dev_err(info->dev, "Mbox send fail %d\n", ret);
2248
2249         return ret;
2250 }
2251
2252 /**
2253  * ti_sci_cmd_proc_shutdown_no_wait() - Command to shutdown a core without
2254  *              requesting or waiting for a response. Note that this API call
2255  *              should be followed by placing the respective processor into
2256  *              either WFE or WFI mode.
2257  * @handle:     Pointer to TI SCI handle
2258  * @proc_id:    Processor ID this request is for
2259  *
2260  * Return: 0 if all went well, else returns appropriate error value.
2261  */
2262 static int ti_sci_cmd_proc_shutdown_no_wait(const struct ti_sci_handle *handle,
2263                                             u8 proc_id)
2264 {
2265         int ret;
2266
2267         /*
2268          * Send the core boot status wait message waiting for either WFE or
2269          * WFI without requesting or waiting for a TISCI response with the
2270          * maximum wait time to give us the best chance to get to the WFE/WFI
2271          * command that should follow the invocation of this API before the
2272          * DMSC-internal processing of this command times out. Note that
2273          * waiting for the R5 WFE/WFI flags will also work on an ARMV8 type
2274          * core as the related flag bit positions are the same.
2275          */
2276         ret = ti_sci_proc_wait_boot_status_no_wait(handle, proc_id,
2277                 U8_MAX, 100, U8_MAX, U8_MAX,
2278                 0, PROC_BOOT_STATUS_FLAG_R5_WFE | PROC_BOOT_STATUS_FLAG_R5_WFI,
2279                 0, 0);
2280         if (ret) {
2281                 dev_err(info->dev, "Sending core %u wait message fail %d\n",
2282                         proc_id, ret);
2283                 return ret;
2284         }
2285
2286         /*
2287          * Release a processor managed by TISCI without requesting or waiting
2288          * for a response.
2289          */
2290         ret = ti_sci_set_device_state_no_wait(handle, proc_id, 0,
2291                                               MSG_DEVICE_SW_STATE_AUTO_OFF);
2292         if (ret)
2293                 dev_err(info->dev, "Sending core %u shutdown message fail %d\n",
2294                         proc_id, ret);
2295
2296         return ret;
2297 }
2298
2299 /**
2300  * ti_sci_cmd_ring_config() - configure RA ring
2301  * @handle:     pointer to TI SCI handle
2302  * @valid_params: Bitfield defining validity of ring configuration parameters.
2303  * @nav_id: Device ID of Navigator Subsystem from which the ring is allocated
2304  * @index: Ring index.
2305  * @addr_lo: The ring base address lo 32 bits
2306  * @addr_hi: The ring base address hi 32 bits
2307  * @count: Number of ring elements.
2308  * @mode: The mode of the ring
2309  * @size: The ring element size.
2310  * @order_id: Specifies the ring's bus order ID.
2311  *
2312  * Return: 0 if all went well, else returns appropriate error value.
2313  *
2314  * See @ti_sci_msg_rm_ring_cfg_req for more info.
2315  */
2316 static int ti_sci_cmd_ring_config(const struct ti_sci_handle *handle,
2317                                   u32 valid_params, u16 nav_id, u16 index,
2318                                   u32 addr_lo, u32 addr_hi, u32 count,
2319                                   u8 mode, u8 size, u8 order_id)
2320 {
2321         struct ti_sci_msg_rm_ring_cfg_resp *resp;
2322         struct ti_sci_msg_rm_ring_cfg_req req;
2323         struct ti_sci_xfer *xfer;
2324         struct ti_sci_info *info;
2325         int ret = 0;
2326
2327         if (IS_ERR(handle))
2328                 return PTR_ERR(handle);
2329         if (!handle)
2330                 return -EINVAL;
2331
2332         info = handle_to_ti_sci_info(handle);
2333
2334         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_RM_RING_CFG,
2335                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2336                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2337         if (IS_ERR(xfer)) {
2338                 ret = PTR_ERR(xfer);
2339                 dev_err(info->dev, "RM_RA:Message config failed(%d)\n", ret);
2340                 return ret;
2341         }
2342         req.valid_params = valid_params;
2343         req.nav_id = nav_id;
2344         req.index = index;
2345         req.addr_lo = addr_lo;
2346         req.addr_hi = addr_hi;
2347         req.count = count;
2348         req.mode = mode;
2349         req.size = size;
2350         req.order_id = order_id;
2351
2352         ret = ti_sci_do_xfer(info, xfer);
2353         if (ret) {
2354                 dev_err(info->dev, "RM_RA:Mbox config send fail %d\n", ret);
2355                 goto fail;
2356         }
2357
2358         resp = (struct ti_sci_msg_rm_ring_cfg_resp *)xfer->tx_message.buf;
2359
2360         ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2361
2362 fail:
2363         dev_dbg(info->dev, "RM_RA:config ring %u ret:%d\n", index, ret);
2364         return ret;
2365 }
2366
2367 static int ti_sci_cmd_rm_psil_pair(const struct ti_sci_handle *handle,
2368                                    u32 nav_id, u32 src_thread, u32 dst_thread)
2369 {
2370         struct ti_sci_msg_hdr *resp;
2371         struct ti_sci_msg_psil_pair req;
2372         struct ti_sci_xfer *xfer;
2373         struct ti_sci_info *info;
2374         int ret = 0;
2375
2376         if (IS_ERR(handle))
2377                 return PTR_ERR(handle);
2378         if (!handle)
2379                 return -EINVAL;
2380
2381         info = handle_to_ti_sci_info(handle);
2382
2383         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_RM_PSIL_PAIR,
2384                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2385                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2386         if (IS_ERR(xfer)) {
2387                 ret = PTR_ERR(xfer);
2388                 dev_err(info->dev, "RM_PSIL:Message alloc failed(%d)\n", ret);
2389                 return ret;
2390         }
2391         req.nav_id = nav_id;
2392         req.src_thread = src_thread;
2393         req.dst_thread = dst_thread;
2394
2395         ret = ti_sci_do_xfer(info, xfer);
2396         if (ret) {
2397                 dev_err(info->dev, "RM_PSIL:Mbox send fail %d\n", ret);
2398                 goto fail;
2399         }
2400
2401         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2402         ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2403
2404 fail:
2405         dev_dbg(info->dev, "RM_PSIL: nav: %u link pair %u->%u ret:%u\n",
2406                 nav_id, src_thread, dst_thread, ret);
2407         return ret;
2408 }
2409
2410 static int ti_sci_cmd_rm_psil_unpair(const struct ti_sci_handle *handle,
2411                                      u32 nav_id, u32 src_thread, u32 dst_thread)
2412 {
2413         struct ti_sci_msg_hdr *resp;
2414         struct ti_sci_msg_psil_unpair req;
2415         struct ti_sci_xfer *xfer;
2416         struct ti_sci_info *info;
2417         int ret = 0;
2418
2419         if (IS_ERR(handle))
2420                 return PTR_ERR(handle);
2421         if (!handle)
2422                 return -EINVAL;
2423
2424         info = handle_to_ti_sci_info(handle);
2425
2426         xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_RM_PSIL_UNPAIR,
2427                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2428                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2429         if (IS_ERR(xfer)) {
2430                 ret = PTR_ERR(xfer);
2431                 dev_err(info->dev, "RM_PSIL:Message alloc failed(%d)\n", ret);
2432                 return ret;
2433         }
2434         req.nav_id = nav_id;
2435         req.src_thread = src_thread;
2436         req.dst_thread = dst_thread;
2437
2438         ret = ti_sci_do_xfer(info, xfer);
2439         if (ret) {
2440                 dev_err(info->dev, "RM_PSIL:Mbox send fail %d\n", ret);
2441                 goto fail;
2442         }
2443
2444         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2445         ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2446
2447 fail:
2448         dev_dbg(info->dev, "RM_PSIL: link unpair %u->%u ret:%u\n",
2449                 src_thread, dst_thread, ret);
2450         return ret;
2451 }
2452
2453 static int ti_sci_cmd_rm_udmap_tx_ch_cfg(
2454                         const struct ti_sci_handle *handle,
2455                         const struct ti_sci_msg_rm_udmap_tx_ch_cfg *params)
2456 {
2457         struct ti_sci_msg_rm_udmap_tx_ch_cfg_resp *resp;
2458         struct ti_sci_msg_rm_udmap_tx_ch_cfg_req req;
2459         struct ti_sci_xfer *xfer;
2460         struct ti_sci_info *info;
2461         int ret = 0;
2462
2463         if (IS_ERR(handle))
2464                 return PTR_ERR(handle);
2465         if (!handle)
2466                 return -EINVAL;
2467
2468         info = handle_to_ti_sci_info(handle);
2469
2470         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_RM_UDMAP_TX_CH_CFG,
2471                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2472                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2473         if (IS_ERR(xfer)) {
2474                 ret = PTR_ERR(xfer);
2475                 dev_err(info->dev, "Message TX_CH_CFG alloc failed(%d)\n", ret);
2476                 return ret;
2477         }
2478         req.valid_params = params->valid_params;
2479         req.nav_id = params->nav_id;
2480         req.index = params->index;
2481         req.tx_pause_on_err = params->tx_pause_on_err;
2482         req.tx_filt_einfo = params->tx_filt_einfo;
2483         req.tx_filt_pswords = params->tx_filt_pswords;
2484         req.tx_atype = params->tx_atype;
2485         req.tx_chan_type = params->tx_chan_type;
2486         req.tx_supr_tdpkt = params->tx_supr_tdpkt;
2487         req.tx_fetch_size = params->tx_fetch_size;
2488         req.tx_credit_count = params->tx_credit_count;
2489         req.txcq_qnum = params->txcq_qnum;
2490         req.tx_priority = params->tx_priority;
2491         req.tx_qos = params->tx_qos;
2492         req.tx_orderid = params->tx_orderid;
2493         req.fdepth = params->fdepth;
2494         req.tx_sched_priority = params->tx_sched_priority;
2495
2496         ret = ti_sci_do_xfer(info, xfer);
2497         if (ret) {
2498                 dev_err(info->dev, "Mbox send TX_CH_CFG fail %d\n", ret);
2499                 goto fail;
2500         }
2501
2502         resp =
2503               (struct ti_sci_msg_rm_udmap_tx_ch_cfg_resp *)xfer->tx_message.buf;
2504         ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2505
2506 fail:
2507         dev_dbg(info->dev, "TX_CH_CFG: chn %u ret:%u\n", params->index, ret);
2508         return ret;
2509 }
2510
2511 static int ti_sci_cmd_rm_udmap_rx_ch_cfg(
2512                         const struct ti_sci_handle *handle,
2513                         const struct ti_sci_msg_rm_udmap_rx_ch_cfg *params)
2514 {
2515         struct ti_sci_msg_rm_udmap_rx_ch_cfg_resp *resp;
2516         struct ti_sci_msg_rm_udmap_rx_ch_cfg_req req;
2517         struct ti_sci_xfer *xfer;
2518         struct ti_sci_info *info;
2519         int ret = 0;
2520
2521         if (IS_ERR(handle))
2522                 return PTR_ERR(handle);
2523         if (!handle)
2524                 return -EINVAL;
2525
2526         info = handle_to_ti_sci_info(handle);
2527
2528         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_RM_UDMAP_RX_CH_CFG,
2529                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2530                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2531         if (IS_ERR(xfer)) {
2532                 ret = PTR_ERR(xfer);
2533                 dev_err(info->dev, "Message RX_CH_CFG alloc failed(%d)\n", ret);
2534                 return ret;
2535         }
2536
2537         req.valid_params = params->valid_params;
2538         req.nav_id = params->nav_id;
2539         req.index = params->index;
2540         req.rx_fetch_size = params->rx_fetch_size;
2541         req.rxcq_qnum = params->rxcq_qnum;
2542         req.rx_priority = params->rx_priority;
2543         req.rx_qos = params->rx_qos;
2544         req.rx_orderid = params->rx_orderid;
2545         req.rx_sched_priority = params->rx_sched_priority;
2546         req.flowid_start = params->flowid_start;
2547         req.flowid_cnt = params->flowid_cnt;
2548         req.rx_pause_on_err = params->rx_pause_on_err;
2549         req.rx_atype = params->rx_atype;
2550         req.rx_chan_type = params->rx_chan_type;
2551         req.rx_ignore_short = params->rx_ignore_short;
2552         req.rx_ignore_long = params->rx_ignore_long;
2553
2554         ret = ti_sci_do_xfer(info, xfer);
2555         if (ret) {
2556                 dev_err(info->dev, "Mbox send RX_CH_CFG fail %d\n", ret);
2557                 goto fail;
2558         }
2559
2560         resp =
2561               (struct ti_sci_msg_rm_udmap_rx_ch_cfg_resp *)xfer->tx_message.buf;
2562         ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2563
2564 fail:
2565         dev_dbg(info->dev, "RX_CH_CFG: chn %u ret:%d\n", params->index, ret);
2566         return ret;
2567 }
2568
2569 static int ti_sci_cmd_rm_udmap_rx_flow_cfg(
2570                         const struct ti_sci_handle *handle,
2571                         const struct ti_sci_msg_rm_udmap_flow_cfg *params)
2572 {
2573         struct ti_sci_msg_rm_udmap_flow_cfg_resp *resp;
2574         struct ti_sci_msg_rm_udmap_flow_cfg_req req;
2575         struct ti_sci_xfer *xfer;
2576         struct ti_sci_info *info;
2577         int ret = 0;
2578
2579         if (IS_ERR(handle))
2580                 return PTR_ERR(handle);
2581         if (!handle)
2582                 return -EINVAL;
2583
2584         info = handle_to_ti_sci_info(handle);
2585
2586         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_RM_UDMAP_FLOW_CFG,
2587                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2588                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2589         if (IS_ERR(xfer)) {
2590                 ret = PTR_ERR(xfer);
2591                 dev_err(dev, "RX_FL_CFG: Message alloc failed(%d)\n", ret);
2592                 return ret;
2593         }
2594
2595         req.valid_params = params->valid_params;
2596         req.nav_id = params->nav_id;
2597         req.flow_index = params->flow_index;
2598         req.rx_einfo_present = params->rx_einfo_present;
2599         req.rx_psinfo_present = params->rx_psinfo_present;
2600         req.rx_error_handling = params->rx_error_handling;
2601         req.rx_desc_type = params->rx_desc_type;
2602         req.rx_sop_offset = params->rx_sop_offset;
2603         req.rx_dest_qnum = params->rx_dest_qnum;
2604         req.rx_src_tag_hi = params->rx_src_tag_hi;
2605         req.rx_src_tag_lo = params->rx_src_tag_lo;
2606         req.rx_dest_tag_hi = params->rx_dest_tag_hi;
2607         req.rx_dest_tag_lo = params->rx_dest_tag_lo;
2608         req.rx_src_tag_hi_sel = params->rx_src_tag_hi_sel;
2609         req.rx_src_tag_lo_sel = params->rx_src_tag_lo_sel;
2610         req.rx_dest_tag_hi_sel = params->rx_dest_tag_hi_sel;
2611         req.rx_dest_tag_lo_sel = params->rx_dest_tag_lo_sel;
2612         req.rx_fdq0_sz0_qnum = params->rx_fdq0_sz0_qnum;
2613         req.rx_fdq1_qnum = params->rx_fdq1_qnum;
2614         req.rx_fdq2_qnum = params->rx_fdq2_qnum;
2615         req.rx_fdq3_qnum = params->rx_fdq3_qnum;
2616         req.rx_ps_location = params->rx_ps_location;
2617
2618         ret = ti_sci_do_xfer(info, xfer);
2619         if (ret) {
2620                 dev_err(dev, "RX_FL_CFG: Mbox send fail %d\n", ret);
2621                 goto fail;
2622         }
2623
2624         resp =
2625                (struct ti_sci_msg_rm_udmap_flow_cfg_resp *)xfer->tx_message.buf;
2626         ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2627
2628 fail:
2629         dev_dbg(info->dev, "RX_FL_CFG: %u ret:%d\n", params->flow_index, ret);
2630         return ret;
2631 }
2632
2633 /**
2634  * ti_sci_cmd_set_fwl_region() - Request for configuring a firewall region
2635  * @handle:    pointer to TI SCI handle
2636  * @region:    region configuration parameters
2637  *
2638  * Return: 0 if all went well, else returns appropriate error value.
2639  */
2640 static int ti_sci_cmd_set_fwl_region(const struct ti_sci_handle *handle,
2641                                      const struct ti_sci_msg_fwl_region *region)
2642 {
2643         struct ti_sci_msg_fwl_set_firewall_region_req req;
2644         struct ti_sci_msg_hdr *resp;
2645         struct ti_sci_info *info;
2646         struct ti_sci_xfer *xfer;
2647         int ret = 0;
2648
2649         if (IS_ERR(handle))
2650                 return PTR_ERR(handle);
2651         if (!handle)
2652                 return -EINVAL;
2653
2654         info = handle_to_ti_sci_info(handle);
2655
2656         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_FWL_SET,
2657                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2658                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2659         if (IS_ERR(xfer)) {
2660                 ret = PTR_ERR(xfer);
2661                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2662                 return ret;
2663         }
2664
2665         req.fwl_id = region->fwl_id;
2666         req.region = region->region;
2667         req.n_permission_regs = region->n_permission_regs;
2668         req.control = region->control;
2669         req.permissions[0] = region->permissions[0];
2670         req.permissions[1] = region->permissions[1];
2671         req.permissions[2] = region->permissions[2];
2672         req.start_address = region->start_address;
2673         req.end_address = region->end_address;
2674
2675         ret = ti_sci_do_xfer(info, xfer);
2676         if (ret) {
2677                 dev_err(info->dev, "Mbox send fail %d\n", ret);
2678                 return ret;
2679         }
2680
2681         resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2682
2683         if (!ti_sci_is_response_ack(resp))
2684                 return -ENODEV;
2685
2686         return 0;
2687 }
2688
2689 /**
2690  * ti_sci_cmd_get_fwl_region() - Request for getting a firewall region
2691  * @handle:    pointer to TI SCI handle
2692  * @region:    region configuration parameters
2693  *
2694  * Return: 0 if all went well, else returns appropriate error value.
2695  */
2696 static int ti_sci_cmd_get_fwl_region(const struct ti_sci_handle *handle,
2697                                      struct ti_sci_msg_fwl_region *region)
2698 {
2699         struct ti_sci_msg_fwl_get_firewall_region_req req;
2700         struct ti_sci_msg_fwl_get_firewall_region_resp *resp;
2701         struct ti_sci_info *info;
2702         struct ti_sci_xfer *xfer;
2703         int ret = 0;
2704
2705         if (IS_ERR(handle))
2706                 return PTR_ERR(handle);
2707         if (!handle)
2708                 return -EINVAL;
2709
2710         info = handle_to_ti_sci_info(handle);
2711
2712         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_FWL_GET,
2713                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2714                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2715         if (IS_ERR(xfer)) {
2716                 ret = PTR_ERR(xfer);
2717                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2718                 return ret;
2719         }
2720
2721         req.fwl_id = region->fwl_id;
2722         req.region = region->region;
2723         req.n_permission_regs = region->n_permission_regs;
2724
2725         ret = ti_sci_do_xfer(info, xfer);
2726         if (ret) {
2727                 dev_err(info->dev, "Mbox send fail %d\n", ret);
2728                 return ret;
2729         }
2730
2731         resp = (struct ti_sci_msg_fwl_get_firewall_region_resp *)xfer->tx_message.buf;
2732
2733         if (!ti_sci_is_response_ack(resp))
2734                 return -ENODEV;
2735
2736         region->fwl_id = resp->fwl_id;
2737         region->region = resp->region;
2738         region->n_permission_regs = resp->n_permission_regs;
2739         region->control = resp->control;
2740         region->permissions[0] = resp->permissions[0];
2741         region->permissions[1] = resp->permissions[1];
2742         region->permissions[2] = resp->permissions[2];
2743         region->start_address = resp->start_address;
2744         region->end_address = resp->end_address;
2745
2746         return 0;
2747 }
2748
2749 /**
2750  * ti_sci_cmd_change_fwl_owner() - Request for changing a firewall owner
2751  * @handle:    pointer to TI SCI handle
2752  * @region:    region configuration parameters
2753  *
2754  * Return: 0 if all went well, else returns appropriate error value.
2755  */
2756 static int ti_sci_cmd_change_fwl_owner(const struct ti_sci_handle *handle,
2757                                        struct ti_sci_msg_fwl_owner *owner)
2758 {
2759         struct ti_sci_msg_fwl_change_owner_info_req req;
2760         struct ti_sci_msg_fwl_change_owner_info_resp *resp;
2761         struct ti_sci_info *info;
2762         struct ti_sci_xfer *xfer;
2763         int ret = 0;
2764
2765         if (IS_ERR(handle))
2766                 return PTR_ERR(handle);
2767         if (!handle)
2768                 return -EINVAL;
2769
2770         info = handle_to_ti_sci_info(handle);
2771
2772         xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_FWL_CHANGE_OWNER,
2773                                      TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2774                                      (u32 *)&req, sizeof(req), sizeof(*resp));
2775         if (IS_ERR(xfer)) {
2776                 ret = PTR_ERR(xfer);
2777                 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2778                 return ret;
2779         }
2780
2781         req.fwl_id = owner->fwl_id;
2782         req.region = owner->region;
2783         req.owner_index = owner->owner_index;
2784
2785         ret = ti_sci_do_xfer(info, xfer);
2786         if (ret) {
2787                 dev_err(info->dev, "Mbox send fail %d\n", ret);
2788                 return ret;
2789         }
2790
2791         resp = (struct ti_sci_msg_fwl_change_owner_info_resp *)xfer->tx_message.buf;
2792
2793         if (!ti_sci_is_response_ack(resp))
2794                 return -ENODEV;
2795
2796         owner->fwl_id = resp->fwl_id;
2797         owner->region = resp->region;
2798         owner->owner_index = resp->owner_index;
2799         owner->owner_privid = resp->owner_privid;
2800         owner->owner_permission_bits = resp->owner_permission_bits;
2801
2802         return ret;
2803 }
2804
2805 /*
2806  * ti_sci_setup_ops() - Setup the operations structures
2807  * @info:       pointer to TISCI pointer
2808  */
2809 static void ti_sci_setup_ops(struct ti_sci_info *info)
2810 {
2811         struct ti_sci_ops *ops = &info->handle.ops;
2812         struct ti_sci_board_ops *bops = &ops->board_ops;
2813         struct ti_sci_dev_ops *dops = &ops->dev_ops;
2814         struct ti_sci_clk_ops *cops = &ops->clk_ops;
2815         struct ti_sci_core_ops *core_ops = &ops->core_ops;
2816         struct ti_sci_rm_core_ops *rm_core_ops = &ops->rm_core_ops;
2817         struct ti_sci_proc_ops *pops = &ops->proc_ops;
2818         struct ti_sci_rm_ringacc_ops *rops = &ops->rm_ring_ops;
2819         struct ti_sci_rm_psil_ops *psilops = &ops->rm_psil_ops;
2820         struct ti_sci_rm_udmap_ops *udmap_ops = &ops->rm_udmap_ops;
2821         struct ti_sci_fwl_ops *fwl_ops = &ops->fwl_ops;
2822
2823         bops->board_config = ti_sci_cmd_set_board_config;
2824         bops->board_config_rm = ti_sci_cmd_set_board_config_rm;
2825         bops->board_config_security = ti_sci_cmd_set_board_config_security;
2826         bops->board_config_pm = ti_sci_cmd_set_board_config_pm;
2827
2828         dops->get_device = ti_sci_cmd_get_device;
2829         dops->get_device_exclusive = ti_sci_cmd_get_device_exclusive;
2830         dops->idle_device = ti_sci_cmd_idle_device;
2831         dops->idle_device_exclusive = ti_sci_cmd_idle_device_exclusive;
2832         dops->put_device = ti_sci_cmd_put_device;
2833         dops->is_valid = ti_sci_cmd_dev_is_valid;
2834         dops->get_context_loss_count = ti_sci_cmd_dev_get_clcnt;
2835         dops->is_idle = ti_sci_cmd_dev_is_idle;
2836         dops->is_stop = ti_sci_cmd_dev_is_stop;
2837         dops->is_on = ti_sci_cmd_dev_is_on;
2838         dops->is_transitioning = ti_sci_cmd_dev_is_trans;
2839         dops->set_device_resets = ti_sci_cmd_set_device_resets;
2840         dops->get_device_resets = ti_sci_cmd_get_device_resets;
2841         dops->release_exclusive_devices = ti_sci_cmd_release_exclusive_devices;
2842
2843         cops->get_clock = ti_sci_cmd_get_clock;
2844         cops->idle_clock = ti_sci_cmd_idle_clock;
2845         cops->put_clock = ti_sci_cmd_put_clock;
2846         cops->is_auto = ti_sci_cmd_clk_is_auto;
2847         cops->is_on = ti_sci_cmd_clk_is_on;
2848         cops->is_off = ti_sci_cmd_clk_is_off;
2849
2850         cops->set_parent = ti_sci_cmd_clk_set_parent;
2851         cops->get_parent = ti_sci_cmd_clk_get_parent;
2852         cops->get_num_parents = ti_sci_cmd_clk_get_num_parents;
2853
2854         cops->get_best_match_freq = ti_sci_cmd_clk_get_match_freq;
2855         cops->set_freq = ti_sci_cmd_clk_set_freq;
2856         cops->get_freq = ti_sci_cmd_clk_get_freq;
2857
2858         core_ops->reboot_device = ti_sci_cmd_core_reboot;
2859         core_ops->query_msmc = ti_sci_cmd_query_msmc;
2860
2861         rm_core_ops->get_range = ti_sci_cmd_get_resource_range;
2862         rm_core_ops->get_range_from_shost =
2863                 ti_sci_cmd_get_resource_range_from_shost;
2864
2865         pops->proc_request = ti_sci_cmd_proc_request;
2866         pops->proc_release = ti_sci_cmd_proc_release;
2867         pops->proc_handover = ti_sci_cmd_proc_handover;
2868         pops->set_proc_boot_cfg = ti_sci_cmd_set_proc_boot_cfg;
2869         pops->set_proc_boot_ctrl = ti_sci_cmd_set_proc_boot_ctrl;
2870         pops->proc_auth_boot_image = ti_sci_cmd_proc_auth_boot_image;
2871         pops->get_proc_boot_status = ti_sci_cmd_get_proc_boot_status;
2872         pops->proc_shutdown_no_wait = ti_sci_cmd_proc_shutdown_no_wait;
2873
2874         rops->config = ti_sci_cmd_ring_config;
2875
2876         psilops->pair = ti_sci_cmd_rm_psil_pair;
2877         psilops->unpair = ti_sci_cmd_rm_psil_unpair;
2878
2879         udmap_ops->tx_ch_cfg = ti_sci_cmd_rm_udmap_tx_ch_cfg;
2880         udmap_ops->rx_ch_cfg = ti_sci_cmd_rm_udmap_rx_ch_cfg;
2881         udmap_ops->rx_flow_cfg = ti_sci_cmd_rm_udmap_rx_flow_cfg;
2882
2883         fwl_ops->set_fwl_region = ti_sci_cmd_set_fwl_region;
2884         fwl_ops->get_fwl_region = ti_sci_cmd_get_fwl_region;
2885         fwl_ops->change_fwl_owner = ti_sci_cmd_change_fwl_owner;
2886 }
2887
2888 /**
2889  * ti_sci_get_handle_from_sysfw() - Get the TI SCI handle of the SYSFW
2890  * @dev:        Pointer to the SYSFW device
2891  *
2892  * Return: pointer to handle if successful, else EINVAL if invalid conditions
2893  *         are encountered.
2894  */
2895 const
2896 struct ti_sci_handle *ti_sci_get_handle_from_sysfw(struct udevice *sci_dev)
2897 {
2898         if (!sci_dev)
2899                 return ERR_PTR(-EINVAL);
2900
2901         struct ti_sci_info *info = dev_get_priv(sci_dev);
2902
2903         if (!info)
2904                 return ERR_PTR(-EINVAL);
2905
2906         struct ti_sci_handle *handle = &info->handle;
2907
2908         if (!handle)
2909                 return ERR_PTR(-EINVAL);
2910
2911         return handle;
2912 }
2913
2914 /**
2915  * ti_sci_get_handle() - Get the TI SCI handle for a device
2916  * @dev:        Pointer to device for which we want SCI handle
2917  *
2918  * Return: pointer to handle if successful, else EINVAL if invalid conditions
2919  *         are encountered.
2920  */
2921 const struct ti_sci_handle *ti_sci_get_handle(struct udevice *dev)
2922 {
2923         if (!dev)
2924                 return ERR_PTR(-EINVAL);
2925
2926         struct udevice *sci_dev = dev_get_parent(dev);
2927
2928         return ti_sci_get_handle_from_sysfw(sci_dev);
2929 }
2930
2931 /**
2932  * ti_sci_get_by_phandle() - Get the TI SCI handle using DT phandle
2933  * @dev:        device node
2934  * @propname:   property name containing phandle on TISCI node
2935  *
2936  * Return: pointer to handle if successful, else appropriate error value.
2937  */
2938 const struct ti_sci_handle *ti_sci_get_by_phandle(struct udevice *dev,
2939                                                   const char *property)
2940 {
2941         struct ti_sci_info *entry, *info = NULL;
2942         u32 phandle, err;
2943         ofnode node;
2944
2945         err = ofnode_read_u32(dev_ofnode(dev), property, &phandle);
2946         if (err)
2947                 return ERR_PTR(err);
2948
2949         node = ofnode_get_by_phandle(phandle);
2950         if (!ofnode_valid(node))
2951                 return ERR_PTR(-EINVAL);
2952
2953         list_for_each_entry(entry, &ti_sci_list, list)
2954                 if (ofnode_equal(dev_ofnode(entry->dev), node)) {
2955                         info = entry;
2956                         break;
2957                 }
2958
2959         if (!info)
2960                 return ERR_PTR(-ENODEV);
2961
2962         return &info->handle;
2963 }
2964
2965 /**
2966  * ti_sci_of_to_info() - generate private data from device tree
2967  * @dev:        corresponding system controller interface device
2968  * @info:       pointer to driver specific private data
2969  *
2970  * Return: 0 if all goes good, else appropriate error message.
2971  */
2972 static int ti_sci_of_to_info(struct udevice *dev, struct ti_sci_info *info)
2973 {
2974         int ret;
2975
2976         ret = mbox_get_by_name(dev, "tx", &info->chan_tx);
2977         if (ret) {
2978                 dev_err(dev, "%s: Acquiring Tx channel failed. ret = %d\n",
2979                         __func__, ret);
2980                 return ret;
2981         }
2982
2983         ret = mbox_get_by_name(dev, "rx", &info->chan_rx);
2984         if (ret) {
2985                 dev_err(dev, "%s: Acquiring Rx channel failed. ret = %d\n",
2986                         __func__, ret);
2987                 return ret;
2988         }
2989
2990         /* Notify channel is optional. Enable only if populated */
2991         ret = mbox_get_by_name(dev, "notify", &info->chan_notify);
2992         if (ret) {
2993                 dev_dbg(dev, "%s: Acquiring notify channel failed. ret = %d\n",
2994                         __func__, ret);
2995         }
2996
2997         info->host_id = dev_read_u32_default(dev, "ti,host-id",
2998                                              info->desc->default_host_id);
2999
3000         info->is_secure = dev_read_bool(dev, "ti,secure-host");
3001
3002         return 0;
3003 }
3004
3005 /**
3006  * ti_sci_probe() - Basic probe
3007  * @dev:        corresponding system controller interface device
3008  *
3009  * Return: 0 if all goes good, else appropriate error message.
3010  */
3011 static int ti_sci_probe(struct udevice *dev)
3012 {
3013         struct ti_sci_info *info;
3014         int ret;
3015
3016         debug("%s(dev=%p)\n", __func__, dev);
3017
3018         info = dev_get_priv(dev);
3019         info->desc = (void *)dev_get_driver_data(dev);
3020
3021         ret = ti_sci_of_to_info(dev, info);
3022         if (ret) {
3023                 dev_err(dev, "%s: Probe failed with error %d\n", __func__, ret);
3024                 return ret;
3025         }
3026
3027         info->dev = dev;
3028         info->seq = 0xA;
3029
3030         list_add_tail(&info->list, &ti_sci_list);
3031         ti_sci_setup_ops(info);
3032
3033         ret = ti_sci_cmd_get_revision(&info->handle);
3034
3035         INIT_LIST_HEAD(&info->dev_list);
3036
3037         return ret;
3038 }
3039
3040 /*
3041  * ti_sci_get_free_resource() - Get a free resource from TISCI resource.
3042  * @res:        Pointer to the TISCI resource
3043  *
3044  * Return: resource num if all went ok else TI_SCI_RESOURCE_NULL.
3045  */
3046 u16 ti_sci_get_free_resource(struct ti_sci_resource *res)
3047 {
3048         u16 set, free_bit;
3049
3050         for (set = 0; set < res->sets; set++) {
3051                 free_bit = find_first_zero_bit(res->desc[set].res_map,
3052                                                res->desc[set].num);
3053                 if (free_bit != res->desc[set].num) {
3054                         set_bit(free_bit, res->desc[set].res_map);
3055                         return res->desc[set].start + free_bit;
3056                 }
3057         }
3058
3059         return TI_SCI_RESOURCE_NULL;
3060 }
3061
3062 /**
3063  * ti_sci_release_resource() - Release a resource from TISCI resource.
3064  * @res:        Pointer to the TISCI resource
3065  */
3066 void ti_sci_release_resource(struct ti_sci_resource *res, u16 id)
3067 {
3068         u16 set;
3069
3070         for (set = 0; set < res->sets; set++) {
3071                 if (res->desc[set].start <= id &&
3072                     (res->desc[set].num + res->desc[set].start) > id)
3073                         clear_bit(id - res->desc[set].start,
3074                                   res->desc[set].res_map);
3075         }
3076 }
3077
3078 /**
3079  * devm_ti_sci_get_of_resource() - Get a TISCI resource assigned to a device
3080  * @handle:     TISCI handle
3081  * @dev:        Device pointer to which the resource is assigned
3082  * @of_prop:    property name by which the resource are represented
3083  *
3084  * Note: This function expects of_prop to be in the form of tuples
3085  *      <type, subtype>. Allocates and initializes ti_sci_resource structure
3086  *      for each of_prop. Client driver can directly call
3087  *      ti_sci_(get_free, release)_resource apis for handling the resource.
3088  *
3089  * Return: Pointer to ti_sci_resource if all went well else appropriate
3090  *         error pointer.
3091  */
3092 struct ti_sci_resource *
3093 devm_ti_sci_get_of_resource(const struct ti_sci_handle *handle,
3094                             struct udevice *dev, u32 dev_id, char *of_prop)
3095 {
3096         u32 resource_subtype;
3097         u16 resource_type;
3098         struct ti_sci_resource *res;
3099         bool valid_set = false;
3100         int sets, i, ret;
3101         u32 *temp;
3102
3103         res = devm_kzalloc(dev, sizeof(*res), GFP_KERNEL);
3104         if (!res)
3105                 return ERR_PTR(-ENOMEM);
3106
3107         sets = dev_read_size(dev, of_prop);
3108         if (sets < 0) {
3109                 dev_err(dev, "%s resource type ids not available\n", of_prop);
3110                 return ERR_PTR(sets);
3111         }
3112         temp = malloc(sets);
3113         sets /= sizeof(u32);
3114         res->sets = sets;
3115
3116         res->desc = devm_kcalloc(dev, res->sets, sizeof(*res->desc),
3117                                  GFP_KERNEL);
3118         if (!res->desc)
3119                 return ERR_PTR(-ENOMEM);
3120
3121         ret = ti_sci_get_resource_type(handle_to_ti_sci_info(handle), dev_id,
3122                                        &resource_type);
3123         if (ret) {
3124                 dev_err(dev, "No valid resource type for %u\n", dev_id);
3125                 return ERR_PTR(-EINVAL);
3126         }
3127
3128         ret = dev_read_u32_array(dev, of_prop, temp, res->sets);
3129         if (ret)
3130                 return ERR_PTR(-EINVAL);
3131
3132         for (i = 0; i < res->sets; i++) {
3133                 resource_subtype = temp[i];
3134                 ret = handle->ops.rm_core_ops.get_range(handle, dev_id,
3135                                                         resource_subtype,
3136                                                         &res->desc[i].start,
3137                                                         &res->desc[i].num);
3138                 if (ret) {
3139                         dev_dbg(dev, "type %d subtype %d not allocated for host %d\n",
3140                                 resource_type, resource_subtype,
3141                                 handle_to_ti_sci_info(handle)->host_id);
3142                         res->desc[i].start = 0;
3143                         res->desc[i].num = 0;
3144                         continue;
3145                 }
3146
3147                 valid_set = true;
3148                 dev_dbg(dev, "res type = %d, subtype = %d, start = %d, num = %d\n",
3149                         resource_type, resource_subtype, res->desc[i].start,
3150                         res->desc[i].num);
3151
3152                 res->desc[i].res_map =
3153                         devm_kzalloc(dev, BITS_TO_LONGS(res->desc[i].num) *
3154                                      sizeof(*res->desc[i].res_map), GFP_KERNEL);
3155                 if (!res->desc[i].res_map)
3156                         return ERR_PTR(-ENOMEM);
3157         }
3158
3159         if (valid_set)
3160                 return res;
3161
3162         return ERR_PTR(-EINVAL);
3163 }
3164
3165 /* Description for K2G */
3166 static const struct ti_sci_desc ti_sci_pmmc_k2g_desc = {
3167         .default_host_id = 2,
3168         /* Conservative duration */
3169         .max_rx_timeout_ms = 10000,
3170         /* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */
3171         .max_msgs = 20,
3172         .max_msg_size = 64,
3173         .rm_type_map = NULL,
3174 };
3175
3176 static struct ti_sci_rm_type_map ti_sci_am654_rm_type_map[] = {
3177         {.dev_id = 56, .type = 0x00b}, /* GIC_IRQ */
3178         {.dev_id = 179, .type = 0x000}, /* MAIN_NAV_UDMASS_IA0 */
3179         {.dev_id = 187, .type = 0x009}, /* MAIN_NAV_RA */
3180         {.dev_id = 188, .type = 0x006}, /* MAIN_NAV_UDMAP */
3181         {.dev_id = 194, .type = 0x007}, /* MCU_NAV_UDMAP */
3182         {.dev_id = 195, .type = 0x00a}, /* MCU_NAV_RA */
3183         {.dev_id = 0, .type = 0x000}, /* end of table */
3184 };
3185
3186 /* Description for AM654 */
3187 static const struct ti_sci_desc ti_sci_pmmc_am654_desc = {
3188         .default_host_id = 12,
3189         /* Conservative duration */
3190         .max_rx_timeout_ms = 10000,
3191         /* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */
3192         .max_msgs = 20,
3193         .max_msg_size = 60,
3194         .rm_type_map = ti_sci_am654_rm_type_map,
3195 };
3196
3197 static const struct udevice_id ti_sci_ids[] = {
3198         {
3199                 .compatible = "ti,k2g-sci",
3200                 .data = (ulong)&ti_sci_pmmc_k2g_desc
3201         },
3202         {
3203                 .compatible = "ti,am654-sci",
3204                 .data = (ulong)&ti_sci_pmmc_am654_desc
3205         },
3206         { /* Sentinel */ },
3207 };
3208
3209 U_BOOT_DRIVER(ti_sci) = {
3210         .name = "ti_sci",
3211         .id = UCLASS_FIRMWARE,
3212         .of_match = ti_sci_ids,
3213         .probe = ti_sci_probe,
3214         .priv_auto_alloc_size = sizeof(struct ti_sci_info),
3215 };