1 // SPDX-License-Identifier: GPL-2.0+
3 * Texas Instruments System Control Interface Protocol Driver
4 * Based on drivers/firmware/ti_sci.c from Linux.
6 * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/
7 * Lokesh Vutla <lokeshvutla@ti.com>
16 #include <dm/device.h>
17 #include <dm/device_compat.h>
18 #include <dm/devres.h>
19 #include <linux/bitops.h>
20 #include <linux/compat.h>
21 #include <linux/err.h>
22 #include <linux/soc/ti/k3-sec-proxy.h>
23 #include <linux/soc/ti/ti_sci_protocol.h>
27 /* List of all TI SCI devices active in system */
28 static LIST_HEAD(ti_sci_list);
31 * struct ti_sci_xfer - Structure representing a message flow
32 * @tx_message: Transmit message
33 * @rx_len: Receive message length
36 struct k3_sec_proxy_msg tx_message;
41 * struct ti_sci_rm_type_map - Structure representing TISCI Resource
42 * management representation of dev_ids.
43 * @dev_id: TISCI device ID
44 * @type: Corresponding id as identified by TISCI RM.
46 * Note: This is used only as a work around for using RM range apis
47 * for AM654 SoC. For future SoCs dev_id will be used as type
48 * for RM range APIs. In order to maintain ABI backward compatibility
49 * type is not being changed for AM654 SoC.
51 struct ti_sci_rm_type_map {
57 * struct ti_sci_desc - Description of SoC integration
58 * @default_host_id: Host identifier representing the compute entity
59 * @max_rx_timeout_ms: Timeout for communication with SoC (in Milliseconds)
60 * @max_msgs: Maximum number of messages that can be pending
61 * simultaneously in the system
62 * @max_msg_size: Maximum size of data per message that can be handled.
66 int max_rx_timeout_ms;
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
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.
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;
99 struct ti_sci_exclusive_dev {
102 struct list_head list;
105 #define handle_to_ti_sci_info(h) container_of(h, struct ti_sci_info, handle)
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
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.
120 * Return: Corresponding ti_sci_xfer pointer if all went fine,
121 * else appropriate error pointer.
123 static struct ti_sci_xfer *ti_sci_setup_one_xfer(struct ti_sci_info *info,
124 u16 msg_type, u32 msg_flags,
126 size_t tx_message_size,
127 size_t rx_message_size)
129 struct ti_sci_xfer *xfer = &info->xfer;
130 struct ti_sci_msg_hdr *hdr;
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);
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;
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;
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
159 * Return: -ETIMEDOUT in case of no response, if transmit error,
160 * return corresponding error, else if all goes well,
163 static inline int ti_sci_get_response(struct ti_sci_info *info,
164 struct ti_sci_xfer *xfer,
165 struct mbox_chan *chan)
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;
172 /* Receive the response */
173 ret = mbox_recv(chan, msg, info->desc->max_rx_timeout_ms * 1000);
175 dev_err(info->dev, "%s: Message receive failed. ret = %d\n",
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));
186 /* msg is updated by mailbox driver */
187 hdr = (struct ti_sci_msg_hdr *)msg->buf;
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",
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);
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);
211 * ti_sci_do_xfer() - Do one transfer
212 * @info: Pointer to SCI entity information
213 * @xfer: Transfer to initiate and wait for response
215 * Return: 0 if all went fine, else return appropriate error.
217 static inline int ti_sci_do_xfer(struct ti_sci_info *info,
218 struct ti_sci_xfer *xfer)
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;
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);
232 xfer->tx_message.buf = (u32 *)secure_buf;
233 xfer->tx_message.len += sizeof(secure_hdr);
236 xfer->rx_len += sizeof(secure_hdr);
239 /* Send the message */
240 ret = mbox_send(&info->chan_tx, msg);
242 dev_err(info->dev, "%s: Message sending failed. ret = %d\n",
247 /* Get response if requested */
249 ret = ti_sci_get_response(info, xfer, &info->chan_rx);
255 * ti_sci_cmd_get_revision() - command to get the revision of the SCI entity
256 * @handle: pointer to TI SCI handle
258 * Updates the SCI information in the internal data structure.
260 * Return: 0 if all went fine, else return appropriate error.
262 static int ti_sci_cmd_get_revision(struct ti_sci_handle *handle)
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;
272 return PTR_ERR(handle);
276 info = handle_to_ti_sci_info(handle);
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),
284 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
288 ret = ti_sci_do_xfer(info, xfer);
290 dev_err(info->dev, "Mbox communication fail %d\n", ret);
294 rev_info = (struct ti_sci_msg_resp_version *)xfer->tx_message.buf;
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));
307 * ti_sci_is_response_ack() - Generic ACK/NACK message checkup
308 * @r: pointer to response buffer
310 * Return: true if the response was an ACK, else returns false.
312 static inline bool ti_sci_is_response_ack(void *r)
314 struct ti_sci_msg_hdr *hdr = r;
316 return hdr->flags & TI_SCI_FLAG_RESP_GENERIC_ACK ? true : false;
320 * cmd_set_board_config_using_msg() - Common command to send board configuration
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
327 * Return: 0 if all went well, else returns appropriate error value.
329 static int cmd_set_board_config_using_msg(const struct ti_sci_handle *handle,
330 u16 msg_type, u64 addr, u32 size)
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;
339 return PTR_ERR(handle);
343 info = handle_to_ti_sci_info(handle);
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));
350 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
353 req.boardcfgp_high = (addr >> 32) & 0xffffffff;
354 req.boardcfgp_low = addr & 0xffffffff;
355 req.boardcfg_size = size;
357 ret = ti_sci_do_xfer(info, xfer);
359 dev_err(info->dev, "Mbox send fail %d\n", ret);
363 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
365 if (!ti_sci_is_response_ack(resp))
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
377 * Return: 0 if all went well, else returns appropriate error value.
379 static int ti_sci_cmd_set_board_config(const struct ti_sci_handle *handle,
382 return cmd_set_board_config_using_msg(handle,
383 TI_SCI_MSG_BOARD_CONFIG,
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
394 * Return: 0 if all went well, else returns appropriate error value.
397 int ti_sci_cmd_set_board_config_rm(const struct ti_sci_handle *handle,
400 return cmd_set_board_config_using_msg(handle,
401 TI_SCI_MSG_BOARD_CONFIG_RM,
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
412 * Return: 0 if all went well, else returns appropriate error value.
415 int ti_sci_cmd_set_board_config_security(const struct ti_sci_handle *handle,
418 return cmd_set_board_config_using_msg(handle,
419 TI_SCI_MSG_BOARD_CONFIG_SECURITY,
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
430 * Return: 0 if all went well, else returns appropriate error value.
432 static int ti_sci_cmd_set_board_config_pm(const struct ti_sci_handle *handle,
435 return cmd_set_board_config_using_msg(handle,
436 TI_SCI_MSG_BOARD_CONFIG_PM,
440 static struct ti_sci_exclusive_dev
441 *ti_sci_get_exclusive_dev(struct list_head *dev_list, u32 id)
443 struct ti_sci_exclusive_dev *dev;
445 list_for_each_entry(dev, dev_list, list)
452 static void ti_sci_add_exclusive_dev(struct ti_sci_info *info, u32 id)
454 struct ti_sci_exclusive_dev *dev;
456 dev = ti_sci_get_exclusive_dev(&info->dev_list, id);
462 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
465 INIT_LIST_HEAD(&dev->list);
466 list_add_tail(&dev->list, &info->dev_list);
469 static void ti_sci_delete_exclusive_dev(struct ti_sci_info *info, u32 id)
471 struct ti_sci_exclusive_dev *dev;
473 dev = ti_sci_get_exclusive_dev(&info->dev_list, id);
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
488 * Return: 0 if all went well, else returns appropriate error value.
490 static int ti_sci_set_device_state(const struct ti_sci_handle *handle,
491 u32 id, u32 flags, u8 state)
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;
500 return PTR_ERR(handle);
504 info = handle_to_ti_sci_info(handle);
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));
511 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
517 ret = ti_sci_do_xfer(info, xfer);
519 dev_err(info->dev, "Mbox send fail %d\n", ret);
523 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
525 if (!ti_sci_is_response_ack(resp))
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);
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
544 * Return: 0 if all went well, else returns appropriate error value.
546 static int ti_sci_set_device_state_no_wait(const struct ti_sci_handle *handle,
547 u32 id, u32 flags, u8 state)
549 struct ti_sci_msg_req_set_device_state req;
550 struct ti_sci_info *info;
551 struct ti_sci_xfer *xfer;
555 return PTR_ERR(handle);
559 info = handle_to_ti_sci_info(handle);
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);
566 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
572 ret = ti_sci_do_xfer(info, xfer);
574 dev_err(info->dev, "Mbox send fail %d\n", ret);
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
588 * Return: 0 if all went fine, else return appropriate error.
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)
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;
601 return PTR_ERR(handle);
605 if (!clcnt && !resets && !p_state && !c_state)
608 info = handle_to_ti_sci_info(handle);
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));
615 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
620 ret = ti_sci_do_xfer(info, xfer);
622 dev_err(info->dev, "Mbox send fail %d\n", ret);
626 resp = (struct ti_sci_msg_resp_get_device_state *)xfer->tx_message.buf;
627 if (!ti_sci_is_response_ack(resp))
631 *clcnt = resp->context_loss_count;
633 *resets = resp->resets;
635 *p_state = resp->programmed_state;
637 *c_state = resp->current_state;
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
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.
651 * NOTE: The request is for exclusive access for the processor.
653 * Return: 0 if all went fine, else return appropriate error.
655 static int ti_sci_cmd_get_device(const struct ti_sci_handle *handle, u32 id)
657 return ti_sci_set_device_state(handle, id, 0,
658 MSG_DEVICE_SW_STATE_ON);
661 static int ti_sci_cmd_get_device_exclusive(const struct ti_sci_handle *handle,
664 return ti_sci_set_device_state(handle, id, MSG_FLAG_DEVICE_EXCLUSIVE,
665 MSG_DEVICE_SW_STATE_ON);
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
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.
677 * Return: 0 if all went fine, else return appropriate error.
679 static int ti_sci_cmd_idle_device(const struct ti_sci_handle *handle, u32 id)
681 return ti_sci_set_device_state(handle, id,
683 MSG_DEVICE_SW_STATE_RETENTION);
686 static int ti_sci_cmd_idle_device_exclusive(const struct ti_sci_handle *handle,
689 return ti_sci_set_device_state(handle, id, MSG_FLAG_DEVICE_EXCLUSIVE,
690 MSG_DEVICE_SW_STATE_RETENTION);
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
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.
702 * Return: 0 if all went fine, else return appropriate error.
704 static int ti_sci_cmd_put_device(const struct ti_sci_handle *handle, u32 id)
706 return ti_sci_set_device_state(handle, id, 0,
707 MSG_DEVICE_SW_STATE_AUTO_OFF);
711 int ti_sci_cmd_release_exclusive_devices(const struct ti_sci_handle *handle)
713 struct ti_sci_exclusive_dev *dev, *tmp;
714 struct ti_sci_info *info;
717 info = handle_to_ti_sci_info(handle);
719 list_for_each_entry_safe(dev, tmp, &info->dev_list, list) {
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);
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
734 * Return: 0 if all went fine and the device ID is valid, else return
737 static int ti_sci_cmd_dev_is_valid(const struct ti_sci_handle *handle, u32 id)
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);
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
751 * Return: 0 if all went fine, else return appropriate error.
753 static int ti_sci_cmd_dev_get_clcnt(const struct ti_sci_handle *handle, u32 id,
756 return ti_sci_get_device_state(handle, id, count, NULL, NULL, NULL);
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
765 * Return: 0 if all went fine, else return appropriate error.
767 static int ti_sci_cmd_dev_is_idle(const struct ti_sci_handle *handle, u32 id,
776 ret = ti_sci_get_device_state(handle, id, NULL, NULL, &state, NULL);
780 *r_state = (state == MSG_DEVICE_SW_STATE_RETENTION);
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.
792 * Return: 0 if all went fine, else return appropriate error.
794 static int ti_sci_cmd_dev_is_stop(const struct ti_sci_handle *handle, u32 id,
795 bool *r_state, bool *curr_state)
800 if (!r_state && !curr_state)
804 ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);
809 *r_state = (p_state == MSG_DEVICE_SW_STATE_AUTO_OFF);
811 *curr_state = (c_state == MSG_DEVICE_HW_STATE_OFF);
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
823 * Return: 0 if all went fine, else return appropriate error.
825 static int ti_sci_cmd_dev_is_on(const struct ti_sci_handle *handle, u32 id,
826 bool *r_state, bool *curr_state)
831 if (!r_state && !curr_state)
835 ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);
840 *r_state = (p_state == MSG_DEVICE_SW_STATE_ON);
842 *curr_state = (c_state == MSG_DEVICE_HW_STATE_ON);
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.
853 * Return: 0 if all went fine, else return appropriate error.
855 static int ti_sci_cmd_dev_is_trans(const struct ti_sci_handle *handle, u32 id,
864 ret = ti_sci_get_device_state(handle, id, NULL, NULL, NULL, &state);
868 *curr_state = (state == MSG_DEVICE_HW_STATE_TRANS);
874 * ti_sci_cmd_set_device_resets() - command to set resets for device managed
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
880 * Return: 0 if all went fine, else return appropriate error.
882 static int ti_sci_cmd_set_device_resets(const struct ti_sci_handle *handle,
883 u32 id, u32 reset_state)
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;
892 return PTR_ERR(handle);
896 info = handle_to_ti_sci_info(handle);
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));
903 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
907 req.resets = reset_state;
909 ret = ti_sci_do_xfer(info, xfer);
911 dev_err(info->dev, "Mbox send fail %d\n", ret);
915 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
917 if (!ti_sci_is_response_ack(resp))
924 * ti_sci_cmd_get_device_resets() - Get reset state for device managed
926 * @handle: Pointer to TISCI handle
927 * @id: Device Identifier
928 * @reset_state: Pointer to reset state to populate
930 * Return: 0 if all went fine, else return appropriate error.
932 static int ti_sci_cmd_get_device_resets(const struct ti_sci_handle *handle,
933 u32 id, u32 *reset_state)
935 return ti_sci_get_device_state(handle, id, NULL, reset_state, NULL,
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.
949 * Return: 0 if all went well, else returns appropriate error value.
951 static int ti_sci_set_clock_state(const struct ti_sci_handle *handle,
952 u32 dev_id, u8 clk_id,
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;
962 return PTR_ERR(handle);
966 info = handle_to_ti_sci_info(handle);
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));
973 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
978 req.request_state = state;
980 ret = ti_sci_do_xfer(info, xfer);
982 dev_err(info->dev, "Mbox send fail %d\n", ret);
986 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
988 if (!ti_sci_is_response_ack(resp))
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
1004 * Return: 0 if all went well, else returns appropriate error value.
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)
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;
1017 return PTR_ERR(handle);
1021 if (!programmed_state && !current_state)
1024 info = handle_to_ti_sci_info(handle);
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));
1030 ret = PTR_ERR(xfer);
1031 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1034 req.dev_id = dev_id;
1035 req.clk_id = clk_id;
1037 ret = ti_sci_do_xfer(info, xfer);
1039 dev_err(info->dev, "Mbox send fail %d\n", ret);
1043 resp = (struct ti_sci_msg_resp_get_clock_state *)xfer->tx_message.buf;
1045 if (!ti_sci_is_response_ack(resp))
1048 if (programmed_state)
1049 *programmed_state = resp->programmed_state;
1051 *current_state = resp->current_state;
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'
1067 * Return: 0 if all went well, else returns appropriate error value.
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)
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;
1079 return ti_sci_set_clock_state(handle, dev_id, clk_id, flags,
1080 MSG_CLOCK_SW_STATE_REQ);
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.
1091 * NOTE: This clock must have been requested by get_clock previously.
1093 * Return: 0 if all went well, else returns appropriate error value.
1095 static int ti_sci_cmd_idle_clock(const struct ti_sci_handle *handle,
1096 u32 dev_id, u8 clk_id)
1098 return ti_sci_set_clock_state(handle, dev_id, clk_id, 0,
1099 MSG_CLOCK_SW_STATE_UNREQ);
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.
1110 * NOTE: This clock must have been requested by get_clock previously.
1112 * Return: 0 if all went well, else returns appropriate error value.
1114 static int ti_sci_cmd_put_clock(const struct ti_sci_handle *handle,
1115 u32 dev_id, u8 clk_id)
1117 return ti_sci_set_clock_state(handle, dev_id, clk_id, 0,
1118 MSG_CLOCK_SW_STATE_AUTO);
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
1130 * Return: 0 if all went well, else returns appropriate error value.
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)
1141 ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id, &state, NULL);
1145 *req_state = (state == MSG_CLOCK_SW_STATE_AUTO);
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
1159 * Return: 0 if all went well, else returns appropriate error value.
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)
1164 u8 c_state = 0, r_state = 0;
1167 if (!req_state && !curr_state)
1170 ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,
1171 &r_state, &c_state);
1176 *req_state = (r_state == MSG_CLOCK_SW_STATE_REQ);
1178 *curr_state = (c_state == MSG_CLOCK_HW_STATE_READY);
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
1192 * Return: 0 if all went well, else returns appropriate error value.
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)
1197 u8 c_state = 0, r_state = 0;
1200 if (!req_state && !curr_state)
1203 ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,
1204 &r_state, &c_state);
1209 *req_state = (r_state == MSG_CLOCK_SW_STATE_UNREQ);
1211 *curr_state = (c_state == MSG_CLOCK_HW_STATE_NOT_READY);
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
1224 * Return: 0 if all went well, else returns appropriate error value.
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)
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;
1236 return PTR_ERR(handle);
1240 info = handle_to_ti_sci_info(handle);
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));
1246 ret = PTR_ERR(xfer);
1247 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1250 req.dev_id = dev_id;
1251 req.clk_id = clk_id;
1252 req.parent_id = parent_id;
1254 ret = ti_sci_do_xfer(info, xfer);
1256 dev_err(info->dev, "Mbox send fail %d\n", ret);
1260 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1262 if (!ti_sci_is_response_ack(resp))
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
1277 * Return: 0 if all went well, else returns appropriate error value.
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)
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;
1289 return PTR_ERR(handle);
1290 if (!handle || !parent_id)
1293 info = handle_to_ti_sci_info(handle);
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));
1299 ret = PTR_ERR(xfer);
1300 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1303 req.dev_id = dev_id;
1304 req.clk_id = clk_id;
1306 ret = ti_sci_do_xfer(info, xfer);
1308 dev_err(info->dev, "Mbox send fail %d\n", ret);
1312 resp = (struct ti_sci_msg_resp_get_clock_parent *)xfer->tx_message.buf;
1314 if (!ti_sci_is_response_ack(resp))
1317 *parent_id = resp->parent_id;
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.
1331 * Return: 0 if all went well, else returns appropriate error value.
1333 static int ti_sci_cmd_clk_get_num_parents(const struct ti_sci_handle *handle,
1334 u32 dev_id, u8 clk_id,
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;
1344 return PTR_ERR(handle);
1345 if (!handle || !num_parents)
1348 info = handle_to_ti_sci_info(handle);
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));
1354 ret = PTR_ERR(xfer);
1355 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1358 req.dev_id = dev_id;
1359 req.clk_id = clk_id;
1361 ret = ti_sci_do_xfer(info, xfer);
1363 dev_err(info->dev, "Mbox send fail %d\n", ret);
1367 resp = (struct ti_sci_msg_resp_get_clock_num_parents *)
1368 xfer->tx_message.buf;
1370 if (!ti_sci_is_response_ack(resp))
1373 *num_parents = resp->num_parents;
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.
1395 * Return: 0 if all went well, else returns appropriate error value.
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,
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;
1409 return PTR_ERR(handle);
1410 if (!handle || !match_freq)
1413 info = handle_to_ti_sci_info(handle);
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));
1419 ret = PTR_ERR(xfer);
1420 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
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;
1429 ret = ti_sci_do_xfer(info, xfer);
1431 dev_err(info->dev, "Mbox send fail %d\n", ret);
1435 resp = (struct ti_sci_msg_resp_query_clock_freq *)xfer->tx_message.buf;
1437 if (!ti_sci_is_response_ack(resp))
1440 *match_freq = resp->freq_hz;
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.
1461 * Return: 0 if all went well, else returns appropriate error value.
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)
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;
1474 return PTR_ERR(handle);
1478 info = handle_to_ti_sci_info(handle);
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));
1484 ret = PTR_ERR(xfer);
1485 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
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;
1494 ret = ti_sci_do_xfer(info, xfer);
1496 dev_err(info->dev, "Mbox send fail %d\n", ret);
1500 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1502 if (!ti_sci_is_response_ack(resp))
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
1517 * Return: 0 if all went well, else returns appropriate error value.
1519 static int ti_sci_cmd_clk_get_freq(const struct ti_sci_handle *handle,
1520 u32 dev_id, u8 clk_id, u64 *freq)
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;
1529 return PTR_ERR(handle);
1530 if (!handle || !freq)
1533 info = handle_to_ti_sci_info(handle);
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));
1539 ret = PTR_ERR(xfer);
1540 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1543 req.dev_id = dev_id;
1544 req.clk_id = clk_id;
1546 ret = ti_sci_do_xfer(info, xfer);
1548 dev_err(info->dev, "Mbox send fail %d\n", ret);
1552 resp = (struct ti_sci_msg_resp_get_clock_freq *)xfer->tx_message.buf;
1554 if (!ti_sci_is_response_ack(resp))
1557 *freq = resp->freq_hz;
1563 * ti_sci_cmd_core_reboot() - Command to request system reset
1564 * @handle: pointer to TI SCI handle
1566 * Return: 0 if all went well, else returns appropriate error value.
1568 static int ti_sci_cmd_core_reboot(const struct ti_sci_handle *handle)
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;
1577 return PTR_ERR(handle);
1581 info = handle_to_ti_sci_info(handle);
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));
1587 ret = PTR_ERR(xfer);
1588 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1592 ret = ti_sci_do_xfer(info, xfer);
1594 dev_err(info->dev, "Mbox send fail %d\n", ret);
1598 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1600 if (!ti_sci_is_response_ack(resp))
1607 * ti_sci_get_resource_range - Helper to get a range of resources assigned
1608 * to a host. Resource is uniquely identified by
1610 * @handle: Pointer to TISCI handle.
1611 * @dev_id: TISCI device ID.
1612 * @subtype: Resource assignment subtype that is being requested
1613 * from the given device.
1614 * @s_host: Host processor ID to which the resources are allocated
1615 * @range_start: Start index of the resource range
1616 * @range_num: Number of resources in the range
1618 * Return: 0 if all went fine, else return appropriate error.
1620 static int ti_sci_get_resource_range(const struct ti_sci_handle *handle,
1621 u32 dev_id, u8 subtype, u8 s_host,
1622 u16 *range_start, u16 *range_num)
1624 struct ti_sci_msg_resp_get_resource_range *resp;
1625 struct ti_sci_msg_req_get_resource_range req;
1626 struct ti_sci_xfer *xfer;
1627 struct ti_sci_info *info;
1631 return PTR_ERR(handle);
1635 info = handle_to_ti_sci_info(handle);
1637 xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_GET_RESOURCE_RANGE,
1638 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1639 (u32 *)&req, sizeof(req), sizeof(*resp));
1641 ret = PTR_ERR(xfer);
1642 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1646 req.secondary_host = s_host;
1647 req.type = dev_id & MSG_RM_RESOURCE_TYPE_MASK;
1648 req.subtype = subtype & MSG_RM_RESOURCE_SUBTYPE_MASK;
1650 ret = ti_sci_do_xfer(info, xfer);
1652 dev_err(info->dev, "Mbox send fail %d\n", ret);
1656 resp = (struct ti_sci_msg_resp_get_resource_range *)xfer->tx_message.buf;
1657 if (!ti_sci_is_response_ack(resp)) {
1659 } else if (!resp->range_start && !resp->range_num) {
1662 *range_start = resp->range_start;
1663 *range_num = resp->range_num;
1671 * ti_sci_cmd_get_resource_range - Get a range of resources assigned to host
1672 * that is same as ti sci interface host.
1673 * @handle: Pointer to TISCI handle.
1674 * @dev_id: TISCI device ID.
1675 * @subtype: Resource assignment subtype that is being requested
1676 * from the given device.
1677 * @range_start: Start index of the resource range
1678 * @range_num: Number of resources in the range
1680 * Return: 0 if all went fine, else return appropriate error.
1682 static int ti_sci_cmd_get_resource_range(const struct ti_sci_handle *handle,
1683 u32 dev_id, u8 subtype,
1684 u16 *range_start, u16 *range_num)
1686 return ti_sci_get_resource_range(handle, dev_id, subtype,
1687 TI_SCI_IRQ_SECONDARY_HOST_INVALID,
1688 range_start, range_num);
1692 * ti_sci_cmd_get_resource_range_from_shost - Get a range of resources
1693 * assigned to a specified host.
1694 * @handle: Pointer to TISCI handle.
1695 * @dev_id: TISCI device ID.
1696 * @subtype: Resource assignment subtype that is being requested
1697 * from the given device.
1698 * @s_host: Host processor ID to which the resources are allocated
1699 * @range_start: Start index of the resource range
1700 * @range_num: Number of resources in the range
1702 * Return: 0 if all went fine, else return appropriate error.
1705 int ti_sci_cmd_get_resource_range_from_shost(const struct ti_sci_handle *handle,
1706 u32 dev_id, u8 subtype, u8 s_host,
1707 u16 *range_start, u16 *range_num)
1709 return ti_sci_get_resource_range(handle, dev_id, subtype, s_host,
1710 range_start, range_num);
1714 * ti_sci_cmd_query_msmc() - Command to query currently available msmc memory
1715 * @handle: pointer to TI SCI handle
1716 * @msms_start: MSMC start as returned by tisci
1717 * @msmc_end: MSMC end as returned by tisci
1719 * Return: 0 if all went well, else returns appropriate error value.
1721 static int ti_sci_cmd_query_msmc(const struct ti_sci_handle *handle,
1722 u64 *msmc_start, u64 *msmc_end)
1724 struct ti_sci_msg_resp_query_msmc *resp;
1725 struct ti_sci_msg_hdr req;
1726 struct ti_sci_info *info;
1727 struct ti_sci_xfer *xfer;
1731 return PTR_ERR(handle);
1735 info = handle_to_ti_sci_info(handle);
1737 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_QUERY_MSMC,
1738 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1739 (u32 *)&req, sizeof(req), sizeof(*resp));
1741 ret = PTR_ERR(xfer);
1742 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1746 ret = ti_sci_do_xfer(info, xfer);
1748 dev_err(info->dev, "Mbox send fail %d\n", ret);
1752 resp = (struct ti_sci_msg_resp_query_msmc *)xfer->tx_message.buf;
1754 if (!ti_sci_is_response_ack(resp))
1757 *msmc_start = ((u64)resp->msmc_start_high << TISCI_ADDR_HIGH_SHIFT) |
1758 resp->msmc_start_low;
1759 *msmc_end = ((u64)resp->msmc_end_high << TISCI_ADDR_HIGH_SHIFT) |
1766 * ti_sci_cmd_proc_request() - Command to request a physical processor control
1767 * @handle: Pointer to TI SCI handle
1768 * @proc_id: Processor ID this request is for
1770 * Return: 0 if all went well, else returns appropriate error value.
1772 static int ti_sci_cmd_proc_request(const struct ti_sci_handle *handle,
1775 struct ti_sci_msg_req_proc_request req;
1776 struct ti_sci_msg_hdr *resp;
1777 struct ti_sci_info *info;
1778 struct ti_sci_xfer *xfer;
1782 return PTR_ERR(handle);
1786 info = handle_to_ti_sci_info(handle);
1788 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_REQUEST,
1789 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1790 (u32 *)&req, sizeof(req), sizeof(*resp));
1792 ret = PTR_ERR(xfer);
1793 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1796 req.processor_id = proc_id;
1798 ret = ti_sci_do_xfer(info, xfer);
1800 dev_err(info->dev, "Mbox send fail %d\n", ret);
1804 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1806 if (!ti_sci_is_response_ack(resp))
1813 * ti_sci_cmd_proc_release() - Command to release a physical processor control
1814 * @handle: Pointer to TI SCI handle
1815 * @proc_id: Processor ID this request is for
1817 * Return: 0 if all went well, else returns appropriate error value.
1819 static int ti_sci_cmd_proc_release(const struct ti_sci_handle *handle,
1822 struct ti_sci_msg_req_proc_release req;
1823 struct ti_sci_msg_hdr *resp;
1824 struct ti_sci_info *info;
1825 struct ti_sci_xfer *xfer;
1829 return PTR_ERR(handle);
1833 info = handle_to_ti_sci_info(handle);
1835 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_RELEASE,
1836 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1837 (u32 *)&req, sizeof(req), sizeof(*resp));
1839 ret = PTR_ERR(xfer);
1840 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1843 req.processor_id = proc_id;
1845 ret = ti_sci_do_xfer(info, xfer);
1847 dev_err(info->dev, "Mbox send fail %d\n", ret);
1851 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1853 if (!ti_sci_is_response_ack(resp))
1860 * ti_sci_cmd_proc_handover() - Command to handover a physical processor
1861 * control to a host in the processor's access
1863 * @handle: Pointer to TI SCI handle
1864 * @proc_id: Processor ID this request is for
1865 * @host_id: Host ID to get the control of the processor
1867 * Return: 0 if all went well, else returns appropriate error value.
1869 static int ti_sci_cmd_proc_handover(const struct ti_sci_handle *handle,
1870 u8 proc_id, u8 host_id)
1872 struct ti_sci_msg_req_proc_handover req;
1873 struct ti_sci_msg_hdr *resp;
1874 struct ti_sci_info *info;
1875 struct ti_sci_xfer *xfer;
1879 return PTR_ERR(handle);
1883 info = handle_to_ti_sci_info(handle);
1885 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_HANDOVER,
1886 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1887 (u32 *)&req, sizeof(req), sizeof(*resp));
1889 ret = PTR_ERR(xfer);
1890 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1893 req.processor_id = proc_id;
1894 req.host_id = host_id;
1896 ret = ti_sci_do_xfer(info, xfer);
1898 dev_err(info->dev, "Mbox send fail %d\n", ret);
1902 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1904 if (!ti_sci_is_response_ack(resp))
1911 * ti_sci_cmd_set_proc_boot_cfg() - Command to set the processor boot
1912 * configuration flags
1913 * @handle: Pointer to TI SCI handle
1914 * @proc_id: Processor ID this request is for
1915 * @config_flags_set: Configuration flags to be set
1916 * @config_flags_clear: Configuration flags to be cleared.
1918 * Return: 0 if all went well, else returns appropriate error value.
1920 static int ti_sci_cmd_set_proc_boot_cfg(const struct ti_sci_handle *handle,
1921 u8 proc_id, u64 bootvector,
1922 u32 config_flags_set,
1923 u32 config_flags_clear)
1925 struct ti_sci_msg_req_set_proc_boot_config req;
1926 struct ti_sci_msg_hdr *resp;
1927 struct ti_sci_info *info;
1928 struct ti_sci_xfer *xfer;
1932 return PTR_ERR(handle);
1936 info = handle_to_ti_sci_info(handle);
1938 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_SET_PROC_BOOT_CONFIG,
1939 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1940 (u32 *)&req, sizeof(req), sizeof(*resp));
1942 ret = PTR_ERR(xfer);
1943 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
1946 req.processor_id = proc_id;
1947 req.bootvector_low = bootvector & TISCI_ADDR_LOW_MASK;
1948 req.bootvector_high = (bootvector & TISCI_ADDR_HIGH_MASK) >>
1949 TISCI_ADDR_HIGH_SHIFT;
1950 req.config_flags_set = config_flags_set;
1951 req.config_flags_clear = config_flags_clear;
1953 ret = ti_sci_do_xfer(info, xfer);
1955 dev_err(info->dev, "Mbox send fail %d\n", ret);
1959 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
1961 if (!ti_sci_is_response_ack(resp))
1968 * ti_sci_cmd_set_proc_boot_ctrl() - Command to set the processor boot
1970 * @handle: Pointer to TI SCI handle
1971 * @proc_id: Processor ID this request is for
1972 * @control_flags_set: Control flags to be set
1973 * @control_flags_clear: Control flags to be cleared
1975 * Return: 0 if all went well, else returns appropriate error value.
1977 static int ti_sci_cmd_set_proc_boot_ctrl(const struct ti_sci_handle *handle,
1978 u8 proc_id, u32 control_flags_set,
1979 u32 control_flags_clear)
1981 struct ti_sci_msg_req_set_proc_boot_ctrl req;
1982 struct ti_sci_msg_hdr *resp;
1983 struct ti_sci_info *info;
1984 struct ti_sci_xfer *xfer;
1988 return PTR_ERR(handle);
1992 info = handle_to_ti_sci_info(handle);
1994 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_SET_PROC_BOOT_CTRL,
1995 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1996 (u32 *)&req, sizeof(req), sizeof(*resp));
1998 ret = PTR_ERR(xfer);
1999 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2002 req.processor_id = proc_id;
2003 req.control_flags_set = control_flags_set;
2004 req.control_flags_clear = control_flags_clear;
2006 ret = ti_sci_do_xfer(info, xfer);
2008 dev_err(info->dev, "Mbox send fail %d\n", ret);
2012 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2014 if (!ti_sci_is_response_ack(resp))
2021 * ti_sci_cmd_proc_auth_boot_image() - Command to authenticate and load the
2022 * image and then set the processor configuration flags.
2023 * @handle: Pointer to TI SCI handle
2024 * @image_addr: Memory address at which payload image and certificate is
2025 * located in memory, this is updated if the image data is
2026 * moved during authentication.
2027 * @image_size: This is updated with the final size of the image after
2030 * Return: 0 if all went well, else returns appropriate error value.
2032 static int ti_sci_cmd_proc_auth_boot_image(const struct ti_sci_handle *handle,
2033 u64 *image_addr, u32 *image_size)
2035 struct ti_sci_msg_req_proc_auth_boot_image req;
2036 struct ti_sci_msg_resp_proc_auth_boot_image *resp;
2037 struct ti_sci_info *info;
2038 struct ti_sci_xfer *xfer;
2042 return PTR_ERR(handle);
2046 info = handle_to_ti_sci_info(handle);
2048 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_PROC_AUTH_BOOT_IMIAGE,
2049 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2050 (u32 *)&req, sizeof(req), sizeof(*resp));
2052 ret = PTR_ERR(xfer);
2053 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2056 req.cert_addr_low = *image_addr & TISCI_ADDR_LOW_MASK;
2057 req.cert_addr_high = (*image_addr & TISCI_ADDR_HIGH_MASK) >>
2058 TISCI_ADDR_HIGH_SHIFT;
2060 ret = ti_sci_do_xfer(info, xfer);
2062 dev_err(info->dev, "Mbox send fail %d\n", ret);
2066 resp = (struct ti_sci_msg_resp_proc_auth_boot_image *)xfer->tx_message.buf;
2068 if (!ti_sci_is_response_ack(resp))
2071 *image_addr = (resp->image_addr_low & TISCI_ADDR_LOW_MASK) |
2072 (((u64)resp->image_addr_high <<
2073 TISCI_ADDR_HIGH_SHIFT) & TISCI_ADDR_HIGH_MASK);
2074 *image_size = resp->image_size;
2080 * ti_sci_cmd_get_proc_boot_status() - Command to get the processor boot status
2081 * @handle: Pointer to TI SCI handle
2082 * @proc_id: Processor ID this request is for
2084 * Return: 0 if all went well, else returns appropriate error value.
2086 static int ti_sci_cmd_get_proc_boot_status(const struct ti_sci_handle *handle,
2087 u8 proc_id, u64 *bv, u32 *cfg_flags,
2088 u32 *ctrl_flags, u32 *sts_flags)
2090 struct ti_sci_msg_resp_get_proc_boot_status *resp;
2091 struct ti_sci_msg_req_get_proc_boot_status req;
2092 struct ti_sci_info *info;
2093 struct ti_sci_xfer *xfer;
2097 return PTR_ERR(handle);
2101 info = handle_to_ti_sci_info(handle);
2103 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_GET_PROC_BOOT_STATUS,
2104 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2105 (u32 *)&req, sizeof(req), sizeof(*resp));
2107 ret = PTR_ERR(xfer);
2108 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2111 req.processor_id = proc_id;
2113 ret = ti_sci_do_xfer(info, xfer);
2115 dev_err(info->dev, "Mbox send fail %d\n", ret);
2119 resp = (struct ti_sci_msg_resp_get_proc_boot_status *)
2120 xfer->tx_message.buf;
2122 if (!ti_sci_is_response_ack(resp))
2124 *bv = (resp->bootvector_low & TISCI_ADDR_LOW_MASK) |
2125 (((u64)resp->bootvector_high <<
2126 TISCI_ADDR_HIGH_SHIFT) & TISCI_ADDR_HIGH_MASK);
2127 *cfg_flags = resp->config_flags;
2128 *ctrl_flags = resp->control_flags;
2129 *sts_flags = resp->status_flags;
2135 * ti_sci_proc_wait_boot_status_no_wait() - Helper function to wait for a
2136 * processor boot status without requesting or
2137 * waiting for a response.
2138 * @proc_id: Processor ID this request is for
2139 * @num_wait_iterations: Total number of iterations we will check before
2140 * we will timeout and give up
2141 * @num_match_iterations: How many iterations should we have continued
2142 * status to account for status bits glitching.
2143 * This is to make sure that match occurs for
2144 * consecutive checks. This implies that the
2145 * worst case should consider that the stable
2146 * time should at the worst be num_wait_iterations
2147 * num_match_iterations to prevent timeout.
2148 * @delay_per_iteration_us: Specifies how long to wait (in micro seconds)
2149 * between each status checks. This is the minimum
2150 * duration, and overhead of register reads and
2151 * checks are on top of this and can vary based on
2152 * varied conditions.
2153 * @delay_before_iterations_us: Specifies how long to wait (in micro seconds)
2154 * before the very first check in the first
2155 * iteration of status check loop. This is the
2156 * minimum duration, and overhead of register
2157 * reads and checks are.
2158 * @status_flags_1_set_all_wait:If non-zero, Specifies that all bits of the
2159 * status matching this field requested MUST be 1.
2160 * @status_flags_1_set_any_wait:If non-zero, Specifies that at least one of the
2161 * bits matching this field requested MUST be 1.
2162 * @status_flags_1_clr_all_wait:If non-zero, Specifies that all bits of the
2163 * status matching this field requested MUST be 0.
2164 * @status_flags_1_clr_any_wait:If non-zero, Specifies that at least one of the
2165 * bits matching this field requested MUST be 0.
2167 * Return: 0 if all goes well, else appropriate error message
2170 ti_sci_proc_wait_boot_status_no_wait(const struct ti_sci_handle *handle,
2172 u8 num_wait_iterations,
2173 u8 num_match_iterations,
2174 u8 delay_per_iteration_us,
2175 u8 delay_before_iterations_us,
2176 u32 status_flags_1_set_all_wait,
2177 u32 status_flags_1_set_any_wait,
2178 u32 status_flags_1_clr_all_wait,
2179 u32 status_flags_1_clr_any_wait)
2181 struct ti_sci_msg_req_wait_proc_boot_status req;
2182 struct ti_sci_info *info;
2183 struct ti_sci_xfer *xfer;
2187 return PTR_ERR(handle);
2191 info = handle_to_ti_sci_info(handle);
2193 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_WAIT_PROC_BOOT_STATUS,
2194 TI_SCI_FLAG_REQ_GENERIC_NORESPONSE,
2195 (u32 *)&req, sizeof(req), 0);
2197 ret = PTR_ERR(xfer);
2198 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2201 req.processor_id = proc_id;
2202 req.num_wait_iterations = num_wait_iterations;
2203 req.num_match_iterations = num_match_iterations;
2204 req.delay_per_iteration_us = delay_per_iteration_us;
2205 req.delay_before_iterations_us = delay_before_iterations_us;
2206 req.status_flags_1_set_all_wait = status_flags_1_set_all_wait;
2207 req.status_flags_1_set_any_wait = status_flags_1_set_any_wait;
2208 req.status_flags_1_clr_all_wait = status_flags_1_clr_all_wait;
2209 req.status_flags_1_clr_any_wait = status_flags_1_clr_any_wait;
2211 ret = ti_sci_do_xfer(info, xfer);
2213 dev_err(info->dev, "Mbox send fail %d\n", ret);
2219 * ti_sci_cmd_proc_shutdown_no_wait() - Command to shutdown a core without
2220 * requesting or waiting for a response. Note that this API call
2221 * should be followed by placing the respective processor into
2222 * either WFE or WFI mode.
2223 * @handle: Pointer to TI SCI handle
2224 * @proc_id: Processor ID this request is for
2226 * Return: 0 if all went well, else returns appropriate error value.
2228 static int ti_sci_cmd_proc_shutdown_no_wait(const struct ti_sci_handle *handle,
2232 struct ti_sci_info *info;
2235 return PTR_ERR(handle);
2239 info = handle_to_ti_sci_info(handle);
2242 * Send the core boot status wait message waiting for either WFE or
2243 * WFI without requesting or waiting for a TISCI response with the
2244 * maximum wait time to give us the best chance to get to the WFE/WFI
2245 * command that should follow the invocation of this API before the
2246 * DMSC-internal processing of this command times out. Note that
2247 * waiting for the R5 WFE/WFI flags will also work on an ARMV8 type
2248 * core as the related flag bit positions are the same.
2250 ret = ti_sci_proc_wait_boot_status_no_wait(handle, proc_id,
2251 U8_MAX, 100, U8_MAX, U8_MAX,
2252 0, PROC_BOOT_STATUS_FLAG_R5_WFE | PROC_BOOT_STATUS_FLAG_R5_WFI,
2255 dev_err(info->dev, "Sending core %u wait message fail %d\n",
2261 * Release a processor managed by TISCI without requesting or waiting
2264 ret = ti_sci_set_device_state_no_wait(handle, proc_id, 0,
2265 MSG_DEVICE_SW_STATE_AUTO_OFF);
2267 dev_err(info->dev, "Sending core %u shutdown message fail %d\n",
2274 * ti_sci_cmd_ring_config() - configure RA ring
2275 * @handle: pointer to TI SCI handle
2276 * @valid_params: Bitfield defining validity of ring configuration parameters.
2277 * @nav_id: Device ID of Navigator Subsystem from which the ring is allocated
2278 * @index: Ring index.
2279 * @addr_lo: The ring base address lo 32 bits
2280 * @addr_hi: The ring base address hi 32 bits
2281 * @count: Number of ring elements.
2282 * @mode: The mode of the ring
2283 * @size: The ring element size.
2284 * @order_id: Specifies the ring's bus order ID.
2286 * Return: 0 if all went well, else returns appropriate error value.
2288 * See @ti_sci_msg_rm_ring_cfg_req for more info.
2290 static int ti_sci_cmd_ring_config(const struct ti_sci_handle *handle,
2291 u32 valid_params, u16 nav_id, u16 index,
2292 u32 addr_lo, u32 addr_hi, u32 count,
2293 u8 mode, u8 size, u8 order_id)
2295 struct ti_sci_msg_rm_ring_cfg_resp *resp;
2296 struct ti_sci_msg_rm_ring_cfg_req req;
2297 struct ti_sci_xfer *xfer;
2298 struct ti_sci_info *info;
2302 return PTR_ERR(handle);
2306 info = handle_to_ti_sci_info(handle);
2308 xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_RM_RING_CFG,
2309 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2310 (u32 *)&req, sizeof(req), sizeof(*resp));
2312 ret = PTR_ERR(xfer);
2313 dev_err(info->dev, "RM_RA:Message config failed(%d)\n", ret);
2316 req.valid_params = valid_params;
2317 req.nav_id = nav_id;
2319 req.addr_lo = addr_lo;
2320 req.addr_hi = addr_hi;
2324 req.order_id = order_id;
2326 ret = ti_sci_do_xfer(info, xfer);
2328 dev_err(info->dev, "RM_RA:Mbox config send fail %d\n", ret);
2332 resp = (struct ti_sci_msg_rm_ring_cfg_resp *)xfer->tx_message.buf;
2334 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2337 dev_dbg(info->dev, "RM_RA:config ring %u ret:%d\n", index, ret);
2341 static int ti_sci_cmd_rm_psil_pair(const struct ti_sci_handle *handle,
2342 u32 nav_id, u32 src_thread, u32 dst_thread)
2344 struct ti_sci_msg_hdr *resp;
2345 struct ti_sci_msg_psil_pair req;
2346 struct ti_sci_xfer *xfer;
2347 struct ti_sci_info *info;
2351 return PTR_ERR(handle);
2355 info = handle_to_ti_sci_info(handle);
2357 xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_RM_PSIL_PAIR,
2358 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2359 (u32 *)&req, sizeof(req), sizeof(*resp));
2361 ret = PTR_ERR(xfer);
2362 dev_err(info->dev, "RM_PSIL:Message alloc failed(%d)\n", ret);
2365 req.nav_id = nav_id;
2366 req.src_thread = src_thread;
2367 req.dst_thread = dst_thread;
2369 ret = ti_sci_do_xfer(info, xfer);
2371 dev_err(info->dev, "RM_PSIL:Mbox send fail %d\n", ret);
2375 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2376 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2379 dev_dbg(info->dev, "RM_PSIL: nav: %u link pair %u->%u ret:%u\n",
2380 nav_id, src_thread, dst_thread, ret);
2384 static int ti_sci_cmd_rm_psil_unpair(const struct ti_sci_handle *handle,
2385 u32 nav_id, u32 src_thread, u32 dst_thread)
2387 struct ti_sci_msg_hdr *resp;
2388 struct ti_sci_msg_psil_unpair req;
2389 struct ti_sci_xfer *xfer;
2390 struct ti_sci_info *info;
2394 return PTR_ERR(handle);
2398 info = handle_to_ti_sci_info(handle);
2400 xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_RM_PSIL_UNPAIR,
2401 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2402 (u32 *)&req, sizeof(req), sizeof(*resp));
2404 ret = PTR_ERR(xfer);
2405 dev_err(info->dev, "RM_PSIL:Message alloc failed(%d)\n", ret);
2408 req.nav_id = nav_id;
2409 req.src_thread = src_thread;
2410 req.dst_thread = dst_thread;
2412 ret = ti_sci_do_xfer(info, xfer);
2414 dev_err(info->dev, "RM_PSIL:Mbox send fail %d\n", ret);
2418 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2419 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2422 dev_dbg(info->dev, "RM_PSIL: link unpair %u->%u ret:%u\n",
2423 src_thread, dst_thread, ret);
2427 static int ti_sci_cmd_rm_udmap_tx_ch_cfg(
2428 const struct ti_sci_handle *handle,
2429 const struct ti_sci_msg_rm_udmap_tx_ch_cfg *params)
2431 struct ti_sci_msg_rm_udmap_tx_ch_cfg_resp *resp;
2432 struct ti_sci_msg_rm_udmap_tx_ch_cfg_req req;
2433 struct ti_sci_xfer *xfer;
2434 struct ti_sci_info *info;
2438 return PTR_ERR(handle);
2442 info = handle_to_ti_sci_info(handle);
2444 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_RM_UDMAP_TX_CH_CFG,
2445 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2446 (u32 *)&req, sizeof(req), sizeof(*resp));
2448 ret = PTR_ERR(xfer);
2449 dev_err(info->dev, "Message TX_CH_CFG alloc failed(%d)\n", ret);
2452 req.valid_params = params->valid_params;
2453 req.nav_id = params->nav_id;
2454 req.index = params->index;
2455 req.tx_pause_on_err = params->tx_pause_on_err;
2456 req.tx_filt_einfo = params->tx_filt_einfo;
2457 req.tx_filt_pswords = params->tx_filt_pswords;
2458 req.tx_atype = params->tx_atype;
2459 req.tx_chan_type = params->tx_chan_type;
2460 req.tx_supr_tdpkt = params->tx_supr_tdpkt;
2461 req.tx_fetch_size = params->tx_fetch_size;
2462 req.tx_credit_count = params->tx_credit_count;
2463 req.txcq_qnum = params->txcq_qnum;
2464 req.tx_priority = params->tx_priority;
2465 req.tx_qos = params->tx_qos;
2466 req.tx_orderid = params->tx_orderid;
2467 req.fdepth = params->fdepth;
2468 req.tx_sched_priority = params->tx_sched_priority;
2470 ret = ti_sci_do_xfer(info, xfer);
2472 dev_err(info->dev, "Mbox send TX_CH_CFG fail %d\n", ret);
2477 (struct ti_sci_msg_rm_udmap_tx_ch_cfg_resp *)xfer->tx_message.buf;
2478 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2481 dev_dbg(info->dev, "TX_CH_CFG: chn %u ret:%u\n", params->index, ret);
2485 static int ti_sci_cmd_rm_udmap_rx_ch_cfg(
2486 const struct ti_sci_handle *handle,
2487 const struct ti_sci_msg_rm_udmap_rx_ch_cfg *params)
2489 struct ti_sci_msg_rm_udmap_rx_ch_cfg_resp *resp;
2490 struct ti_sci_msg_rm_udmap_rx_ch_cfg_req req;
2491 struct ti_sci_xfer *xfer;
2492 struct ti_sci_info *info;
2496 return PTR_ERR(handle);
2500 info = handle_to_ti_sci_info(handle);
2502 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_RM_UDMAP_RX_CH_CFG,
2503 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2504 (u32 *)&req, sizeof(req), sizeof(*resp));
2506 ret = PTR_ERR(xfer);
2507 dev_err(info->dev, "Message RX_CH_CFG alloc failed(%d)\n", ret);
2511 req.valid_params = params->valid_params;
2512 req.nav_id = params->nav_id;
2513 req.index = params->index;
2514 req.rx_fetch_size = params->rx_fetch_size;
2515 req.rxcq_qnum = params->rxcq_qnum;
2516 req.rx_priority = params->rx_priority;
2517 req.rx_qos = params->rx_qos;
2518 req.rx_orderid = params->rx_orderid;
2519 req.rx_sched_priority = params->rx_sched_priority;
2520 req.flowid_start = params->flowid_start;
2521 req.flowid_cnt = params->flowid_cnt;
2522 req.rx_pause_on_err = params->rx_pause_on_err;
2523 req.rx_atype = params->rx_atype;
2524 req.rx_chan_type = params->rx_chan_type;
2525 req.rx_ignore_short = params->rx_ignore_short;
2526 req.rx_ignore_long = params->rx_ignore_long;
2528 ret = ti_sci_do_xfer(info, xfer);
2530 dev_err(info->dev, "Mbox send RX_CH_CFG fail %d\n", ret);
2535 (struct ti_sci_msg_rm_udmap_rx_ch_cfg_resp *)xfer->tx_message.buf;
2536 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2539 dev_dbg(info->dev, "RX_CH_CFG: chn %u ret:%d\n", params->index, ret);
2543 static int ti_sci_cmd_rm_udmap_rx_flow_cfg(
2544 const struct ti_sci_handle *handle,
2545 const struct ti_sci_msg_rm_udmap_flow_cfg *params)
2547 struct ti_sci_msg_rm_udmap_flow_cfg_resp *resp;
2548 struct ti_sci_msg_rm_udmap_flow_cfg_req req;
2549 struct ti_sci_xfer *xfer;
2550 struct ti_sci_info *info;
2554 return PTR_ERR(handle);
2558 info = handle_to_ti_sci_info(handle);
2560 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_RM_UDMAP_FLOW_CFG,
2561 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2562 (u32 *)&req, sizeof(req), sizeof(*resp));
2564 ret = PTR_ERR(xfer);
2565 dev_err(info->dev, "RX_FL_CFG: Message alloc failed(%d)\n",
2570 req.valid_params = params->valid_params;
2571 req.nav_id = params->nav_id;
2572 req.flow_index = params->flow_index;
2573 req.rx_einfo_present = params->rx_einfo_present;
2574 req.rx_psinfo_present = params->rx_psinfo_present;
2575 req.rx_error_handling = params->rx_error_handling;
2576 req.rx_desc_type = params->rx_desc_type;
2577 req.rx_sop_offset = params->rx_sop_offset;
2578 req.rx_dest_qnum = params->rx_dest_qnum;
2579 req.rx_src_tag_hi = params->rx_src_tag_hi;
2580 req.rx_src_tag_lo = params->rx_src_tag_lo;
2581 req.rx_dest_tag_hi = params->rx_dest_tag_hi;
2582 req.rx_dest_tag_lo = params->rx_dest_tag_lo;
2583 req.rx_src_tag_hi_sel = params->rx_src_tag_hi_sel;
2584 req.rx_src_tag_lo_sel = params->rx_src_tag_lo_sel;
2585 req.rx_dest_tag_hi_sel = params->rx_dest_tag_hi_sel;
2586 req.rx_dest_tag_lo_sel = params->rx_dest_tag_lo_sel;
2587 req.rx_fdq0_sz0_qnum = params->rx_fdq0_sz0_qnum;
2588 req.rx_fdq1_qnum = params->rx_fdq1_qnum;
2589 req.rx_fdq2_qnum = params->rx_fdq2_qnum;
2590 req.rx_fdq3_qnum = params->rx_fdq3_qnum;
2591 req.rx_ps_location = params->rx_ps_location;
2593 ret = ti_sci_do_xfer(info, xfer);
2595 dev_err(info->dev, "RX_FL_CFG: Mbox send fail %d\n", ret);
2600 (struct ti_sci_msg_rm_udmap_flow_cfg_resp *)xfer->tx_message.buf;
2601 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2604 dev_dbg(info->dev, "RX_FL_CFG: %u ret:%d\n", params->flow_index, ret);
2609 * ti_sci_cmd_set_fwl_region() - Request for configuring a firewall region
2610 * @handle: pointer to TI SCI handle
2611 * @region: region configuration parameters
2613 * Return: 0 if all went well, else returns appropriate error value.
2615 static int ti_sci_cmd_set_fwl_region(const struct ti_sci_handle *handle,
2616 const struct ti_sci_msg_fwl_region *region)
2618 struct ti_sci_msg_fwl_set_firewall_region_req req;
2619 struct ti_sci_msg_hdr *resp;
2620 struct ti_sci_info *info;
2621 struct ti_sci_xfer *xfer;
2625 return PTR_ERR(handle);
2629 info = handle_to_ti_sci_info(handle);
2631 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_FWL_SET,
2632 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2633 (u32 *)&req, sizeof(req), sizeof(*resp));
2635 ret = PTR_ERR(xfer);
2636 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2640 req.fwl_id = region->fwl_id;
2641 req.region = region->region;
2642 req.n_permission_regs = region->n_permission_regs;
2643 req.control = region->control;
2644 req.permissions[0] = region->permissions[0];
2645 req.permissions[1] = region->permissions[1];
2646 req.permissions[2] = region->permissions[2];
2647 req.start_address = region->start_address;
2648 req.end_address = region->end_address;
2650 ret = ti_sci_do_xfer(info, xfer);
2652 dev_err(info->dev, "Mbox send fail %d\n", ret);
2656 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2658 if (!ti_sci_is_response_ack(resp))
2665 * ti_sci_cmd_get_fwl_region() - Request for getting a firewall region
2666 * @handle: pointer to TI SCI handle
2667 * @region: region configuration parameters
2669 * Return: 0 if all went well, else returns appropriate error value.
2671 static int ti_sci_cmd_get_fwl_region(const struct ti_sci_handle *handle,
2672 struct ti_sci_msg_fwl_region *region)
2674 struct ti_sci_msg_fwl_get_firewall_region_req req;
2675 struct ti_sci_msg_fwl_get_firewall_region_resp *resp;
2676 struct ti_sci_info *info;
2677 struct ti_sci_xfer *xfer;
2681 return PTR_ERR(handle);
2685 info = handle_to_ti_sci_info(handle);
2687 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_FWL_GET,
2688 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2689 (u32 *)&req, sizeof(req), sizeof(*resp));
2691 ret = PTR_ERR(xfer);
2692 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2696 req.fwl_id = region->fwl_id;
2697 req.region = region->region;
2698 req.n_permission_regs = region->n_permission_regs;
2700 ret = ti_sci_do_xfer(info, xfer);
2702 dev_err(info->dev, "Mbox send fail %d\n", ret);
2706 resp = (struct ti_sci_msg_fwl_get_firewall_region_resp *)xfer->tx_message.buf;
2708 if (!ti_sci_is_response_ack(resp))
2711 region->fwl_id = resp->fwl_id;
2712 region->region = resp->region;
2713 region->n_permission_regs = resp->n_permission_regs;
2714 region->control = resp->control;
2715 region->permissions[0] = resp->permissions[0];
2716 region->permissions[1] = resp->permissions[1];
2717 region->permissions[2] = resp->permissions[2];
2718 region->start_address = resp->start_address;
2719 region->end_address = resp->end_address;
2725 * ti_sci_cmd_change_fwl_owner() - Request for changing a firewall owner
2726 * @handle: pointer to TI SCI handle
2727 * @region: region configuration parameters
2729 * Return: 0 if all went well, else returns appropriate error value.
2731 static int ti_sci_cmd_change_fwl_owner(const struct ti_sci_handle *handle,
2732 struct ti_sci_msg_fwl_owner *owner)
2734 struct ti_sci_msg_fwl_change_owner_info_req req;
2735 struct ti_sci_msg_fwl_change_owner_info_resp *resp;
2736 struct ti_sci_info *info;
2737 struct ti_sci_xfer *xfer;
2741 return PTR_ERR(handle);
2745 info = handle_to_ti_sci_info(handle);
2747 xfer = ti_sci_setup_one_xfer(info, TISCI_MSG_FWL_CHANGE_OWNER,
2748 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2749 (u32 *)&req, sizeof(req), sizeof(*resp));
2751 ret = PTR_ERR(xfer);
2752 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
2756 req.fwl_id = owner->fwl_id;
2757 req.region = owner->region;
2758 req.owner_index = owner->owner_index;
2760 ret = ti_sci_do_xfer(info, xfer);
2762 dev_err(info->dev, "Mbox send fail %d\n", ret);
2766 resp = (struct ti_sci_msg_fwl_change_owner_info_resp *)xfer->tx_message.buf;
2768 if (!ti_sci_is_response_ack(resp))
2771 owner->fwl_id = resp->fwl_id;
2772 owner->region = resp->region;
2773 owner->owner_index = resp->owner_index;
2774 owner->owner_privid = resp->owner_privid;
2775 owner->owner_permission_bits = resp->owner_permission_bits;
2781 * ti_sci_setup_ops() - Setup the operations structures
2782 * @info: pointer to TISCI pointer
2784 static void ti_sci_setup_ops(struct ti_sci_info *info)
2786 struct ti_sci_ops *ops = &info->handle.ops;
2787 struct ti_sci_board_ops *bops = &ops->board_ops;
2788 struct ti_sci_dev_ops *dops = &ops->dev_ops;
2789 struct ti_sci_clk_ops *cops = &ops->clk_ops;
2790 struct ti_sci_core_ops *core_ops = &ops->core_ops;
2791 struct ti_sci_rm_core_ops *rm_core_ops = &ops->rm_core_ops;
2792 struct ti_sci_proc_ops *pops = &ops->proc_ops;
2793 struct ti_sci_rm_ringacc_ops *rops = &ops->rm_ring_ops;
2794 struct ti_sci_rm_psil_ops *psilops = &ops->rm_psil_ops;
2795 struct ti_sci_rm_udmap_ops *udmap_ops = &ops->rm_udmap_ops;
2796 struct ti_sci_fwl_ops *fwl_ops = &ops->fwl_ops;
2798 bops->board_config = ti_sci_cmd_set_board_config;
2799 bops->board_config_rm = ti_sci_cmd_set_board_config_rm;
2800 bops->board_config_security = ti_sci_cmd_set_board_config_security;
2801 bops->board_config_pm = ti_sci_cmd_set_board_config_pm;
2803 dops->get_device = ti_sci_cmd_get_device;
2804 dops->get_device_exclusive = ti_sci_cmd_get_device_exclusive;
2805 dops->idle_device = ti_sci_cmd_idle_device;
2806 dops->idle_device_exclusive = ti_sci_cmd_idle_device_exclusive;
2807 dops->put_device = ti_sci_cmd_put_device;
2808 dops->is_valid = ti_sci_cmd_dev_is_valid;
2809 dops->get_context_loss_count = ti_sci_cmd_dev_get_clcnt;
2810 dops->is_idle = ti_sci_cmd_dev_is_idle;
2811 dops->is_stop = ti_sci_cmd_dev_is_stop;
2812 dops->is_on = ti_sci_cmd_dev_is_on;
2813 dops->is_transitioning = ti_sci_cmd_dev_is_trans;
2814 dops->set_device_resets = ti_sci_cmd_set_device_resets;
2815 dops->get_device_resets = ti_sci_cmd_get_device_resets;
2816 dops->release_exclusive_devices = ti_sci_cmd_release_exclusive_devices;
2818 cops->get_clock = ti_sci_cmd_get_clock;
2819 cops->idle_clock = ti_sci_cmd_idle_clock;
2820 cops->put_clock = ti_sci_cmd_put_clock;
2821 cops->is_auto = ti_sci_cmd_clk_is_auto;
2822 cops->is_on = ti_sci_cmd_clk_is_on;
2823 cops->is_off = ti_sci_cmd_clk_is_off;
2825 cops->set_parent = ti_sci_cmd_clk_set_parent;
2826 cops->get_parent = ti_sci_cmd_clk_get_parent;
2827 cops->get_num_parents = ti_sci_cmd_clk_get_num_parents;
2829 cops->get_best_match_freq = ti_sci_cmd_clk_get_match_freq;
2830 cops->set_freq = ti_sci_cmd_clk_set_freq;
2831 cops->get_freq = ti_sci_cmd_clk_get_freq;
2833 core_ops->reboot_device = ti_sci_cmd_core_reboot;
2834 core_ops->query_msmc = ti_sci_cmd_query_msmc;
2836 rm_core_ops->get_range = ti_sci_cmd_get_resource_range;
2837 rm_core_ops->get_range_from_shost =
2838 ti_sci_cmd_get_resource_range_from_shost;
2840 pops->proc_request = ti_sci_cmd_proc_request;
2841 pops->proc_release = ti_sci_cmd_proc_release;
2842 pops->proc_handover = ti_sci_cmd_proc_handover;
2843 pops->set_proc_boot_cfg = ti_sci_cmd_set_proc_boot_cfg;
2844 pops->set_proc_boot_ctrl = ti_sci_cmd_set_proc_boot_ctrl;
2845 pops->proc_auth_boot_image = ti_sci_cmd_proc_auth_boot_image;
2846 pops->get_proc_boot_status = ti_sci_cmd_get_proc_boot_status;
2847 pops->proc_shutdown_no_wait = ti_sci_cmd_proc_shutdown_no_wait;
2849 rops->config = ti_sci_cmd_ring_config;
2851 psilops->pair = ti_sci_cmd_rm_psil_pair;
2852 psilops->unpair = ti_sci_cmd_rm_psil_unpair;
2854 udmap_ops->tx_ch_cfg = ti_sci_cmd_rm_udmap_tx_ch_cfg;
2855 udmap_ops->rx_ch_cfg = ti_sci_cmd_rm_udmap_rx_ch_cfg;
2856 udmap_ops->rx_flow_cfg = ti_sci_cmd_rm_udmap_rx_flow_cfg;
2858 fwl_ops->set_fwl_region = ti_sci_cmd_set_fwl_region;
2859 fwl_ops->get_fwl_region = ti_sci_cmd_get_fwl_region;
2860 fwl_ops->change_fwl_owner = ti_sci_cmd_change_fwl_owner;
2864 * ti_sci_get_handle_from_sysfw() - Get the TI SCI handle of the SYSFW
2865 * @dev: Pointer to the SYSFW device
2867 * Return: pointer to handle if successful, else EINVAL if invalid conditions
2871 struct ti_sci_handle *ti_sci_get_handle_from_sysfw(struct udevice *sci_dev)
2874 return ERR_PTR(-EINVAL);
2876 struct ti_sci_info *info = dev_get_priv(sci_dev);
2879 return ERR_PTR(-EINVAL);
2881 struct ti_sci_handle *handle = &info->handle;
2884 return ERR_PTR(-EINVAL);
2890 * ti_sci_get_handle() - Get the TI SCI handle for a device
2891 * @dev: Pointer to device for which we want SCI handle
2893 * Return: pointer to handle if successful, else EINVAL if invalid conditions
2896 const struct ti_sci_handle *ti_sci_get_handle(struct udevice *dev)
2899 return ERR_PTR(-EINVAL);
2901 struct udevice *sci_dev = dev_get_parent(dev);
2903 return ti_sci_get_handle_from_sysfw(sci_dev);
2907 * ti_sci_get_by_phandle() - Get the TI SCI handle using DT phandle
2909 * @propname: property name containing phandle on TISCI node
2911 * Return: pointer to handle if successful, else appropriate error value.
2913 const struct ti_sci_handle *ti_sci_get_by_phandle(struct udevice *dev,
2914 const char *property)
2916 struct ti_sci_info *entry, *info = NULL;
2920 err = ofnode_read_u32(dev_ofnode(dev), property, &phandle);
2922 return ERR_PTR(err);
2924 node = ofnode_get_by_phandle(phandle);
2925 if (!ofnode_valid(node))
2926 return ERR_PTR(-EINVAL);
2928 list_for_each_entry(entry, &ti_sci_list, list)
2929 if (ofnode_equal(dev_ofnode(entry->dev), node)) {
2935 return ERR_PTR(-ENODEV);
2937 return &info->handle;
2941 * ti_sci_of_to_info() - generate private data from device tree
2942 * @dev: corresponding system controller interface device
2943 * @info: pointer to driver specific private data
2945 * Return: 0 if all goes good, else appropriate error message.
2947 static int ti_sci_of_to_info(struct udevice *dev, struct ti_sci_info *info)
2951 ret = mbox_get_by_name(dev, "tx", &info->chan_tx);
2953 dev_err(dev, "%s: Acquiring Tx channel failed. ret = %d\n",
2958 ret = mbox_get_by_name(dev, "rx", &info->chan_rx);
2960 dev_err(dev, "%s: Acquiring Rx channel failed. ret = %d\n",
2965 /* Notify channel is optional. Enable only if populated */
2966 ret = mbox_get_by_name(dev, "notify", &info->chan_notify);
2968 dev_dbg(dev, "%s: Acquiring notify channel failed. ret = %d\n",
2972 info->host_id = dev_read_u32_default(dev, "ti,host-id",
2973 info->desc->default_host_id);
2975 info->is_secure = dev_read_bool(dev, "ti,secure-host");
2981 * ti_sci_probe() - Basic probe
2982 * @dev: corresponding system controller interface device
2984 * Return: 0 if all goes good, else appropriate error message.
2986 static int ti_sci_probe(struct udevice *dev)
2988 struct ti_sci_info *info;
2991 debug("%s(dev=%p)\n", __func__, dev);
2993 info = dev_get_priv(dev);
2994 info->desc = (void *)dev_get_driver_data(dev);
2996 ret = ti_sci_of_to_info(dev, info);
2998 dev_err(dev, "%s: Probe failed with error %d\n", __func__, ret);
3005 list_add_tail(&info->list, &ti_sci_list);
3006 ti_sci_setup_ops(info);
3008 ret = ti_sci_cmd_get_revision(&info->handle);
3010 INIT_LIST_HEAD(&info->dev_list);
3016 * ti_sci_get_free_resource() - Get a free resource from TISCI resource.
3017 * @res: Pointer to the TISCI resource
3019 * Return: resource num if all went ok else TI_SCI_RESOURCE_NULL.
3021 u16 ti_sci_get_free_resource(struct ti_sci_resource *res)
3025 for (set = 0; set < res->sets; set++) {
3026 free_bit = find_first_zero_bit(res->desc[set].res_map,
3027 res->desc[set].num);
3028 if (free_bit != res->desc[set].num) {
3029 set_bit(free_bit, res->desc[set].res_map);
3030 return res->desc[set].start + free_bit;
3034 return TI_SCI_RESOURCE_NULL;
3038 * ti_sci_release_resource() - Release a resource from TISCI resource.
3039 * @res: Pointer to the TISCI resource
3041 void ti_sci_release_resource(struct ti_sci_resource *res, u16 id)
3045 for (set = 0; set < res->sets; set++) {
3046 if (res->desc[set].start <= id &&
3047 (res->desc[set].num + res->desc[set].start) > id)
3048 clear_bit(id - res->desc[set].start,
3049 res->desc[set].res_map);
3054 * devm_ti_sci_get_of_resource() - Get a TISCI resource assigned to a device
3055 * @handle: TISCI handle
3056 * @dev: Device pointer to which the resource is assigned
3057 * @of_prop: property name by which the resource are represented
3059 * Note: This function expects of_prop to be in the form of tuples
3060 * <type, subtype>. Allocates and initializes ti_sci_resource structure
3061 * for each of_prop. Client driver can directly call
3062 * ti_sci_(get_free, release)_resource apis for handling the resource.
3064 * Return: Pointer to ti_sci_resource if all went well else appropriate
3067 struct ti_sci_resource *
3068 devm_ti_sci_get_of_resource(const struct ti_sci_handle *handle,
3069 struct udevice *dev, u32 dev_id, char *of_prop)
3071 u32 resource_subtype;
3072 struct ti_sci_resource *res;
3073 bool valid_set = false;
3077 res = devm_kzalloc(dev, sizeof(*res), GFP_KERNEL);
3079 return ERR_PTR(-ENOMEM);
3081 sets = dev_read_size(dev, of_prop);
3083 dev_err(dev, "%s resource type ids not available\n", of_prop);
3084 return ERR_PTR(sets);
3086 temp = malloc(sets);
3087 sets /= sizeof(u32);
3090 res->desc = devm_kcalloc(dev, res->sets, sizeof(*res->desc),
3093 return ERR_PTR(-ENOMEM);
3095 ret = dev_read_u32_array(dev, of_prop, temp, res->sets);
3097 return ERR_PTR(-EINVAL);
3099 for (i = 0; i < res->sets; i++) {
3100 resource_subtype = temp[i];
3101 ret = handle->ops.rm_core_ops.get_range(handle, dev_id,
3103 &res->desc[i].start,
3106 dev_dbg(dev, "type %d subtype %d not allocated for host %d\n",
3107 dev_id, resource_subtype,
3108 handle_to_ti_sci_info(handle)->host_id);
3109 res->desc[i].start = 0;
3110 res->desc[i].num = 0;
3115 dev_dbg(dev, "res type = %d, subtype = %d, start = %d, num = %d\n",
3116 dev_id, resource_subtype, res->desc[i].start,
3119 res->desc[i].res_map =
3120 devm_kzalloc(dev, BITS_TO_LONGS(res->desc[i].num) *
3121 sizeof(*res->desc[i].res_map), GFP_KERNEL);
3122 if (!res->desc[i].res_map)
3123 return ERR_PTR(-ENOMEM);
3129 return ERR_PTR(-EINVAL);
3132 /* Description for K2G */
3133 static const struct ti_sci_desc ti_sci_pmmc_k2g_desc = {
3134 .default_host_id = 2,
3135 /* Conservative duration */
3136 .max_rx_timeout_ms = 10000,
3137 /* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */
3142 /* Description for AM654 */
3143 static const struct ti_sci_desc ti_sci_pmmc_am654_desc = {
3144 .default_host_id = 12,
3145 /* Conservative duration */
3146 .max_rx_timeout_ms = 10000,
3147 /* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */
3152 static const struct udevice_id ti_sci_ids[] = {
3154 .compatible = "ti,k2g-sci",
3155 .data = (ulong)&ti_sci_pmmc_k2g_desc
3158 .compatible = "ti,am654-sci",
3159 .data = (ulong)&ti_sci_pmmc_am654_desc
3164 U_BOOT_DRIVER(ti_sci) = {
3166 .id = UCLASS_FIRMWARE,
3167 .of_match = ti_sci_ids,
3168 .probe = ti_sci_probe,
3169 .priv_auto_alloc_size = sizeof(struct ti_sci_info),