1 // SPDX-License-Identifier: GPL-2.0
3 * Texas Instruments System Control Interface Protocol Driver
5 * Copyright (C) 2015-2016 Texas Instruments Incorporated - https://www.ti.com/
9 #define pr_fmt(fmt) "%s: " fmt, __func__
11 #include <linux/bitmap.h>
12 #include <linux/debugfs.h>
13 #include <linux/export.h>
15 #include <linux/kernel.h>
16 #include <linux/mailbox_client.h>
17 #include <linux/module.h>
18 #include <linux/of_device.h>
19 #include <linux/semaphore.h>
20 #include <linux/slab.h>
21 #include <linux/soc/ti/ti-msgmgr.h>
22 #include <linux/soc/ti/ti_sci_protocol.h>
23 #include <linux/reboot.h>
27 /* List of all TI SCI devices active in system */
28 static LIST_HEAD(ti_sci_list);
29 /* Protection for the entire list */
30 static DEFINE_MUTEX(ti_sci_list_mutex);
33 * struct ti_sci_xfer - Structure representing a message flow
34 * @tx_message: Transmit message
35 * @rx_len: Receive message length
36 * @xfer_buf: Preallocated buffer to store receive message
37 * Since we work with request-ACK protocol, we can
38 * reuse the same buffer for the rx path as we
39 * use for the tx path.
40 * @done: completion event
43 struct ti_msgmgr_message tx_message;
46 struct completion done;
50 * struct ti_sci_xfers_info - Structure to manage transfer information
51 * @sem_xfer_count: Counting Semaphore for managing max simultaneous
53 * @xfer_block: Preallocated Message array
54 * @xfer_alloc_table: Bitmap table for allocated messages.
55 * Index of this bitmap table is also used for message
56 * sequence identifier.
57 * @xfer_lock: Protection for message allocation
59 struct ti_sci_xfers_info {
60 struct semaphore sem_xfer_count;
61 struct ti_sci_xfer *xfer_block;
62 unsigned long *xfer_alloc_table;
63 /* protect transfer allocation */
68 * struct ti_sci_desc - Description of SoC integration
69 * @default_host_id: Host identifier representing the compute entity
70 * @max_rx_timeout_ms: Timeout for communication with SoC (in Milliseconds)
71 * @max_msgs: Maximum number of messages that can be pending
72 * simultaneously in the system
73 * @max_msg_size: Maximum size of data per message that can be handled.
77 int max_rx_timeout_ms;
83 * struct ti_sci_info - Structure representing a TI SCI instance
84 * @dev: Device pointer
85 * @desc: SoC description for this instance
86 * @nb: Reboot Notifier block
87 * @d: Debugfs file entry
88 * @debug_region: Memory region where the debug message are available
89 * @debug_region_size: Debug region size
90 * @debug_buffer: Buffer allocated to copy debug messages.
91 * @handle: Instance of TI SCI handle to send to clients.
93 * @chan_tx: Transmit mailbox channel
94 * @chan_rx: Receive mailbox channel
95 * @minfo: Message info
98 * @users: Number of users of this instance
102 struct notifier_block nb;
103 const struct ti_sci_desc *desc;
105 void __iomem *debug_region;
107 size_t debug_region_size;
108 struct ti_sci_handle handle;
109 struct mbox_client cl;
110 struct mbox_chan *chan_tx;
111 struct mbox_chan *chan_rx;
112 struct ti_sci_xfers_info minfo;
113 struct list_head node;
115 /* protected by ti_sci_list_mutex */
120 #define cl_to_ti_sci_info(c) container_of(c, struct ti_sci_info, cl)
121 #define handle_to_ti_sci_info(h) container_of(h, struct ti_sci_info, handle)
122 #define reboot_to_ti_sci_info(n) container_of(n, struct ti_sci_info, nb)
124 #ifdef CONFIG_DEBUG_FS
127 * ti_sci_debug_show() - Helper to dump the debug log
128 * @s: sequence file pointer
133 static int ti_sci_debug_show(struct seq_file *s, void *unused)
135 struct ti_sci_info *info = s->private;
137 memcpy_fromio(info->debug_buffer, info->debug_region,
138 info->debug_region_size);
140 * We don't trust firmware to leave NULL terminated last byte (hence
141 * we have allocated 1 extra 0 byte). Since we cannot guarantee any
142 * specific data format for debug messages, We just present the data
143 * in the buffer as is - we expect the messages to be self explanatory.
145 seq_puts(s, info->debug_buffer);
149 /* Provide the log file operations interface*/
150 DEFINE_SHOW_ATTRIBUTE(ti_sci_debug);
153 * ti_sci_debugfs_create() - Create log debug file
154 * @pdev: platform device pointer
155 * @info: Pointer to SCI entity information
157 * Return: 0 if all went fine, else corresponding error.
159 static int ti_sci_debugfs_create(struct platform_device *pdev,
160 struct ti_sci_info *info)
162 struct device *dev = &pdev->dev;
163 struct resource *res;
164 char debug_name[50] = "ti_sci_debug@";
166 /* Debug region is optional */
167 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
169 info->debug_region = devm_ioremap_resource(dev, res);
170 if (IS_ERR(info->debug_region))
172 info->debug_region_size = resource_size(res);
174 info->debug_buffer = devm_kcalloc(dev, info->debug_region_size + 1,
175 sizeof(char), GFP_KERNEL);
176 if (!info->debug_buffer)
178 /* Setup NULL termination */
179 info->debug_buffer[info->debug_region_size] = 0;
181 info->d = debugfs_create_file(strncat(debug_name, dev_name(dev),
183 sizeof("ti_sci_debug@")),
184 0444, NULL, info, &ti_sci_debug_fops);
186 return PTR_ERR(info->d);
188 dev_dbg(dev, "Debug region => %p, size = %zu bytes, resource: %pr\n",
189 info->debug_region, info->debug_region_size, res);
194 * ti_sci_debugfs_destroy() - clean up log debug file
195 * @pdev: platform device pointer
196 * @info: Pointer to SCI entity information
198 static void ti_sci_debugfs_destroy(struct platform_device *pdev,
199 struct ti_sci_info *info)
201 if (IS_ERR(info->debug_region))
204 debugfs_remove(info->d);
206 #else /* CONFIG_DEBUG_FS */
207 static inline int ti_sci_debugfs_create(struct platform_device *dev,
208 struct ti_sci_info *info)
213 static inline void ti_sci_debugfs_destroy(struct platform_device *dev,
214 struct ti_sci_info *info)
217 #endif /* CONFIG_DEBUG_FS */
220 * ti_sci_dump_header_dbg() - Helper to dump a message header.
221 * @dev: Device pointer corresponding to the SCI entity
222 * @hdr: pointer to header.
224 static inline void ti_sci_dump_header_dbg(struct device *dev,
225 struct ti_sci_msg_hdr *hdr)
227 dev_dbg(dev, "MSGHDR:type=0x%04x host=0x%02x seq=0x%02x flags=0x%08x\n",
228 hdr->type, hdr->host, hdr->seq, hdr->flags);
232 * ti_sci_rx_callback() - mailbox client callback for receive messages
233 * @cl: client pointer
234 * @m: mailbox message
236 * Processes one received message to appropriate transfer information and
237 * signals completion of the transfer.
239 * NOTE: This function will be invoked in IRQ context, hence should be
240 * as optimal as possible.
242 static void ti_sci_rx_callback(struct mbox_client *cl, void *m)
244 struct ti_sci_info *info = cl_to_ti_sci_info(cl);
245 struct device *dev = info->dev;
246 struct ti_sci_xfers_info *minfo = &info->minfo;
247 struct ti_msgmgr_message *mbox_msg = m;
248 struct ti_sci_msg_hdr *hdr = (struct ti_sci_msg_hdr *)mbox_msg->buf;
249 struct ti_sci_xfer *xfer;
255 * Are we even expecting this?
256 * NOTE: barriers were implicit in locks used for modifying the bitmap
258 if (!test_bit(xfer_id, minfo->xfer_alloc_table)) {
259 dev_err(dev, "Message for %d is not expected!\n", xfer_id);
263 xfer = &minfo->xfer_block[xfer_id];
265 /* Is the message of valid length? */
266 if (mbox_msg->len > info->desc->max_msg_size) {
267 dev_err(dev, "Unable to handle %zu xfer(max %d)\n",
268 mbox_msg->len, info->desc->max_msg_size);
269 ti_sci_dump_header_dbg(dev, hdr);
272 if (mbox_msg->len < xfer->rx_len) {
273 dev_err(dev, "Recv xfer %zu < expected %d length\n",
274 mbox_msg->len, xfer->rx_len);
275 ti_sci_dump_header_dbg(dev, hdr);
279 ti_sci_dump_header_dbg(dev, hdr);
280 /* Take a copy to the rx buffer.. */
281 memcpy(xfer->xfer_buf, mbox_msg->buf, xfer->rx_len);
282 complete(&xfer->done);
286 * ti_sci_get_one_xfer() - Allocate one message
287 * @info: Pointer to SCI entity information
288 * @msg_type: Message type
289 * @msg_flags: Flag to set for the message
290 * @tx_message_size: transmit message size
291 * @rx_message_size: receive message size
293 * Helper function which is used by various command functions that are
294 * exposed to clients of this driver for allocating a message traffic event.
296 * This function can sleep depending on pending requests already in the system
297 * for the SCI entity. Further, this also holds a spinlock to maintain integrity
298 * of internal data structures.
300 * Return: 0 if all went fine, else corresponding error.
302 static struct ti_sci_xfer *ti_sci_get_one_xfer(struct ti_sci_info *info,
303 u16 msg_type, u32 msg_flags,
304 size_t tx_message_size,
305 size_t rx_message_size)
307 struct ti_sci_xfers_info *minfo = &info->minfo;
308 struct ti_sci_xfer *xfer;
309 struct ti_sci_msg_hdr *hdr;
311 unsigned long bit_pos;
316 /* Ensure we have sane transfer sizes */
317 if (rx_message_size > info->desc->max_msg_size ||
318 tx_message_size > info->desc->max_msg_size ||
319 rx_message_size < sizeof(*hdr) || tx_message_size < sizeof(*hdr))
320 return ERR_PTR(-ERANGE);
323 * Ensure we have only controlled number of pending messages.
324 * Ideally, we might just have to wait a single message, be
325 * conservative and wait 5 times that..
327 timeout = msecs_to_jiffies(info->desc->max_rx_timeout_ms) * 5;
328 ret = down_timeout(&minfo->sem_xfer_count, timeout);
332 /* Keep the locked section as small as possible */
333 spin_lock_irqsave(&minfo->xfer_lock, flags);
334 bit_pos = find_first_zero_bit(minfo->xfer_alloc_table,
335 info->desc->max_msgs);
336 set_bit(bit_pos, minfo->xfer_alloc_table);
337 spin_unlock_irqrestore(&minfo->xfer_lock, flags);
340 * We already ensured in probe that we can have max messages that can
341 * fit in hdr.seq - NOTE: this improves access latencies
342 * to predictable O(1) access, BUT, it opens us to risk if
343 * remote misbehaves with corrupted message sequence responses.
344 * If that happens, we are going to be messed up anyways..
346 xfer_id = (u8)bit_pos;
348 xfer = &minfo->xfer_block[xfer_id];
350 hdr = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
351 xfer->tx_message.len = tx_message_size;
352 xfer->rx_len = (u8)rx_message_size;
354 reinit_completion(&xfer->done);
357 hdr->type = msg_type;
358 hdr->host = info->host_id;
359 hdr->flags = msg_flags;
365 * ti_sci_put_one_xfer() - Release a message
366 * @minfo: transfer info pointer
367 * @xfer: message that was reserved by ti_sci_get_one_xfer
369 * This holds a spinlock to maintain integrity of internal data structures.
371 static void ti_sci_put_one_xfer(struct ti_sci_xfers_info *minfo,
372 struct ti_sci_xfer *xfer)
375 struct ti_sci_msg_hdr *hdr;
378 hdr = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
382 * Keep the locked section as small as possible
383 * NOTE: we might escape with smp_mb and no lock here..
384 * but just be conservative and symmetric.
386 spin_lock_irqsave(&minfo->xfer_lock, flags);
387 clear_bit(xfer_id, minfo->xfer_alloc_table);
388 spin_unlock_irqrestore(&minfo->xfer_lock, flags);
390 /* Increment the count for the next user to get through */
391 up(&minfo->sem_xfer_count);
395 * ti_sci_do_xfer() - Do one transfer
396 * @info: Pointer to SCI entity information
397 * @xfer: Transfer to initiate and wait for response
399 * Return: -ETIMEDOUT in case of no response, if transmit error,
400 * return corresponding error, else if all goes well,
403 static inline int ti_sci_do_xfer(struct ti_sci_info *info,
404 struct ti_sci_xfer *xfer)
408 struct device *dev = info->dev;
410 ret = mbox_send_message(info->chan_tx, &xfer->tx_message);
416 /* And we wait for the response. */
417 timeout = msecs_to_jiffies(info->desc->max_rx_timeout_ms);
418 if (!wait_for_completion_timeout(&xfer->done, timeout)) {
419 dev_err(dev, "Mbox timedout in resp(caller: %pS)\n",
424 * NOTE: we might prefer not to need the mailbox ticker to manage the
425 * transfer queueing since the protocol layer queues things by itself.
426 * Unfortunately, we have to kick the mailbox framework after we have
427 * received our message.
429 mbox_client_txdone(info->chan_tx, ret);
435 * ti_sci_cmd_get_revision() - command to get the revision of the SCI entity
436 * @info: Pointer to SCI entity information
438 * Updates the SCI information in the internal data structure.
440 * Return: 0 if all went fine, else return appropriate error.
442 static int ti_sci_cmd_get_revision(struct ti_sci_info *info)
444 struct device *dev = info->dev;
445 struct ti_sci_handle *handle = &info->handle;
446 struct ti_sci_version_info *ver = &handle->version;
447 struct ti_sci_msg_resp_version *rev_info;
448 struct ti_sci_xfer *xfer;
451 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_VERSION,
452 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
453 sizeof(struct ti_sci_msg_hdr),
457 dev_err(dev, "Message alloc failed(%d)\n", ret);
461 rev_info = (struct ti_sci_msg_resp_version *)xfer->xfer_buf;
463 ret = ti_sci_do_xfer(info, xfer);
465 dev_err(dev, "Mbox send fail %d\n", ret);
469 ver->abi_major = rev_info->abi_major;
470 ver->abi_minor = rev_info->abi_minor;
471 ver->firmware_revision = rev_info->firmware_revision;
472 strncpy(ver->firmware_description, rev_info->firmware_description,
473 sizeof(ver->firmware_description));
476 ti_sci_put_one_xfer(&info->minfo, xfer);
481 * ti_sci_is_response_ack() - Generic ACK/NACK message checkup
482 * @r: pointer to response buffer
484 * Return: true if the response was an ACK, else returns false.
486 static inline bool ti_sci_is_response_ack(void *r)
488 struct ti_sci_msg_hdr *hdr = r;
490 return hdr->flags & TI_SCI_FLAG_RESP_GENERIC_ACK ? true : false;
494 * ti_sci_set_device_state() - Set device state helper
495 * @handle: pointer to TI SCI handle
496 * @id: Device identifier
497 * @flags: flags to setup for the device
498 * @state: State to move the device to
500 * Return: 0 if all went well, else returns appropriate error value.
502 static int ti_sci_set_device_state(const struct ti_sci_handle *handle,
503 u32 id, u32 flags, u8 state)
505 struct ti_sci_info *info;
506 struct ti_sci_msg_req_set_device_state *req;
507 struct ti_sci_msg_hdr *resp;
508 struct ti_sci_xfer *xfer;
513 return PTR_ERR(handle);
517 info = handle_to_ti_sci_info(handle);
520 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_DEVICE_STATE,
521 flags | TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
522 sizeof(*req), sizeof(*resp));
525 dev_err(dev, "Message alloc failed(%d)\n", ret);
528 req = (struct ti_sci_msg_req_set_device_state *)xfer->xfer_buf;
532 ret = ti_sci_do_xfer(info, xfer);
534 dev_err(dev, "Mbox send fail %d\n", ret);
538 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
540 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
543 ti_sci_put_one_xfer(&info->minfo, xfer);
549 * ti_sci_get_device_state() - Get device state helper
550 * @handle: Handle to the device
551 * @id: Device Identifier
552 * @clcnt: Pointer to Context Loss Count
553 * @resets: pointer to resets
554 * @p_state: pointer to p_state
555 * @c_state: pointer to c_state
557 * Return: 0 if all went fine, else return appropriate error.
559 static int ti_sci_get_device_state(const struct ti_sci_handle *handle,
560 u32 id, u32 *clcnt, u32 *resets,
561 u8 *p_state, u8 *c_state)
563 struct ti_sci_info *info;
564 struct ti_sci_msg_req_get_device_state *req;
565 struct ti_sci_msg_resp_get_device_state *resp;
566 struct ti_sci_xfer *xfer;
571 return PTR_ERR(handle);
575 if (!clcnt && !resets && !p_state && !c_state)
578 info = handle_to_ti_sci_info(handle);
581 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_DEVICE_STATE,
582 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
583 sizeof(*req), sizeof(*resp));
586 dev_err(dev, "Message alloc failed(%d)\n", ret);
589 req = (struct ti_sci_msg_req_get_device_state *)xfer->xfer_buf;
592 ret = ti_sci_do_xfer(info, xfer);
594 dev_err(dev, "Mbox send fail %d\n", ret);
598 resp = (struct ti_sci_msg_resp_get_device_state *)xfer->xfer_buf;
599 if (!ti_sci_is_response_ack(resp)) {
605 *clcnt = resp->context_loss_count;
607 *resets = resp->resets;
609 *p_state = resp->programmed_state;
611 *c_state = resp->current_state;
613 ti_sci_put_one_xfer(&info->minfo, xfer);
619 * ti_sci_cmd_get_device() - command to request for device managed by TISCI
620 * that can be shared with other hosts.
621 * @handle: Pointer to TISCI handle as retrieved by *ti_sci_get_handle
622 * @id: Device Identifier
624 * Request for the device - NOTE: the client MUST maintain integrity of
625 * usage count by balancing get_device with put_device. No refcounting is
626 * managed by driver for that purpose.
628 * Return: 0 if all went fine, else return appropriate error.
630 static int ti_sci_cmd_get_device(const struct ti_sci_handle *handle, u32 id)
632 return ti_sci_set_device_state(handle, id, 0,
633 MSG_DEVICE_SW_STATE_ON);
637 * ti_sci_cmd_get_device_exclusive() - command to request for device managed by
638 * TISCI that is exclusively owned by the
640 * @handle: Pointer to TISCI handle as retrieved by *ti_sci_get_handle
641 * @id: Device Identifier
643 * Request for the device - NOTE: the client MUST maintain integrity of
644 * usage count by balancing get_device with put_device. No refcounting is
645 * managed by driver for that purpose.
647 * Return: 0 if all went fine, else return appropriate error.
649 static int ti_sci_cmd_get_device_exclusive(const struct ti_sci_handle *handle,
652 return ti_sci_set_device_state(handle, id,
653 MSG_FLAG_DEVICE_EXCLUSIVE,
654 MSG_DEVICE_SW_STATE_ON);
658 * ti_sci_cmd_idle_device() - Command to idle a device managed by TISCI
659 * @handle: Pointer to TISCI handle as retrieved by *ti_sci_get_handle
660 * @id: Device Identifier
662 * Request for the device - NOTE: the client MUST maintain integrity of
663 * usage count by balancing get_device with put_device. No refcounting is
664 * managed by driver for that purpose.
666 * Return: 0 if all went fine, else return appropriate error.
668 static int ti_sci_cmd_idle_device(const struct ti_sci_handle *handle, u32 id)
670 return ti_sci_set_device_state(handle, id, 0,
671 MSG_DEVICE_SW_STATE_RETENTION);
675 * ti_sci_cmd_idle_device_exclusive() - Command to idle a device managed by
676 * TISCI that is exclusively owned by
678 * @handle: Pointer to TISCI handle as retrieved by *ti_sci_get_handle
679 * @id: Device Identifier
681 * Request for the device - NOTE: the client MUST maintain integrity of
682 * usage count by balancing get_device with put_device. No refcounting is
683 * managed by driver for that purpose.
685 * Return: 0 if all went fine, else return appropriate error.
687 static int ti_sci_cmd_idle_device_exclusive(const struct ti_sci_handle *handle,
690 return ti_sci_set_device_state(handle, id,
691 MSG_FLAG_DEVICE_EXCLUSIVE,
692 MSG_DEVICE_SW_STATE_RETENTION);
696 * ti_sci_cmd_put_device() - command to release a device managed by TISCI
697 * @handle: Pointer to TISCI handle as retrieved by *ti_sci_get_handle
698 * @id: Device Identifier
700 * Request for the device - NOTE: the client MUST maintain integrity of
701 * usage count by balancing get_device with put_device. No refcounting is
702 * managed by driver for that purpose.
704 * Return: 0 if all went fine, else return appropriate error.
706 static int ti_sci_cmd_put_device(const struct ti_sci_handle *handle, u32 id)
708 return ti_sci_set_device_state(handle, id,
709 0, MSG_DEVICE_SW_STATE_AUTO_OFF);
713 * ti_sci_cmd_dev_is_valid() - Is the device valid
714 * @handle: Pointer to TISCI handle as retrieved by *ti_sci_get_handle
715 * @id: Device Identifier
717 * Return: 0 if all went fine and the device ID is valid, else return
720 static int ti_sci_cmd_dev_is_valid(const struct ti_sci_handle *handle, u32 id)
724 /* check the device state which will also tell us if the ID is valid */
725 return ti_sci_get_device_state(handle, id, NULL, NULL, NULL, &unused);
729 * ti_sci_cmd_dev_get_clcnt() - Get context loss counter
730 * @handle: Pointer to TISCI handle
731 * @id: Device Identifier
732 * @count: Pointer to Context Loss counter to populate
734 * Return: 0 if all went fine, else return appropriate error.
736 static int ti_sci_cmd_dev_get_clcnt(const struct ti_sci_handle *handle, u32 id,
739 return ti_sci_get_device_state(handle, id, count, NULL, NULL, NULL);
743 * ti_sci_cmd_dev_is_idle() - Check if the device is requested to be idle
744 * @handle: Pointer to TISCI handle
745 * @id: Device Identifier
746 * @r_state: true if requested to be idle
748 * Return: 0 if all went fine, else return appropriate error.
750 static int ti_sci_cmd_dev_is_idle(const struct ti_sci_handle *handle, u32 id,
759 ret = ti_sci_get_device_state(handle, id, NULL, NULL, &state, NULL);
763 *r_state = (state == MSG_DEVICE_SW_STATE_RETENTION);
769 * ti_sci_cmd_dev_is_stop() - Check if the device is requested to be stopped
770 * @handle: Pointer to TISCI handle
771 * @id: Device Identifier
772 * @r_state: true if requested to be stopped
773 * @curr_state: true if currently stopped.
775 * Return: 0 if all went fine, else return appropriate error.
777 static int ti_sci_cmd_dev_is_stop(const struct ti_sci_handle *handle, u32 id,
778 bool *r_state, bool *curr_state)
783 if (!r_state && !curr_state)
787 ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);
792 *r_state = (p_state == MSG_DEVICE_SW_STATE_AUTO_OFF);
794 *curr_state = (c_state == MSG_DEVICE_HW_STATE_OFF);
800 * ti_sci_cmd_dev_is_on() - Check if the device is requested to be ON
801 * @handle: Pointer to TISCI handle
802 * @id: Device Identifier
803 * @r_state: true if requested to be ON
804 * @curr_state: true if currently ON and active
806 * Return: 0 if all went fine, else return appropriate error.
808 static int ti_sci_cmd_dev_is_on(const struct ti_sci_handle *handle, u32 id,
809 bool *r_state, bool *curr_state)
814 if (!r_state && !curr_state)
818 ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);
823 *r_state = (p_state == MSG_DEVICE_SW_STATE_ON);
825 *curr_state = (c_state == MSG_DEVICE_HW_STATE_ON);
831 * ti_sci_cmd_dev_is_trans() - Check if the device is currently transitioning
832 * @handle: Pointer to TISCI handle
833 * @id: Device Identifier
834 * @curr_state: true if currently transitioning.
836 * Return: 0 if all went fine, else return appropriate error.
838 static int ti_sci_cmd_dev_is_trans(const struct ti_sci_handle *handle, u32 id,
847 ret = ti_sci_get_device_state(handle, id, NULL, NULL, NULL, &state);
851 *curr_state = (state == MSG_DEVICE_HW_STATE_TRANS);
857 * ti_sci_cmd_set_device_resets() - command to set resets for device managed
859 * @handle: Pointer to TISCI handle as retrieved by *ti_sci_get_handle
860 * @id: Device Identifier
861 * @reset_state: Device specific reset bit field
863 * Return: 0 if all went fine, else return appropriate error.
865 static int ti_sci_cmd_set_device_resets(const struct ti_sci_handle *handle,
866 u32 id, u32 reset_state)
868 struct ti_sci_info *info;
869 struct ti_sci_msg_req_set_device_resets *req;
870 struct ti_sci_msg_hdr *resp;
871 struct ti_sci_xfer *xfer;
876 return PTR_ERR(handle);
880 info = handle_to_ti_sci_info(handle);
883 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_DEVICE_RESETS,
884 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
885 sizeof(*req), sizeof(*resp));
888 dev_err(dev, "Message alloc failed(%d)\n", ret);
891 req = (struct ti_sci_msg_req_set_device_resets *)xfer->xfer_buf;
893 req->resets = reset_state;
895 ret = ti_sci_do_xfer(info, xfer);
897 dev_err(dev, "Mbox send fail %d\n", ret);
901 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
903 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
906 ti_sci_put_one_xfer(&info->minfo, xfer);
912 * ti_sci_cmd_get_device_resets() - Get reset state for device managed
914 * @handle: Pointer to TISCI handle
915 * @id: Device Identifier
916 * @reset_state: Pointer to reset state to populate
918 * Return: 0 if all went fine, else return appropriate error.
920 static int ti_sci_cmd_get_device_resets(const struct ti_sci_handle *handle,
921 u32 id, u32 *reset_state)
923 return ti_sci_get_device_state(handle, id, NULL, reset_state, NULL,
928 * ti_sci_set_clock_state() - Set clock state helper
929 * @handle: pointer to TI SCI handle
930 * @dev_id: Device identifier this request is for
931 * @clk_id: Clock identifier for the device for this request.
932 * Each device has it's own set of clock inputs. This indexes
933 * which clock input to modify.
934 * @flags: Header flags as needed
935 * @state: State to request for the clock.
937 * Return: 0 if all went well, else returns appropriate error value.
939 static int ti_sci_set_clock_state(const struct ti_sci_handle *handle,
940 u32 dev_id, u32 clk_id,
943 struct ti_sci_info *info;
944 struct ti_sci_msg_req_set_clock_state *req;
945 struct ti_sci_msg_hdr *resp;
946 struct ti_sci_xfer *xfer;
951 return PTR_ERR(handle);
955 info = handle_to_ti_sci_info(handle);
958 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CLOCK_STATE,
959 flags | TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
960 sizeof(*req), sizeof(*resp));
963 dev_err(dev, "Message alloc failed(%d)\n", ret);
966 req = (struct ti_sci_msg_req_set_clock_state *)xfer->xfer_buf;
967 req->dev_id = dev_id;
969 req->clk_id = clk_id;
972 req->clk_id_32 = clk_id;
974 req->request_state = state;
976 ret = ti_sci_do_xfer(info, xfer);
978 dev_err(dev, "Mbox send fail %d\n", ret);
982 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
984 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
987 ti_sci_put_one_xfer(&info->minfo, xfer);
993 * ti_sci_cmd_get_clock_state() - Get clock state helper
994 * @handle: pointer to TI SCI handle
995 * @dev_id: Device identifier this request is for
996 * @clk_id: Clock identifier for the device for this request.
997 * Each device has it's own set of clock inputs. This indexes
998 * which clock input to modify.
999 * @programmed_state: State requested for clock to move to
1000 * @current_state: State that the clock is currently in
1002 * Return: 0 if all went well, else returns appropriate error value.
1004 static int ti_sci_cmd_get_clock_state(const struct ti_sci_handle *handle,
1005 u32 dev_id, u32 clk_id,
1006 u8 *programmed_state, u8 *current_state)
1008 struct ti_sci_info *info;
1009 struct ti_sci_msg_req_get_clock_state *req;
1010 struct ti_sci_msg_resp_get_clock_state *resp;
1011 struct ti_sci_xfer *xfer;
1016 return PTR_ERR(handle);
1020 if (!programmed_state && !current_state)
1023 info = handle_to_ti_sci_info(handle);
1026 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_CLOCK_STATE,
1027 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1028 sizeof(*req), sizeof(*resp));
1030 ret = PTR_ERR(xfer);
1031 dev_err(dev, "Message alloc failed(%d)\n", ret);
1034 req = (struct ti_sci_msg_req_get_clock_state *)xfer->xfer_buf;
1035 req->dev_id = dev_id;
1037 req->clk_id = clk_id;
1040 req->clk_id_32 = clk_id;
1043 ret = ti_sci_do_xfer(info, xfer);
1045 dev_err(dev, "Mbox send fail %d\n", ret);
1049 resp = (struct ti_sci_msg_resp_get_clock_state *)xfer->xfer_buf;
1051 if (!ti_sci_is_response_ack(resp)) {
1056 if (programmed_state)
1057 *programmed_state = resp->programmed_state;
1059 *current_state = resp->current_state;
1062 ti_sci_put_one_xfer(&info->minfo, xfer);
1068 * ti_sci_cmd_get_clock() - Get control of a clock from TI SCI
1069 * @handle: pointer to TI SCI handle
1070 * @dev_id: Device identifier this request is for
1071 * @clk_id: Clock identifier for the device for this request.
1072 * Each device has it's own set of clock inputs. This indexes
1073 * which clock input to modify.
1074 * @needs_ssc: 'true' if Spread Spectrum clock is desired, else 'false'
1075 * @can_change_freq: 'true' if frequency change is desired, else 'false'
1076 * @enable_input_term: 'true' if input termination is desired, else 'false'
1078 * Return: 0 if all went well, else returns appropriate error value.
1080 static int ti_sci_cmd_get_clock(const struct ti_sci_handle *handle, u32 dev_id,
1081 u32 clk_id, bool needs_ssc,
1082 bool can_change_freq, bool enable_input_term)
1086 flags |= needs_ssc ? MSG_FLAG_CLOCK_ALLOW_SSC : 0;
1087 flags |= can_change_freq ? MSG_FLAG_CLOCK_ALLOW_FREQ_CHANGE : 0;
1088 flags |= enable_input_term ? MSG_FLAG_CLOCK_INPUT_TERM : 0;
1090 return ti_sci_set_clock_state(handle, dev_id, clk_id, flags,
1091 MSG_CLOCK_SW_STATE_REQ);
1095 * ti_sci_cmd_idle_clock() - Idle a clock which is in our control
1096 * @handle: pointer to TI SCI handle
1097 * @dev_id: Device identifier this request is for
1098 * @clk_id: Clock identifier for the device for this request.
1099 * Each device has it's own set of clock inputs. This indexes
1100 * which clock input to modify.
1102 * NOTE: This clock must have been requested by get_clock previously.
1104 * Return: 0 if all went well, else returns appropriate error value.
1106 static int ti_sci_cmd_idle_clock(const struct ti_sci_handle *handle,
1107 u32 dev_id, u32 clk_id)
1109 return ti_sci_set_clock_state(handle, dev_id, clk_id, 0,
1110 MSG_CLOCK_SW_STATE_UNREQ);
1114 * ti_sci_cmd_put_clock() - Release a clock from our control back to TISCI
1115 * @handle: pointer to TI SCI handle
1116 * @dev_id: Device identifier this request is for
1117 * @clk_id: Clock identifier for the device for this request.
1118 * Each device has it's own set of clock inputs. This indexes
1119 * which clock input to modify.
1121 * NOTE: This clock must have been requested by get_clock previously.
1123 * Return: 0 if all went well, else returns appropriate error value.
1125 static int ti_sci_cmd_put_clock(const struct ti_sci_handle *handle,
1126 u32 dev_id, u32 clk_id)
1128 return ti_sci_set_clock_state(handle, dev_id, clk_id, 0,
1129 MSG_CLOCK_SW_STATE_AUTO);
1133 * ti_sci_cmd_clk_is_auto() - Is the clock being auto managed
1134 * @handle: pointer to TI SCI handle
1135 * @dev_id: Device identifier this request is for
1136 * @clk_id: Clock identifier for the device for this request.
1137 * Each device has it's own set of clock inputs. This indexes
1138 * which clock input to modify.
1139 * @req_state: state indicating if the clock is auto managed
1141 * Return: 0 if all went well, else returns appropriate error value.
1143 static int ti_sci_cmd_clk_is_auto(const struct ti_sci_handle *handle,
1144 u32 dev_id, u32 clk_id, bool *req_state)
1152 ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id, &state, NULL);
1156 *req_state = (state == MSG_CLOCK_SW_STATE_AUTO);
1161 * ti_sci_cmd_clk_is_on() - Is the clock ON
1162 * @handle: pointer to TI SCI handle
1163 * @dev_id: Device identifier this request is for
1164 * @clk_id: Clock identifier for the device for this request.
1165 * Each device has it's own set of clock inputs. This indexes
1166 * which clock input to modify.
1167 * @req_state: state indicating if the clock is managed by us and enabled
1168 * @curr_state: state indicating if the clock is ready for operation
1170 * Return: 0 if all went well, else returns appropriate error value.
1172 static int ti_sci_cmd_clk_is_on(const struct ti_sci_handle *handle, u32 dev_id,
1173 u32 clk_id, bool *req_state, bool *curr_state)
1175 u8 c_state = 0, r_state = 0;
1178 if (!req_state && !curr_state)
1181 ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,
1182 &r_state, &c_state);
1187 *req_state = (r_state == MSG_CLOCK_SW_STATE_REQ);
1189 *curr_state = (c_state == MSG_CLOCK_HW_STATE_READY);
1194 * ti_sci_cmd_clk_is_off() - Is the clock OFF
1195 * @handle: pointer to TI SCI handle
1196 * @dev_id: Device identifier this request is for
1197 * @clk_id: Clock identifier for the device for this request.
1198 * Each device has it's own set of clock inputs. This indexes
1199 * which clock input to modify.
1200 * @req_state: state indicating if the clock is managed by us and disabled
1201 * @curr_state: state indicating if the clock is NOT ready for operation
1203 * Return: 0 if all went well, else returns appropriate error value.
1205 static int ti_sci_cmd_clk_is_off(const struct ti_sci_handle *handle, u32 dev_id,
1206 u32 clk_id, bool *req_state, bool *curr_state)
1208 u8 c_state = 0, r_state = 0;
1211 if (!req_state && !curr_state)
1214 ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,
1215 &r_state, &c_state);
1220 *req_state = (r_state == MSG_CLOCK_SW_STATE_UNREQ);
1222 *curr_state = (c_state == MSG_CLOCK_HW_STATE_NOT_READY);
1227 * ti_sci_cmd_clk_set_parent() - Set the clock source of a specific device clock
1228 * @handle: pointer to TI SCI handle
1229 * @dev_id: Device identifier this request is for
1230 * @clk_id: Clock identifier for the device for this request.
1231 * Each device has it's own set of clock inputs. This indexes
1232 * which clock input to modify.
1233 * @parent_id: Parent clock identifier to set
1235 * Return: 0 if all went well, else returns appropriate error value.
1237 static int ti_sci_cmd_clk_set_parent(const struct ti_sci_handle *handle,
1238 u32 dev_id, u32 clk_id, u32 parent_id)
1240 struct ti_sci_info *info;
1241 struct ti_sci_msg_req_set_clock_parent *req;
1242 struct ti_sci_msg_hdr *resp;
1243 struct ti_sci_xfer *xfer;
1248 return PTR_ERR(handle);
1252 info = handle_to_ti_sci_info(handle);
1255 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CLOCK_PARENT,
1256 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1257 sizeof(*req), sizeof(*resp));
1259 ret = PTR_ERR(xfer);
1260 dev_err(dev, "Message alloc failed(%d)\n", ret);
1263 req = (struct ti_sci_msg_req_set_clock_parent *)xfer->xfer_buf;
1264 req->dev_id = dev_id;
1266 req->clk_id = clk_id;
1269 req->clk_id_32 = clk_id;
1271 if (parent_id < 255) {
1272 req->parent_id = parent_id;
1274 req->parent_id = 255;
1275 req->parent_id_32 = parent_id;
1278 ret = ti_sci_do_xfer(info, xfer);
1280 dev_err(dev, "Mbox send fail %d\n", ret);
1284 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
1286 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
1289 ti_sci_put_one_xfer(&info->minfo, xfer);
1295 * ti_sci_cmd_clk_get_parent() - Get current parent clock source
1296 * @handle: pointer to TI SCI handle
1297 * @dev_id: Device identifier this request is for
1298 * @clk_id: Clock identifier for the device for this request.
1299 * Each device has it's own set of clock inputs. This indexes
1300 * which clock input to modify.
1301 * @parent_id: Current clock parent
1303 * Return: 0 if all went well, else returns appropriate error value.
1305 static int ti_sci_cmd_clk_get_parent(const struct ti_sci_handle *handle,
1306 u32 dev_id, u32 clk_id, u32 *parent_id)
1308 struct ti_sci_info *info;
1309 struct ti_sci_msg_req_get_clock_parent *req;
1310 struct ti_sci_msg_resp_get_clock_parent *resp;
1311 struct ti_sci_xfer *xfer;
1316 return PTR_ERR(handle);
1317 if (!handle || !parent_id)
1320 info = handle_to_ti_sci_info(handle);
1323 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_CLOCK_PARENT,
1324 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1325 sizeof(*req), sizeof(*resp));
1327 ret = PTR_ERR(xfer);
1328 dev_err(dev, "Message alloc failed(%d)\n", ret);
1331 req = (struct ti_sci_msg_req_get_clock_parent *)xfer->xfer_buf;
1332 req->dev_id = dev_id;
1334 req->clk_id = clk_id;
1337 req->clk_id_32 = clk_id;
1340 ret = ti_sci_do_xfer(info, xfer);
1342 dev_err(dev, "Mbox send fail %d\n", ret);
1346 resp = (struct ti_sci_msg_resp_get_clock_parent *)xfer->xfer_buf;
1348 if (!ti_sci_is_response_ack(resp)) {
1351 if (resp->parent_id < 255)
1352 *parent_id = resp->parent_id;
1354 *parent_id = resp->parent_id_32;
1358 ti_sci_put_one_xfer(&info->minfo, xfer);
1364 * ti_sci_cmd_clk_get_num_parents() - Get num parents of the current clk source
1365 * @handle: pointer to TI SCI handle
1366 * @dev_id: Device identifier this request is for
1367 * @clk_id: Clock identifier for the device for this request.
1368 * Each device has it's own set of clock inputs. This indexes
1369 * which clock input to modify.
1370 * @num_parents: Returns he number of parents to the current clock.
1372 * Return: 0 if all went well, else returns appropriate error value.
1374 static int ti_sci_cmd_clk_get_num_parents(const struct ti_sci_handle *handle,
1375 u32 dev_id, u32 clk_id,
1378 struct ti_sci_info *info;
1379 struct ti_sci_msg_req_get_clock_num_parents *req;
1380 struct ti_sci_msg_resp_get_clock_num_parents *resp;
1381 struct ti_sci_xfer *xfer;
1386 return PTR_ERR(handle);
1387 if (!handle || !num_parents)
1390 info = handle_to_ti_sci_info(handle);
1393 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_NUM_CLOCK_PARENTS,
1394 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1395 sizeof(*req), sizeof(*resp));
1397 ret = PTR_ERR(xfer);
1398 dev_err(dev, "Message alloc failed(%d)\n", ret);
1401 req = (struct ti_sci_msg_req_get_clock_num_parents *)xfer->xfer_buf;
1402 req->dev_id = dev_id;
1404 req->clk_id = clk_id;
1407 req->clk_id_32 = clk_id;
1410 ret = ti_sci_do_xfer(info, xfer);
1412 dev_err(dev, "Mbox send fail %d\n", ret);
1416 resp = (struct ti_sci_msg_resp_get_clock_num_parents *)xfer->xfer_buf;
1418 if (!ti_sci_is_response_ack(resp)) {
1421 if (resp->num_parents < 255)
1422 *num_parents = resp->num_parents;
1424 *num_parents = resp->num_parents_32;
1428 ti_sci_put_one_xfer(&info->minfo, xfer);
1434 * ti_sci_cmd_clk_get_match_freq() - Find a good match for frequency
1435 * @handle: pointer to TI SCI handle
1436 * @dev_id: Device identifier this request is for
1437 * @clk_id: Clock identifier for the device for this request.
1438 * Each device has it's own set of clock inputs. This indexes
1439 * which clock input to modify.
1440 * @min_freq: The minimum allowable frequency in Hz. This is the minimum
1441 * allowable programmed frequency and does not account for clock
1442 * tolerances and jitter.
1443 * @target_freq: The target clock frequency in Hz. A frequency will be
1444 * processed as close to this target frequency as possible.
1445 * @max_freq: The maximum allowable frequency in Hz. This is the maximum
1446 * allowable programmed frequency and does not account for clock
1447 * tolerances and jitter.
1448 * @match_freq: Frequency match in Hz response.
1450 * Return: 0 if all went well, else returns appropriate error value.
1452 static int ti_sci_cmd_clk_get_match_freq(const struct ti_sci_handle *handle,
1453 u32 dev_id, u32 clk_id, u64 min_freq,
1454 u64 target_freq, u64 max_freq,
1457 struct ti_sci_info *info;
1458 struct ti_sci_msg_req_query_clock_freq *req;
1459 struct ti_sci_msg_resp_query_clock_freq *resp;
1460 struct ti_sci_xfer *xfer;
1465 return PTR_ERR(handle);
1466 if (!handle || !match_freq)
1469 info = handle_to_ti_sci_info(handle);
1472 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_QUERY_CLOCK_FREQ,
1473 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1474 sizeof(*req), sizeof(*resp));
1476 ret = PTR_ERR(xfer);
1477 dev_err(dev, "Message alloc failed(%d)\n", ret);
1480 req = (struct ti_sci_msg_req_query_clock_freq *)xfer->xfer_buf;
1481 req->dev_id = dev_id;
1483 req->clk_id = clk_id;
1486 req->clk_id_32 = clk_id;
1488 req->min_freq_hz = min_freq;
1489 req->target_freq_hz = target_freq;
1490 req->max_freq_hz = max_freq;
1492 ret = ti_sci_do_xfer(info, xfer);
1494 dev_err(dev, "Mbox send fail %d\n", ret);
1498 resp = (struct ti_sci_msg_resp_query_clock_freq *)xfer->xfer_buf;
1500 if (!ti_sci_is_response_ack(resp))
1503 *match_freq = resp->freq_hz;
1506 ti_sci_put_one_xfer(&info->minfo, xfer);
1512 * ti_sci_cmd_clk_set_freq() - Set a frequency for clock
1513 * @handle: pointer to TI SCI handle
1514 * @dev_id: Device identifier this request is for
1515 * @clk_id: Clock identifier for the device for this request.
1516 * Each device has it's own set of clock inputs. This indexes
1517 * which clock input to modify.
1518 * @min_freq: The minimum allowable frequency in Hz. This is the minimum
1519 * allowable programmed frequency and does not account for clock
1520 * tolerances and jitter.
1521 * @target_freq: The target clock frequency in Hz. A frequency will be
1522 * processed as close to this target frequency as possible.
1523 * @max_freq: The maximum allowable frequency in Hz. This is the maximum
1524 * allowable programmed frequency and does not account for clock
1525 * tolerances and jitter.
1527 * Return: 0 if all went well, else returns appropriate error value.
1529 static int ti_sci_cmd_clk_set_freq(const struct ti_sci_handle *handle,
1530 u32 dev_id, u32 clk_id, u64 min_freq,
1531 u64 target_freq, u64 max_freq)
1533 struct ti_sci_info *info;
1534 struct ti_sci_msg_req_set_clock_freq *req;
1535 struct ti_sci_msg_hdr *resp;
1536 struct ti_sci_xfer *xfer;
1541 return PTR_ERR(handle);
1545 info = handle_to_ti_sci_info(handle);
1548 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CLOCK_FREQ,
1549 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1550 sizeof(*req), sizeof(*resp));
1552 ret = PTR_ERR(xfer);
1553 dev_err(dev, "Message alloc failed(%d)\n", ret);
1556 req = (struct ti_sci_msg_req_set_clock_freq *)xfer->xfer_buf;
1557 req->dev_id = dev_id;
1559 req->clk_id = clk_id;
1562 req->clk_id_32 = clk_id;
1564 req->min_freq_hz = min_freq;
1565 req->target_freq_hz = target_freq;
1566 req->max_freq_hz = max_freq;
1568 ret = ti_sci_do_xfer(info, xfer);
1570 dev_err(dev, "Mbox send fail %d\n", ret);
1574 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
1576 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
1579 ti_sci_put_one_xfer(&info->minfo, xfer);
1585 * ti_sci_cmd_clk_get_freq() - Get current frequency
1586 * @handle: pointer to TI SCI handle
1587 * @dev_id: Device identifier this request is for
1588 * @clk_id: Clock identifier for the device for this request.
1589 * Each device has it's own set of clock inputs. This indexes
1590 * which clock input to modify.
1591 * @freq: Currently frequency in Hz
1593 * Return: 0 if all went well, else returns appropriate error value.
1595 static int ti_sci_cmd_clk_get_freq(const struct ti_sci_handle *handle,
1596 u32 dev_id, u32 clk_id, u64 *freq)
1598 struct ti_sci_info *info;
1599 struct ti_sci_msg_req_get_clock_freq *req;
1600 struct ti_sci_msg_resp_get_clock_freq *resp;
1601 struct ti_sci_xfer *xfer;
1606 return PTR_ERR(handle);
1607 if (!handle || !freq)
1610 info = handle_to_ti_sci_info(handle);
1613 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_CLOCK_FREQ,
1614 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1615 sizeof(*req), sizeof(*resp));
1617 ret = PTR_ERR(xfer);
1618 dev_err(dev, "Message alloc failed(%d)\n", ret);
1621 req = (struct ti_sci_msg_req_get_clock_freq *)xfer->xfer_buf;
1622 req->dev_id = dev_id;
1624 req->clk_id = clk_id;
1627 req->clk_id_32 = clk_id;
1630 ret = ti_sci_do_xfer(info, xfer);
1632 dev_err(dev, "Mbox send fail %d\n", ret);
1636 resp = (struct ti_sci_msg_resp_get_clock_freq *)xfer->xfer_buf;
1638 if (!ti_sci_is_response_ack(resp))
1641 *freq = resp->freq_hz;
1644 ti_sci_put_one_xfer(&info->minfo, xfer);
1649 static int ti_sci_cmd_core_reboot(const struct ti_sci_handle *handle)
1651 struct ti_sci_info *info;
1652 struct ti_sci_msg_req_reboot *req;
1653 struct ti_sci_msg_hdr *resp;
1654 struct ti_sci_xfer *xfer;
1659 return PTR_ERR(handle);
1663 info = handle_to_ti_sci_info(handle);
1666 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SYS_RESET,
1667 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1668 sizeof(*req), sizeof(*resp));
1670 ret = PTR_ERR(xfer);
1671 dev_err(dev, "Message alloc failed(%d)\n", ret);
1674 req = (struct ti_sci_msg_req_reboot *)xfer->xfer_buf;
1676 ret = ti_sci_do_xfer(info, xfer);
1678 dev_err(dev, "Mbox send fail %d\n", ret);
1682 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
1684 if (!ti_sci_is_response_ack(resp))
1690 ti_sci_put_one_xfer(&info->minfo, xfer);
1696 * ti_sci_get_resource_range - Helper to get a range of resources assigned
1697 * to a host. Resource is uniquely identified by
1699 * @handle: Pointer to TISCI handle.
1700 * @dev_id: TISCI device ID.
1701 * @subtype: Resource assignment subtype that is being requested
1702 * from the given device.
1703 * @s_host: Host processor ID to which the resources are allocated
1704 * @range_start: Start index of the resource range
1705 * @range_num: Number of resources in the range
1707 * Return: 0 if all went fine, else return appropriate error.
1709 static int ti_sci_get_resource_range(const struct ti_sci_handle *handle,
1710 u32 dev_id, u8 subtype, u8 s_host,
1711 u16 *range_start, u16 *range_num)
1713 struct ti_sci_msg_resp_get_resource_range *resp;
1714 struct ti_sci_msg_req_get_resource_range *req;
1715 struct ti_sci_xfer *xfer;
1716 struct ti_sci_info *info;
1721 return PTR_ERR(handle);
1725 info = handle_to_ti_sci_info(handle);
1728 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_RESOURCE_RANGE,
1729 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1730 sizeof(*req), sizeof(*resp));
1732 ret = PTR_ERR(xfer);
1733 dev_err(dev, "Message alloc failed(%d)\n", ret);
1737 req = (struct ti_sci_msg_req_get_resource_range *)xfer->xfer_buf;
1738 req->secondary_host = s_host;
1739 req->type = dev_id & MSG_RM_RESOURCE_TYPE_MASK;
1740 req->subtype = subtype & MSG_RM_RESOURCE_SUBTYPE_MASK;
1742 ret = ti_sci_do_xfer(info, xfer);
1744 dev_err(dev, "Mbox send fail %d\n", ret);
1748 resp = (struct ti_sci_msg_resp_get_resource_range *)xfer->xfer_buf;
1750 if (!ti_sci_is_response_ack(resp)) {
1752 } else if (!resp->range_start && !resp->range_num) {
1755 *range_start = resp->range_start;
1756 *range_num = resp->range_num;
1760 ti_sci_put_one_xfer(&info->minfo, xfer);
1766 * ti_sci_cmd_get_resource_range - Get a range of resources assigned to host
1767 * that is same as ti sci interface host.
1768 * @handle: Pointer to TISCI handle.
1769 * @dev_id: TISCI device ID.
1770 * @subtype: Resource assignment subtype that is being requested
1771 * from the given device.
1772 * @range_start: Start index of the resource range
1773 * @range_num: Number of resources in the range
1775 * Return: 0 if all went fine, else return appropriate error.
1777 static int ti_sci_cmd_get_resource_range(const struct ti_sci_handle *handle,
1778 u32 dev_id, u8 subtype,
1779 u16 *range_start, u16 *range_num)
1781 return ti_sci_get_resource_range(handle, dev_id, subtype,
1782 TI_SCI_IRQ_SECONDARY_HOST_INVALID,
1783 range_start, range_num);
1787 * ti_sci_cmd_get_resource_range_from_shost - Get a range of resources
1788 * assigned to a specified host.
1789 * @handle: Pointer to TISCI handle.
1790 * @dev_id: TISCI device ID.
1791 * @subtype: Resource assignment subtype that is being requested
1792 * from the given device.
1793 * @s_host: Host processor ID to which the resources are allocated
1794 * @range_start: Start index of the resource range
1795 * @range_num: Number of resources in the range
1797 * Return: 0 if all went fine, else return appropriate error.
1800 int ti_sci_cmd_get_resource_range_from_shost(const struct ti_sci_handle *handle,
1801 u32 dev_id, u8 subtype, u8 s_host,
1802 u16 *range_start, u16 *range_num)
1804 return ti_sci_get_resource_range(handle, dev_id, subtype, s_host,
1805 range_start, range_num);
1809 * ti_sci_manage_irq() - Helper api to configure/release the irq route between
1810 * the requested source and destination
1811 * @handle: Pointer to TISCI handle.
1812 * @valid_params: Bit fields defining the validity of certain params
1813 * @src_id: Device ID of the IRQ source
1814 * @src_index: IRQ source index within the source device
1815 * @dst_id: Device ID of the IRQ destination
1816 * @dst_host_irq: IRQ number of the destination device
1817 * @ia_id: Device ID of the IA, if the IRQ flows through this IA
1818 * @vint: Virtual interrupt to be used within the IA
1819 * @global_event: Global event number to be used for the requesting event
1820 * @vint_status_bit: Virtual interrupt status bit to be used for the event
1821 * @s_host: Secondary host ID to which the irq/event is being
1823 * @type: Request type irq set or release.
1825 * Return: 0 if all went fine, else return appropriate error.
1827 static int ti_sci_manage_irq(const struct ti_sci_handle *handle,
1828 u32 valid_params, u16 src_id, u16 src_index,
1829 u16 dst_id, u16 dst_host_irq, u16 ia_id, u16 vint,
1830 u16 global_event, u8 vint_status_bit, u8 s_host,
1833 struct ti_sci_msg_req_manage_irq *req;
1834 struct ti_sci_msg_hdr *resp;
1835 struct ti_sci_xfer *xfer;
1836 struct ti_sci_info *info;
1841 return PTR_ERR(handle);
1845 info = handle_to_ti_sci_info(handle);
1848 xfer = ti_sci_get_one_xfer(info, type, TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
1849 sizeof(*req), sizeof(*resp));
1851 ret = PTR_ERR(xfer);
1852 dev_err(dev, "Message alloc failed(%d)\n", ret);
1855 req = (struct ti_sci_msg_req_manage_irq *)xfer->xfer_buf;
1856 req->valid_params = valid_params;
1857 req->src_id = src_id;
1858 req->src_index = src_index;
1859 req->dst_id = dst_id;
1860 req->dst_host_irq = dst_host_irq;
1863 req->global_event = global_event;
1864 req->vint_status_bit = vint_status_bit;
1865 req->secondary_host = s_host;
1867 ret = ti_sci_do_xfer(info, xfer);
1869 dev_err(dev, "Mbox send fail %d\n", ret);
1873 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
1875 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
1878 ti_sci_put_one_xfer(&info->minfo, xfer);
1884 * ti_sci_set_irq() - Helper api to configure the irq route between the
1885 * requested source and destination
1886 * @handle: Pointer to TISCI handle.
1887 * @valid_params: Bit fields defining the validity of certain params
1888 * @src_id: Device ID of the IRQ source
1889 * @src_index: IRQ source index within the source device
1890 * @dst_id: Device ID of the IRQ destination
1891 * @dst_host_irq: IRQ number of the destination device
1892 * @ia_id: Device ID of the IA, if the IRQ flows through this IA
1893 * @vint: Virtual interrupt to be used within the IA
1894 * @global_event: Global event number to be used for the requesting event
1895 * @vint_status_bit: Virtual interrupt status bit to be used for the event
1896 * @s_host: Secondary host ID to which the irq/event is being
1899 * Return: 0 if all went fine, else return appropriate error.
1901 static int ti_sci_set_irq(const struct ti_sci_handle *handle, u32 valid_params,
1902 u16 src_id, u16 src_index, u16 dst_id,
1903 u16 dst_host_irq, u16 ia_id, u16 vint,
1904 u16 global_event, u8 vint_status_bit, u8 s_host)
1906 pr_debug("%s: IRQ set with valid_params = 0x%x from src = %d, index = %d, to dst = %d, irq = %d,via ia_id = %d, vint = %d, global event = %d,status_bit = %d\n",
1907 __func__, valid_params, src_id, src_index,
1908 dst_id, dst_host_irq, ia_id, vint, global_event,
1911 return ti_sci_manage_irq(handle, valid_params, src_id, src_index,
1912 dst_id, dst_host_irq, ia_id, vint,
1913 global_event, vint_status_bit, s_host,
1914 TI_SCI_MSG_SET_IRQ);
1918 * ti_sci_free_irq() - Helper api to free the irq route between the
1919 * requested source and destination
1920 * @handle: Pointer to TISCI handle.
1921 * @valid_params: Bit fields defining the validity of certain params
1922 * @src_id: Device ID of the IRQ source
1923 * @src_index: IRQ source index within the source device
1924 * @dst_id: Device ID of the IRQ destination
1925 * @dst_host_irq: IRQ number of the destination device
1926 * @ia_id: Device ID of the IA, if the IRQ flows through this IA
1927 * @vint: Virtual interrupt to be used within the IA
1928 * @global_event: Global event number to be used for the requesting event
1929 * @vint_status_bit: Virtual interrupt status bit to be used for the event
1930 * @s_host: Secondary host ID to which the irq/event is being
1933 * Return: 0 if all went fine, else return appropriate error.
1935 static int ti_sci_free_irq(const struct ti_sci_handle *handle, u32 valid_params,
1936 u16 src_id, u16 src_index, u16 dst_id,
1937 u16 dst_host_irq, u16 ia_id, u16 vint,
1938 u16 global_event, u8 vint_status_bit, u8 s_host)
1940 pr_debug("%s: IRQ release with valid_params = 0x%x from src = %d, index = %d, to dst = %d, irq = %d,via ia_id = %d, vint = %d, global event = %d,status_bit = %d\n",
1941 __func__, valid_params, src_id, src_index,
1942 dst_id, dst_host_irq, ia_id, vint, global_event,
1945 return ti_sci_manage_irq(handle, valid_params, src_id, src_index,
1946 dst_id, dst_host_irq, ia_id, vint,
1947 global_event, vint_status_bit, s_host,
1948 TI_SCI_MSG_FREE_IRQ);
1952 * ti_sci_cmd_set_irq() - Configure a host irq route between the requested
1953 * source and destination.
1954 * @handle: Pointer to TISCI handle.
1955 * @src_id: Device ID of the IRQ source
1956 * @src_index: IRQ source index within the source device
1957 * @dst_id: Device ID of the IRQ destination
1958 * @dst_host_irq: IRQ number of the destination device
1959 * @vint_irq: Boolean specifying if this interrupt belongs to
1960 * Interrupt Aggregator.
1962 * Return: 0 if all went fine, else return appropriate error.
1964 static int ti_sci_cmd_set_irq(const struct ti_sci_handle *handle, u16 src_id,
1965 u16 src_index, u16 dst_id, u16 dst_host_irq)
1967 u32 valid_params = MSG_FLAG_DST_ID_VALID | MSG_FLAG_DST_HOST_IRQ_VALID;
1969 return ti_sci_set_irq(handle, valid_params, src_id, src_index, dst_id,
1970 dst_host_irq, 0, 0, 0, 0, 0);
1974 * ti_sci_cmd_set_event_map() - Configure an event based irq route between the
1975 * requested source and Interrupt Aggregator.
1976 * @handle: Pointer to TISCI handle.
1977 * @src_id: Device ID of the IRQ source
1978 * @src_index: IRQ source index within the source device
1979 * @ia_id: Device ID of the IA, if the IRQ flows through this IA
1980 * @vint: Virtual interrupt to be used within the IA
1981 * @global_event: Global event number to be used for the requesting event
1982 * @vint_status_bit: Virtual interrupt status bit to be used for the event
1984 * Return: 0 if all went fine, else return appropriate error.
1986 static int ti_sci_cmd_set_event_map(const struct ti_sci_handle *handle,
1987 u16 src_id, u16 src_index, u16 ia_id,
1988 u16 vint, u16 global_event,
1991 u32 valid_params = MSG_FLAG_IA_ID_VALID | MSG_FLAG_VINT_VALID |
1992 MSG_FLAG_GLB_EVNT_VALID |
1993 MSG_FLAG_VINT_STS_BIT_VALID;
1995 return ti_sci_set_irq(handle, valid_params, src_id, src_index, 0, 0,
1996 ia_id, vint, global_event, vint_status_bit, 0);
2000 * ti_sci_cmd_free_irq() - Free a host irq route between the between the
2001 * requested source and destination.
2002 * @handle: Pointer to TISCI handle.
2003 * @src_id: Device ID of the IRQ source
2004 * @src_index: IRQ source index within the source device
2005 * @dst_id: Device ID of the IRQ destination
2006 * @dst_host_irq: IRQ number of the destination device
2007 * @vint_irq: Boolean specifying if this interrupt belongs to
2008 * Interrupt Aggregator.
2010 * Return: 0 if all went fine, else return appropriate error.
2012 static int ti_sci_cmd_free_irq(const struct ti_sci_handle *handle, u16 src_id,
2013 u16 src_index, u16 dst_id, u16 dst_host_irq)
2015 u32 valid_params = MSG_FLAG_DST_ID_VALID | MSG_FLAG_DST_HOST_IRQ_VALID;
2017 return ti_sci_free_irq(handle, valid_params, src_id, src_index, dst_id,
2018 dst_host_irq, 0, 0, 0, 0, 0);
2022 * ti_sci_cmd_free_event_map() - Free an event map between the requested source
2023 * and Interrupt Aggregator.
2024 * @handle: Pointer to TISCI handle.
2025 * @src_id: Device ID of the IRQ source
2026 * @src_index: IRQ source index within the source device
2027 * @ia_id: Device ID of the IA, if the IRQ flows through this IA
2028 * @vint: Virtual interrupt to be used within the IA
2029 * @global_event: Global event number to be used for the requesting event
2030 * @vint_status_bit: Virtual interrupt status bit to be used for the event
2032 * Return: 0 if all went fine, else return appropriate error.
2034 static int ti_sci_cmd_free_event_map(const struct ti_sci_handle *handle,
2035 u16 src_id, u16 src_index, u16 ia_id,
2036 u16 vint, u16 global_event,
2039 u32 valid_params = MSG_FLAG_IA_ID_VALID |
2040 MSG_FLAG_VINT_VALID | MSG_FLAG_GLB_EVNT_VALID |
2041 MSG_FLAG_VINT_STS_BIT_VALID;
2043 return ti_sci_free_irq(handle, valid_params, src_id, src_index, 0, 0,
2044 ia_id, vint, global_event, vint_status_bit, 0);
2048 * ti_sci_cmd_ring_config() - configure RA ring
2049 * @handle: Pointer to TI SCI handle.
2050 * @valid_params: Bitfield defining validity of ring configuration
2052 * @nav_id: Device ID of Navigator Subsystem from which the ring is
2054 * @index: Ring index
2055 * @addr_lo: The ring base address lo 32 bits
2056 * @addr_hi: The ring base address hi 32 bits
2057 * @count: Number of ring elements
2058 * @mode: The mode of the ring
2059 * @size: The ring element size.
2060 * @order_id: Specifies the ring's bus order ID
2062 * Return: 0 if all went well, else returns appropriate error value.
2064 * See @ti_sci_msg_rm_ring_cfg_req for more info.
2066 static int ti_sci_cmd_ring_config(const struct ti_sci_handle *handle,
2067 u32 valid_params, u16 nav_id, u16 index,
2068 u32 addr_lo, u32 addr_hi, u32 count,
2069 u8 mode, u8 size, u8 order_id)
2071 struct ti_sci_msg_rm_ring_cfg_req *req;
2072 struct ti_sci_msg_hdr *resp;
2073 struct ti_sci_xfer *xfer;
2074 struct ti_sci_info *info;
2078 if (IS_ERR_OR_NULL(handle))
2081 info = handle_to_ti_sci_info(handle);
2084 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_RM_RING_CFG,
2085 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2086 sizeof(*req), sizeof(*resp));
2088 ret = PTR_ERR(xfer);
2089 dev_err(dev, "RM_RA:Message config failed(%d)\n", ret);
2092 req = (struct ti_sci_msg_rm_ring_cfg_req *)xfer->xfer_buf;
2093 req->valid_params = valid_params;
2094 req->nav_id = nav_id;
2096 req->addr_lo = addr_lo;
2097 req->addr_hi = addr_hi;
2101 req->order_id = order_id;
2103 ret = ti_sci_do_xfer(info, xfer);
2105 dev_err(dev, "RM_RA:Mbox config send fail %d\n", ret);
2109 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
2110 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2113 ti_sci_put_one_xfer(&info->minfo, xfer);
2114 dev_dbg(dev, "RM_RA:config ring %u ret:%d\n", index, ret);
2119 * ti_sci_cmd_ring_get_config() - get RA ring configuration
2120 * @handle: Pointer to TI SCI handle.
2121 * @nav_id: Device ID of Navigator Subsystem from which the ring is
2123 * @index: Ring index
2124 * @addr_lo: Returns ring's base address lo 32 bits
2125 * @addr_hi: Returns ring's base address hi 32 bits
2126 * @count: Returns number of ring elements
2127 * @mode: Returns mode of the ring
2128 * @size: Returns ring element size
2129 * @order_id: Returns ring's bus order ID
2131 * Return: 0 if all went well, else returns appropriate error value.
2133 * See @ti_sci_msg_rm_ring_get_cfg_req for more info.
2135 static int ti_sci_cmd_ring_get_config(const struct ti_sci_handle *handle,
2136 u32 nav_id, u32 index, u8 *mode,
2137 u32 *addr_lo, u32 *addr_hi,
2138 u32 *count, u8 *size, u8 *order_id)
2140 struct ti_sci_msg_rm_ring_get_cfg_resp *resp;
2141 struct ti_sci_msg_rm_ring_get_cfg_req *req;
2142 struct ti_sci_xfer *xfer;
2143 struct ti_sci_info *info;
2147 if (IS_ERR_OR_NULL(handle))
2150 info = handle_to_ti_sci_info(handle);
2153 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_RM_RING_GET_CFG,
2154 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2155 sizeof(*req), sizeof(*resp));
2157 ret = PTR_ERR(xfer);
2159 "RM_RA:Message get config failed(%d)\n", ret);
2162 req = (struct ti_sci_msg_rm_ring_get_cfg_req *)xfer->xfer_buf;
2163 req->nav_id = nav_id;
2166 ret = ti_sci_do_xfer(info, xfer);
2168 dev_err(dev, "RM_RA:Mbox get config send fail %d\n", ret);
2172 resp = (struct ti_sci_msg_rm_ring_get_cfg_resp *)xfer->xfer_buf;
2174 if (!ti_sci_is_response_ack(resp)) {
2180 *addr_lo = resp->addr_lo;
2182 *addr_hi = resp->addr_hi;
2184 *count = resp->count;
2188 *order_id = resp->order_id;
2192 ti_sci_put_one_xfer(&info->minfo, xfer);
2193 dev_dbg(dev, "RM_RA:get config ring %u ret:%d\n", index, ret);
2198 * ti_sci_cmd_rm_psil_pair() - Pair PSI-L source to destination thread
2199 * @handle: Pointer to TI SCI handle.
2200 * @nav_id: Device ID of Navigator Subsystem which should be used for
2202 * @src_thread: Source PSI-L thread ID
2203 * @dst_thread: Destination PSI-L thread ID
2205 * Return: 0 if all went well, else returns appropriate error value.
2207 static int ti_sci_cmd_rm_psil_pair(const struct ti_sci_handle *handle,
2208 u32 nav_id, u32 src_thread, u32 dst_thread)
2210 struct ti_sci_msg_psil_pair *req;
2211 struct ti_sci_msg_hdr *resp;
2212 struct ti_sci_xfer *xfer;
2213 struct ti_sci_info *info;
2218 return PTR_ERR(handle);
2222 info = handle_to_ti_sci_info(handle);
2225 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_RM_PSIL_PAIR,
2226 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2227 sizeof(*req), sizeof(*resp));
2229 ret = PTR_ERR(xfer);
2230 dev_err(dev, "RM_PSIL:Message reconfig failed(%d)\n", ret);
2233 req = (struct ti_sci_msg_psil_pair *)xfer->xfer_buf;
2234 req->nav_id = nav_id;
2235 req->src_thread = src_thread;
2236 req->dst_thread = dst_thread;
2238 ret = ti_sci_do_xfer(info, xfer);
2240 dev_err(dev, "RM_PSIL:Mbox send fail %d\n", ret);
2244 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
2245 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2248 ti_sci_put_one_xfer(&info->minfo, xfer);
2254 * ti_sci_cmd_rm_psil_unpair() - Unpair PSI-L source from destination thread
2255 * @handle: Pointer to TI SCI handle.
2256 * @nav_id: Device ID of Navigator Subsystem which should be used for
2258 * @src_thread: Source PSI-L thread ID
2259 * @dst_thread: Destination PSI-L thread ID
2261 * Return: 0 if all went well, else returns appropriate error value.
2263 static int ti_sci_cmd_rm_psil_unpair(const struct ti_sci_handle *handle,
2264 u32 nav_id, u32 src_thread, u32 dst_thread)
2266 struct ti_sci_msg_psil_unpair *req;
2267 struct ti_sci_msg_hdr *resp;
2268 struct ti_sci_xfer *xfer;
2269 struct ti_sci_info *info;
2274 return PTR_ERR(handle);
2278 info = handle_to_ti_sci_info(handle);
2281 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_RM_PSIL_UNPAIR,
2282 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2283 sizeof(*req), sizeof(*resp));
2285 ret = PTR_ERR(xfer);
2286 dev_err(dev, "RM_PSIL:Message reconfig failed(%d)\n", ret);
2289 req = (struct ti_sci_msg_psil_unpair *)xfer->xfer_buf;
2290 req->nav_id = nav_id;
2291 req->src_thread = src_thread;
2292 req->dst_thread = dst_thread;
2294 ret = ti_sci_do_xfer(info, xfer);
2296 dev_err(dev, "RM_PSIL:Mbox send fail %d\n", ret);
2300 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
2301 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2304 ti_sci_put_one_xfer(&info->minfo, xfer);
2310 * ti_sci_cmd_rm_udmap_tx_ch_cfg() - Configure a UDMAP TX channel
2311 * @handle: Pointer to TI SCI handle.
2312 * @params: Pointer to ti_sci_msg_rm_udmap_tx_ch_cfg TX channel config
2315 * Return: 0 if all went well, else returns appropriate error value.
2317 * See @ti_sci_msg_rm_udmap_tx_ch_cfg and @ti_sci_msg_rm_udmap_tx_ch_cfg_req for
2320 static int ti_sci_cmd_rm_udmap_tx_ch_cfg(const struct ti_sci_handle *handle,
2321 const struct ti_sci_msg_rm_udmap_tx_ch_cfg *params)
2323 struct ti_sci_msg_rm_udmap_tx_ch_cfg_req *req;
2324 struct ti_sci_msg_hdr *resp;
2325 struct ti_sci_xfer *xfer;
2326 struct ti_sci_info *info;
2330 if (IS_ERR_OR_NULL(handle))
2333 info = handle_to_ti_sci_info(handle);
2336 xfer = ti_sci_get_one_xfer(info, TISCI_MSG_RM_UDMAP_TX_CH_CFG,
2337 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2338 sizeof(*req), sizeof(*resp));
2340 ret = PTR_ERR(xfer);
2341 dev_err(dev, "Message TX_CH_CFG alloc failed(%d)\n", ret);
2344 req = (struct ti_sci_msg_rm_udmap_tx_ch_cfg_req *)xfer->xfer_buf;
2345 req->valid_params = params->valid_params;
2346 req->nav_id = params->nav_id;
2347 req->index = params->index;
2348 req->tx_pause_on_err = params->tx_pause_on_err;
2349 req->tx_filt_einfo = params->tx_filt_einfo;
2350 req->tx_filt_pswords = params->tx_filt_pswords;
2351 req->tx_atype = params->tx_atype;
2352 req->tx_chan_type = params->tx_chan_type;
2353 req->tx_supr_tdpkt = params->tx_supr_tdpkt;
2354 req->tx_fetch_size = params->tx_fetch_size;
2355 req->tx_credit_count = params->tx_credit_count;
2356 req->txcq_qnum = params->txcq_qnum;
2357 req->tx_priority = params->tx_priority;
2358 req->tx_qos = params->tx_qos;
2359 req->tx_orderid = params->tx_orderid;
2360 req->fdepth = params->fdepth;
2361 req->tx_sched_priority = params->tx_sched_priority;
2362 req->tx_burst_size = params->tx_burst_size;
2364 ret = ti_sci_do_xfer(info, xfer);
2366 dev_err(dev, "Mbox send TX_CH_CFG fail %d\n", ret);
2370 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
2371 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2374 ti_sci_put_one_xfer(&info->minfo, xfer);
2375 dev_dbg(dev, "TX_CH_CFG: chn %u ret:%u\n", params->index, ret);
2380 * ti_sci_cmd_rm_udmap_rx_ch_cfg() - Configure a UDMAP RX channel
2381 * @handle: Pointer to TI SCI handle.
2382 * @params: Pointer to ti_sci_msg_rm_udmap_rx_ch_cfg RX channel config
2385 * Return: 0 if all went well, else returns appropriate error value.
2387 * See @ti_sci_msg_rm_udmap_rx_ch_cfg and @ti_sci_msg_rm_udmap_rx_ch_cfg_req for
2390 static int ti_sci_cmd_rm_udmap_rx_ch_cfg(const struct ti_sci_handle *handle,
2391 const struct ti_sci_msg_rm_udmap_rx_ch_cfg *params)
2393 struct ti_sci_msg_rm_udmap_rx_ch_cfg_req *req;
2394 struct ti_sci_msg_hdr *resp;
2395 struct ti_sci_xfer *xfer;
2396 struct ti_sci_info *info;
2400 if (IS_ERR_OR_NULL(handle))
2403 info = handle_to_ti_sci_info(handle);
2406 xfer = ti_sci_get_one_xfer(info, TISCI_MSG_RM_UDMAP_RX_CH_CFG,
2407 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2408 sizeof(*req), sizeof(*resp));
2410 ret = PTR_ERR(xfer);
2411 dev_err(dev, "Message RX_CH_CFG alloc failed(%d)\n", ret);
2414 req = (struct ti_sci_msg_rm_udmap_rx_ch_cfg_req *)xfer->xfer_buf;
2415 req->valid_params = params->valid_params;
2416 req->nav_id = params->nav_id;
2417 req->index = params->index;
2418 req->rx_fetch_size = params->rx_fetch_size;
2419 req->rxcq_qnum = params->rxcq_qnum;
2420 req->rx_priority = params->rx_priority;
2421 req->rx_qos = params->rx_qos;
2422 req->rx_orderid = params->rx_orderid;
2423 req->rx_sched_priority = params->rx_sched_priority;
2424 req->flowid_start = params->flowid_start;
2425 req->flowid_cnt = params->flowid_cnt;
2426 req->rx_pause_on_err = params->rx_pause_on_err;
2427 req->rx_atype = params->rx_atype;
2428 req->rx_chan_type = params->rx_chan_type;
2429 req->rx_ignore_short = params->rx_ignore_short;
2430 req->rx_ignore_long = params->rx_ignore_long;
2431 req->rx_burst_size = params->rx_burst_size;
2433 ret = ti_sci_do_xfer(info, xfer);
2435 dev_err(dev, "Mbox send RX_CH_CFG fail %d\n", ret);
2439 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
2440 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2443 ti_sci_put_one_xfer(&info->minfo, xfer);
2444 dev_dbg(dev, "RX_CH_CFG: chn %u ret:%d\n", params->index, ret);
2449 * ti_sci_cmd_rm_udmap_rx_flow_cfg() - Configure UDMAP RX FLOW
2450 * @handle: Pointer to TI SCI handle.
2451 * @params: Pointer to ti_sci_msg_rm_udmap_flow_cfg RX FLOW config
2454 * Return: 0 if all went well, else returns appropriate error value.
2456 * See @ti_sci_msg_rm_udmap_flow_cfg and @ti_sci_msg_rm_udmap_flow_cfg_req for
2459 static int ti_sci_cmd_rm_udmap_rx_flow_cfg(const struct ti_sci_handle *handle,
2460 const struct ti_sci_msg_rm_udmap_flow_cfg *params)
2462 struct ti_sci_msg_rm_udmap_flow_cfg_req *req;
2463 struct ti_sci_msg_hdr *resp;
2464 struct ti_sci_xfer *xfer;
2465 struct ti_sci_info *info;
2469 if (IS_ERR_OR_NULL(handle))
2472 info = handle_to_ti_sci_info(handle);
2475 xfer = ti_sci_get_one_xfer(info, TISCI_MSG_RM_UDMAP_FLOW_CFG,
2476 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2477 sizeof(*req), sizeof(*resp));
2479 ret = PTR_ERR(xfer);
2480 dev_err(dev, "RX_FL_CFG: Message alloc failed(%d)\n", ret);
2483 req = (struct ti_sci_msg_rm_udmap_flow_cfg_req *)xfer->xfer_buf;
2484 req->valid_params = params->valid_params;
2485 req->nav_id = params->nav_id;
2486 req->flow_index = params->flow_index;
2487 req->rx_einfo_present = params->rx_einfo_present;
2488 req->rx_psinfo_present = params->rx_psinfo_present;
2489 req->rx_error_handling = params->rx_error_handling;
2490 req->rx_desc_type = params->rx_desc_type;
2491 req->rx_sop_offset = params->rx_sop_offset;
2492 req->rx_dest_qnum = params->rx_dest_qnum;
2493 req->rx_src_tag_hi = params->rx_src_tag_hi;
2494 req->rx_src_tag_lo = params->rx_src_tag_lo;
2495 req->rx_dest_tag_hi = params->rx_dest_tag_hi;
2496 req->rx_dest_tag_lo = params->rx_dest_tag_lo;
2497 req->rx_src_tag_hi_sel = params->rx_src_tag_hi_sel;
2498 req->rx_src_tag_lo_sel = params->rx_src_tag_lo_sel;
2499 req->rx_dest_tag_hi_sel = params->rx_dest_tag_hi_sel;
2500 req->rx_dest_tag_lo_sel = params->rx_dest_tag_lo_sel;
2501 req->rx_fdq0_sz0_qnum = params->rx_fdq0_sz0_qnum;
2502 req->rx_fdq1_qnum = params->rx_fdq1_qnum;
2503 req->rx_fdq2_qnum = params->rx_fdq2_qnum;
2504 req->rx_fdq3_qnum = params->rx_fdq3_qnum;
2505 req->rx_ps_location = params->rx_ps_location;
2507 ret = ti_sci_do_xfer(info, xfer);
2509 dev_err(dev, "RX_FL_CFG: Mbox send fail %d\n", ret);
2513 resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;
2514 ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;
2517 ti_sci_put_one_xfer(&info->minfo, xfer);
2518 dev_dbg(info->dev, "RX_FL_CFG: %u ret:%d\n", params->flow_index, ret);
2523 * ti_sci_cmd_proc_request() - Command to request a physical processor control
2524 * @handle: Pointer to TI SCI handle
2525 * @proc_id: Processor ID this request is for
2527 * Return: 0 if all went well, else returns appropriate error value.
2529 static int ti_sci_cmd_proc_request(const struct ti_sci_handle *handle,
2532 struct ti_sci_msg_req_proc_request *req;
2533 struct ti_sci_msg_hdr *resp;
2534 struct ti_sci_info *info;
2535 struct ti_sci_xfer *xfer;
2542 return PTR_ERR(handle);
2544 info = handle_to_ti_sci_info(handle);
2547 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_REQUEST,
2548 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2549 sizeof(*req), sizeof(*resp));
2551 ret = PTR_ERR(xfer);
2552 dev_err(dev, "Message alloc failed(%d)\n", ret);
2555 req = (struct ti_sci_msg_req_proc_request *)xfer->xfer_buf;
2556 req->processor_id = proc_id;
2558 ret = ti_sci_do_xfer(info, xfer);
2560 dev_err(dev, "Mbox send fail %d\n", ret);
2564 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2566 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2569 ti_sci_put_one_xfer(&info->minfo, xfer);
2575 * ti_sci_cmd_proc_release() - Command to release a physical processor control
2576 * @handle: Pointer to TI SCI handle
2577 * @proc_id: Processor ID this request is for
2579 * Return: 0 if all went well, else returns appropriate error value.
2581 static int ti_sci_cmd_proc_release(const struct ti_sci_handle *handle,
2584 struct ti_sci_msg_req_proc_release *req;
2585 struct ti_sci_msg_hdr *resp;
2586 struct ti_sci_info *info;
2587 struct ti_sci_xfer *xfer;
2594 return PTR_ERR(handle);
2596 info = handle_to_ti_sci_info(handle);
2599 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_RELEASE,
2600 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2601 sizeof(*req), sizeof(*resp));
2603 ret = PTR_ERR(xfer);
2604 dev_err(dev, "Message alloc failed(%d)\n", ret);
2607 req = (struct ti_sci_msg_req_proc_release *)xfer->xfer_buf;
2608 req->processor_id = proc_id;
2610 ret = ti_sci_do_xfer(info, xfer);
2612 dev_err(dev, "Mbox send fail %d\n", ret);
2616 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2618 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2621 ti_sci_put_one_xfer(&info->minfo, xfer);
2627 * ti_sci_cmd_proc_handover() - Command to handover a physical processor
2628 * control to a host in the processor's access
2630 * @handle: Pointer to TI SCI handle
2631 * @proc_id: Processor ID this request is for
2632 * @host_id: Host ID to get the control of the processor
2634 * Return: 0 if all went well, else returns appropriate error value.
2636 static int ti_sci_cmd_proc_handover(const struct ti_sci_handle *handle,
2637 u8 proc_id, u8 host_id)
2639 struct ti_sci_msg_req_proc_handover *req;
2640 struct ti_sci_msg_hdr *resp;
2641 struct ti_sci_info *info;
2642 struct ti_sci_xfer *xfer;
2649 return PTR_ERR(handle);
2651 info = handle_to_ti_sci_info(handle);
2654 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_HANDOVER,
2655 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2656 sizeof(*req), sizeof(*resp));
2658 ret = PTR_ERR(xfer);
2659 dev_err(dev, "Message alloc failed(%d)\n", ret);
2662 req = (struct ti_sci_msg_req_proc_handover *)xfer->xfer_buf;
2663 req->processor_id = proc_id;
2664 req->host_id = host_id;
2666 ret = ti_sci_do_xfer(info, xfer);
2668 dev_err(dev, "Mbox send fail %d\n", ret);
2672 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2674 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2677 ti_sci_put_one_xfer(&info->minfo, xfer);
2683 * ti_sci_cmd_proc_set_config() - Command to set the processor boot
2684 * configuration flags
2685 * @handle: Pointer to TI SCI handle
2686 * @proc_id: Processor ID this request is for
2687 * @config_flags_set: Configuration flags to be set
2688 * @config_flags_clear: Configuration flags to be cleared.
2690 * Return: 0 if all went well, else returns appropriate error value.
2692 static int ti_sci_cmd_proc_set_config(const struct ti_sci_handle *handle,
2693 u8 proc_id, u64 bootvector,
2694 u32 config_flags_set,
2695 u32 config_flags_clear)
2697 struct ti_sci_msg_req_set_config *req;
2698 struct ti_sci_msg_hdr *resp;
2699 struct ti_sci_info *info;
2700 struct ti_sci_xfer *xfer;
2707 return PTR_ERR(handle);
2709 info = handle_to_ti_sci_info(handle);
2712 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CONFIG,
2713 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2714 sizeof(*req), sizeof(*resp));
2716 ret = PTR_ERR(xfer);
2717 dev_err(dev, "Message alloc failed(%d)\n", ret);
2720 req = (struct ti_sci_msg_req_set_config *)xfer->xfer_buf;
2721 req->processor_id = proc_id;
2722 req->bootvector_low = bootvector & TI_SCI_ADDR_LOW_MASK;
2723 req->bootvector_high = (bootvector & TI_SCI_ADDR_HIGH_MASK) >>
2724 TI_SCI_ADDR_HIGH_SHIFT;
2725 req->config_flags_set = config_flags_set;
2726 req->config_flags_clear = config_flags_clear;
2728 ret = ti_sci_do_xfer(info, xfer);
2730 dev_err(dev, "Mbox send fail %d\n", ret);
2734 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2736 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2739 ti_sci_put_one_xfer(&info->minfo, xfer);
2745 * ti_sci_cmd_proc_set_control() - Command to set the processor boot
2747 * @handle: Pointer to TI SCI handle
2748 * @proc_id: Processor ID this request is for
2749 * @control_flags_set: Control flags to be set
2750 * @control_flags_clear: Control flags to be cleared
2752 * Return: 0 if all went well, else returns appropriate error value.
2754 static int ti_sci_cmd_proc_set_control(const struct ti_sci_handle *handle,
2755 u8 proc_id, u32 control_flags_set,
2756 u32 control_flags_clear)
2758 struct ti_sci_msg_req_set_ctrl *req;
2759 struct ti_sci_msg_hdr *resp;
2760 struct ti_sci_info *info;
2761 struct ti_sci_xfer *xfer;
2768 return PTR_ERR(handle);
2770 info = handle_to_ti_sci_info(handle);
2773 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CTRL,
2774 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2775 sizeof(*req), sizeof(*resp));
2777 ret = PTR_ERR(xfer);
2778 dev_err(dev, "Message alloc failed(%d)\n", ret);
2781 req = (struct ti_sci_msg_req_set_ctrl *)xfer->xfer_buf;
2782 req->processor_id = proc_id;
2783 req->control_flags_set = control_flags_set;
2784 req->control_flags_clear = control_flags_clear;
2786 ret = ti_sci_do_xfer(info, xfer);
2788 dev_err(dev, "Mbox send fail %d\n", ret);
2792 resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;
2794 ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;
2797 ti_sci_put_one_xfer(&info->minfo, xfer);
2803 * ti_sci_cmd_get_boot_status() - Command to get the processor boot status
2804 * @handle: Pointer to TI SCI handle
2805 * @proc_id: Processor ID this request is for
2807 * Return: 0 if all went well, else returns appropriate error value.
2809 static int ti_sci_cmd_proc_get_status(const struct ti_sci_handle *handle,
2810 u8 proc_id, u64 *bv, u32 *cfg_flags,
2811 u32 *ctrl_flags, u32 *sts_flags)
2813 struct ti_sci_msg_resp_get_status *resp;
2814 struct ti_sci_msg_req_get_status *req;
2815 struct ti_sci_info *info;
2816 struct ti_sci_xfer *xfer;
2823 return PTR_ERR(handle);
2825 info = handle_to_ti_sci_info(handle);
2828 xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_STATUS,
2829 TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,
2830 sizeof(*req), sizeof(*resp));
2832 ret = PTR_ERR(xfer);
2833 dev_err(dev, "Message alloc failed(%d)\n", ret);
2836 req = (struct ti_sci_msg_req_get_status *)xfer->xfer_buf;
2837 req->processor_id = proc_id;
2839 ret = ti_sci_do_xfer(info, xfer);
2841 dev_err(dev, "Mbox send fail %d\n", ret);
2845 resp = (struct ti_sci_msg_resp_get_status *)xfer->tx_message.buf;
2847 if (!ti_sci_is_response_ack(resp)) {
2850 *bv = (resp->bootvector_low & TI_SCI_ADDR_LOW_MASK) |
2851 (((u64)resp->bootvector_high << TI_SCI_ADDR_HIGH_SHIFT) &
2852 TI_SCI_ADDR_HIGH_MASK);
2853 *cfg_flags = resp->config_flags;
2854 *ctrl_flags = resp->control_flags;
2855 *sts_flags = resp->status_flags;
2859 ti_sci_put_one_xfer(&info->minfo, xfer);
2865 * ti_sci_setup_ops() - Setup the operations structures
2866 * @info: pointer to TISCI pointer
2868 static void ti_sci_setup_ops(struct ti_sci_info *info)
2870 struct ti_sci_ops *ops = &info->handle.ops;
2871 struct ti_sci_core_ops *core_ops = &ops->core_ops;
2872 struct ti_sci_dev_ops *dops = &ops->dev_ops;
2873 struct ti_sci_clk_ops *cops = &ops->clk_ops;
2874 struct ti_sci_rm_core_ops *rm_core_ops = &ops->rm_core_ops;
2875 struct ti_sci_rm_irq_ops *iops = &ops->rm_irq_ops;
2876 struct ti_sci_rm_ringacc_ops *rops = &ops->rm_ring_ops;
2877 struct ti_sci_rm_psil_ops *psilops = &ops->rm_psil_ops;
2878 struct ti_sci_rm_udmap_ops *udmap_ops = &ops->rm_udmap_ops;
2879 struct ti_sci_proc_ops *pops = &ops->proc_ops;
2881 core_ops->reboot_device = ti_sci_cmd_core_reboot;
2883 dops->get_device = ti_sci_cmd_get_device;
2884 dops->get_device_exclusive = ti_sci_cmd_get_device_exclusive;
2885 dops->idle_device = ti_sci_cmd_idle_device;
2886 dops->idle_device_exclusive = ti_sci_cmd_idle_device_exclusive;
2887 dops->put_device = ti_sci_cmd_put_device;
2889 dops->is_valid = ti_sci_cmd_dev_is_valid;
2890 dops->get_context_loss_count = ti_sci_cmd_dev_get_clcnt;
2891 dops->is_idle = ti_sci_cmd_dev_is_idle;
2892 dops->is_stop = ti_sci_cmd_dev_is_stop;
2893 dops->is_on = ti_sci_cmd_dev_is_on;
2894 dops->is_transitioning = ti_sci_cmd_dev_is_trans;
2895 dops->set_device_resets = ti_sci_cmd_set_device_resets;
2896 dops->get_device_resets = ti_sci_cmd_get_device_resets;
2898 cops->get_clock = ti_sci_cmd_get_clock;
2899 cops->idle_clock = ti_sci_cmd_idle_clock;
2900 cops->put_clock = ti_sci_cmd_put_clock;
2901 cops->is_auto = ti_sci_cmd_clk_is_auto;
2902 cops->is_on = ti_sci_cmd_clk_is_on;
2903 cops->is_off = ti_sci_cmd_clk_is_off;
2905 cops->set_parent = ti_sci_cmd_clk_set_parent;
2906 cops->get_parent = ti_sci_cmd_clk_get_parent;
2907 cops->get_num_parents = ti_sci_cmd_clk_get_num_parents;
2909 cops->get_best_match_freq = ti_sci_cmd_clk_get_match_freq;
2910 cops->set_freq = ti_sci_cmd_clk_set_freq;
2911 cops->get_freq = ti_sci_cmd_clk_get_freq;
2913 rm_core_ops->get_range = ti_sci_cmd_get_resource_range;
2914 rm_core_ops->get_range_from_shost =
2915 ti_sci_cmd_get_resource_range_from_shost;
2917 iops->set_irq = ti_sci_cmd_set_irq;
2918 iops->set_event_map = ti_sci_cmd_set_event_map;
2919 iops->free_irq = ti_sci_cmd_free_irq;
2920 iops->free_event_map = ti_sci_cmd_free_event_map;
2922 rops->config = ti_sci_cmd_ring_config;
2923 rops->get_config = ti_sci_cmd_ring_get_config;
2925 psilops->pair = ti_sci_cmd_rm_psil_pair;
2926 psilops->unpair = ti_sci_cmd_rm_psil_unpair;
2928 udmap_ops->tx_ch_cfg = ti_sci_cmd_rm_udmap_tx_ch_cfg;
2929 udmap_ops->rx_ch_cfg = ti_sci_cmd_rm_udmap_rx_ch_cfg;
2930 udmap_ops->rx_flow_cfg = ti_sci_cmd_rm_udmap_rx_flow_cfg;
2932 pops->request = ti_sci_cmd_proc_request;
2933 pops->release = ti_sci_cmd_proc_release;
2934 pops->handover = ti_sci_cmd_proc_handover;
2935 pops->set_config = ti_sci_cmd_proc_set_config;
2936 pops->set_control = ti_sci_cmd_proc_set_control;
2937 pops->get_status = ti_sci_cmd_proc_get_status;
2941 * ti_sci_get_handle() - Get the TI SCI handle for a device
2942 * @dev: Pointer to device for which we want SCI handle
2944 * NOTE: The function does not track individual clients of the framework
2945 * and is expected to be maintained by caller of TI SCI protocol library.
2946 * ti_sci_put_handle must be balanced with successful ti_sci_get_handle
2947 * Return: pointer to handle if successful, else:
2948 * -EPROBE_DEFER if the instance is not ready
2949 * -ENODEV if the required node handler is missing
2950 * -EINVAL if invalid conditions are encountered.
2952 const struct ti_sci_handle *ti_sci_get_handle(struct device *dev)
2954 struct device_node *ti_sci_np;
2955 struct list_head *p;
2956 struct ti_sci_handle *handle = NULL;
2957 struct ti_sci_info *info;
2960 pr_err("I need a device pointer\n");
2961 return ERR_PTR(-EINVAL);
2963 ti_sci_np = of_get_parent(dev->of_node);
2965 dev_err(dev, "No OF information\n");
2966 return ERR_PTR(-EINVAL);
2969 mutex_lock(&ti_sci_list_mutex);
2970 list_for_each(p, &ti_sci_list) {
2971 info = list_entry(p, struct ti_sci_info, node);
2972 if (ti_sci_np == info->dev->of_node) {
2973 handle = &info->handle;
2978 mutex_unlock(&ti_sci_list_mutex);
2979 of_node_put(ti_sci_np);
2982 return ERR_PTR(-EPROBE_DEFER);
2986 EXPORT_SYMBOL_GPL(ti_sci_get_handle);
2989 * ti_sci_put_handle() - Release the handle acquired by ti_sci_get_handle
2990 * @handle: Handle acquired by ti_sci_get_handle
2992 * NOTE: The function does not track individual clients of the framework
2993 * and is expected to be maintained by caller of TI SCI protocol library.
2994 * ti_sci_put_handle must be balanced with successful ti_sci_get_handle
2996 * Return: 0 is successfully released
2997 * if an error pointer was passed, it returns the error value back,
2998 * if null was passed, it returns -EINVAL;
3000 int ti_sci_put_handle(const struct ti_sci_handle *handle)
3002 struct ti_sci_info *info;
3005 return PTR_ERR(handle);
3009 info = handle_to_ti_sci_info(handle);
3010 mutex_lock(&ti_sci_list_mutex);
3011 if (!WARN_ON(!info->users))
3013 mutex_unlock(&ti_sci_list_mutex);
3017 EXPORT_SYMBOL_GPL(ti_sci_put_handle);
3019 static void devm_ti_sci_release(struct device *dev, void *res)
3021 const struct ti_sci_handle **ptr = res;
3022 const struct ti_sci_handle *handle = *ptr;
3025 ret = ti_sci_put_handle(handle);
3027 dev_err(dev, "failed to put handle %d\n", ret);
3031 * devm_ti_sci_get_handle() - Managed get handle
3032 * @dev: device for which we want SCI handle for.
3034 * NOTE: This releases the handle once the device resources are
3035 * no longer needed. MUST NOT BE released with ti_sci_put_handle.
3036 * The function does not track individual clients of the framework
3037 * and is expected to be maintained by caller of TI SCI protocol library.
3039 * Return: 0 if all went fine, else corresponding error.
3041 const struct ti_sci_handle *devm_ti_sci_get_handle(struct device *dev)
3043 const struct ti_sci_handle **ptr;
3044 const struct ti_sci_handle *handle;
3046 ptr = devres_alloc(devm_ti_sci_release, sizeof(*ptr), GFP_KERNEL);
3048 return ERR_PTR(-ENOMEM);
3049 handle = ti_sci_get_handle(dev);
3051 if (!IS_ERR(handle)) {
3053 devres_add(dev, ptr);
3060 EXPORT_SYMBOL_GPL(devm_ti_sci_get_handle);
3063 * ti_sci_get_by_phandle() - Get the TI SCI handle using DT phandle
3065 * @property: property name containing phandle on TISCI node
3067 * NOTE: The function does not track individual clients of the framework
3068 * and is expected to be maintained by caller of TI SCI protocol library.
3069 * ti_sci_put_handle must be balanced with successful ti_sci_get_by_phandle
3070 * Return: pointer to handle if successful, else:
3071 * -EPROBE_DEFER if the instance is not ready
3072 * -ENODEV if the required node handler is missing
3073 * -EINVAL if invalid conditions are encountered.
3075 const struct ti_sci_handle *ti_sci_get_by_phandle(struct device_node *np,
3076 const char *property)
3078 struct ti_sci_handle *handle = NULL;
3079 struct device_node *ti_sci_np;
3080 struct ti_sci_info *info;
3081 struct list_head *p;
3084 pr_err("I need a device pointer\n");
3085 return ERR_PTR(-EINVAL);
3088 ti_sci_np = of_parse_phandle(np, property, 0);
3090 return ERR_PTR(-ENODEV);
3092 mutex_lock(&ti_sci_list_mutex);
3093 list_for_each(p, &ti_sci_list) {
3094 info = list_entry(p, struct ti_sci_info, node);
3095 if (ti_sci_np == info->dev->of_node) {
3096 handle = &info->handle;
3101 mutex_unlock(&ti_sci_list_mutex);
3102 of_node_put(ti_sci_np);
3105 return ERR_PTR(-EPROBE_DEFER);
3109 EXPORT_SYMBOL_GPL(ti_sci_get_by_phandle);
3112 * devm_ti_sci_get_by_phandle() - Managed get handle using phandle
3113 * @dev: Device pointer requesting TISCI handle
3114 * @property: property name containing phandle on TISCI node
3116 * NOTE: This releases the handle once the device resources are
3117 * no longer needed. MUST NOT BE released with ti_sci_put_handle.
3118 * The function does not track individual clients of the framework
3119 * and is expected to be maintained by caller of TI SCI protocol library.
3121 * Return: 0 if all went fine, else corresponding error.
3123 const struct ti_sci_handle *devm_ti_sci_get_by_phandle(struct device *dev,
3124 const char *property)
3126 const struct ti_sci_handle *handle;
3127 const struct ti_sci_handle **ptr;
3129 ptr = devres_alloc(devm_ti_sci_release, sizeof(*ptr), GFP_KERNEL);
3131 return ERR_PTR(-ENOMEM);
3132 handle = ti_sci_get_by_phandle(dev_of_node(dev), property);
3134 if (!IS_ERR(handle)) {
3136 devres_add(dev, ptr);
3143 EXPORT_SYMBOL_GPL(devm_ti_sci_get_by_phandle);
3146 * ti_sci_get_free_resource() - Get a free resource from TISCI resource.
3147 * @res: Pointer to the TISCI resource
3149 * Return: resource num if all went ok else TI_SCI_RESOURCE_NULL.
3151 u16 ti_sci_get_free_resource(struct ti_sci_resource *res)
3153 unsigned long flags;
3156 raw_spin_lock_irqsave(&res->lock, flags);
3157 for (set = 0; set < res->sets; set++) {
3158 free_bit = find_first_zero_bit(res->desc[set].res_map,
3159 res->desc[set].num);
3160 if (free_bit != res->desc[set].num) {
3161 set_bit(free_bit, res->desc[set].res_map);
3162 raw_spin_unlock_irqrestore(&res->lock, flags);
3163 return res->desc[set].start + free_bit;
3166 raw_spin_unlock_irqrestore(&res->lock, flags);
3168 return TI_SCI_RESOURCE_NULL;
3170 EXPORT_SYMBOL_GPL(ti_sci_get_free_resource);
3173 * ti_sci_release_resource() - Release a resource from TISCI resource.
3174 * @res: Pointer to the TISCI resource
3175 * @id: Resource id to be released.
3177 void ti_sci_release_resource(struct ti_sci_resource *res, u16 id)
3179 unsigned long flags;
3182 raw_spin_lock_irqsave(&res->lock, flags);
3183 for (set = 0; set < res->sets; set++) {
3184 if (res->desc[set].start <= id &&
3185 (res->desc[set].num + res->desc[set].start) > id)
3186 clear_bit(id - res->desc[set].start,
3187 res->desc[set].res_map);
3189 raw_spin_unlock_irqrestore(&res->lock, flags);
3191 EXPORT_SYMBOL_GPL(ti_sci_release_resource);
3194 * ti_sci_get_num_resources() - Get the number of resources in TISCI resource
3195 * @res: Pointer to the TISCI resource
3197 * Return: Total number of available resources.
3199 u32 ti_sci_get_num_resources(struct ti_sci_resource *res)
3203 for (set = 0; set < res->sets; set++)
3204 count += res->desc[set].num;
3208 EXPORT_SYMBOL_GPL(ti_sci_get_num_resources);
3211 * devm_ti_sci_get_resource_sets() - Get a TISCI resources assigned to a device
3212 * @handle: TISCI handle
3213 * @dev: Device pointer to which the resource is assigned
3214 * @dev_id: TISCI device id to which the resource is assigned
3215 * @sub_types: Array of sub_types assigned corresponding to device
3216 * @sets: Number of sub_types
3218 * Return: Pointer to ti_sci_resource if all went well else appropriate
3221 static struct ti_sci_resource *
3222 devm_ti_sci_get_resource_sets(const struct ti_sci_handle *handle,
3223 struct device *dev, u32 dev_id, u32 *sub_types,
3226 struct ti_sci_resource *res;
3227 bool valid_set = false;
3230 res = devm_kzalloc(dev, sizeof(*res), GFP_KERNEL);
3232 return ERR_PTR(-ENOMEM);
3235 res->desc = devm_kcalloc(dev, res->sets, sizeof(*res->desc),
3238 return ERR_PTR(-ENOMEM);
3240 for (i = 0; i < res->sets; i++) {
3241 ret = handle->ops.rm_core_ops.get_range(handle, dev_id,
3243 &res->desc[i].start,
3246 dev_dbg(dev, "dev = %d subtype %d not allocated for this host\n",
3247 dev_id, sub_types[i]);
3248 res->desc[i].start = 0;
3249 res->desc[i].num = 0;
3253 dev_dbg(dev, "dev = %d, subtype = %d, start = %d, num = %d\n",
3254 dev_id, sub_types[i], res->desc[i].start,
3258 res->desc[i].res_map =
3259 devm_kzalloc(dev, BITS_TO_LONGS(res->desc[i].num) *
3260 sizeof(*res->desc[i].res_map), GFP_KERNEL);
3261 if (!res->desc[i].res_map)
3262 return ERR_PTR(-ENOMEM);
3264 raw_spin_lock_init(&res->lock);
3269 return ERR_PTR(-EINVAL);
3273 * devm_ti_sci_get_of_resource() - Get a TISCI resource assigned to a device
3274 * @handle: TISCI handle
3275 * @dev: Device pointer to which the resource is assigned
3276 * @dev_id: TISCI device id to which the resource is assigned
3277 * @of_prop: property name by which the resource are represented
3279 * Return: Pointer to ti_sci_resource if all went well else appropriate
3282 struct ti_sci_resource *
3283 devm_ti_sci_get_of_resource(const struct ti_sci_handle *handle,
3284 struct device *dev, u32 dev_id, char *of_prop)
3286 struct ti_sci_resource *res;
3290 sets = of_property_count_elems_of_size(dev_of_node(dev), of_prop,
3293 dev_err(dev, "%s resource type ids not available\n", of_prop);
3294 return ERR_PTR(sets);
3297 sub_types = kcalloc(sets, sizeof(*sub_types), GFP_KERNEL);
3299 return ERR_PTR(-ENOMEM);
3301 of_property_read_u32_array(dev_of_node(dev), of_prop, sub_types, sets);
3302 res = devm_ti_sci_get_resource_sets(handle, dev, dev_id, sub_types,
3308 EXPORT_SYMBOL_GPL(devm_ti_sci_get_of_resource);
3311 * devm_ti_sci_get_resource() - Get a resource range assigned to the device
3312 * @handle: TISCI handle
3313 * @dev: Device pointer to which the resource is assigned
3314 * @dev_id: TISCI device id to which the resource is assigned
3315 * @suub_type: TISCI resource subytpe representing the resource.
3317 * Return: Pointer to ti_sci_resource if all went well else appropriate
3320 struct ti_sci_resource *
3321 devm_ti_sci_get_resource(const struct ti_sci_handle *handle, struct device *dev,
3322 u32 dev_id, u32 sub_type)
3324 return devm_ti_sci_get_resource_sets(handle, dev, dev_id, &sub_type, 1);
3326 EXPORT_SYMBOL_GPL(devm_ti_sci_get_resource);
3328 static int tisci_reboot_handler(struct notifier_block *nb, unsigned long mode,
3331 struct ti_sci_info *info = reboot_to_ti_sci_info(nb);
3332 const struct ti_sci_handle *handle = &info->handle;
3334 ti_sci_cmd_core_reboot(handle);
3336 /* call fail OR pass, we should not be here in the first place */
3340 /* Description for K2G */
3341 static const struct ti_sci_desc ti_sci_pmmc_k2g_desc = {
3342 .default_host_id = 2,
3343 /* Conservative duration */
3344 .max_rx_timeout_ms = 1000,
3345 /* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */
3350 /* Description for AM654 */
3351 static const struct ti_sci_desc ti_sci_pmmc_am654_desc = {
3352 .default_host_id = 12,
3353 /* Conservative duration */
3354 .max_rx_timeout_ms = 10000,
3355 /* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */
3360 static const struct of_device_id ti_sci_of_match[] = {
3361 {.compatible = "ti,k2g-sci", .data = &ti_sci_pmmc_k2g_desc},
3362 {.compatible = "ti,am654-sci", .data = &ti_sci_pmmc_am654_desc},
3365 MODULE_DEVICE_TABLE(of, ti_sci_of_match);
3367 static int ti_sci_probe(struct platform_device *pdev)
3369 struct device *dev = &pdev->dev;
3370 const struct of_device_id *of_id;
3371 const struct ti_sci_desc *desc;
3372 struct ti_sci_xfer *xfer;
3373 struct ti_sci_info *info = NULL;
3374 struct ti_sci_xfers_info *minfo;
3375 struct mbox_client *cl;
3381 of_id = of_match_device(ti_sci_of_match, dev);
3383 dev_err(dev, "OF data missing\n");
3388 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
3394 ret = of_property_read_u32(dev->of_node, "ti,host-id", &h_id);
3395 /* if the property is not present in DT, use a default from desc */
3397 info->host_id = info->desc->default_host_id;
3400 dev_warn(dev, "Host ID 0 is reserved for firmware\n");
3401 info->host_id = info->desc->default_host_id;
3403 info->host_id = h_id;
3407 reboot = of_property_read_bool(dev->of_node,
3408 "ti,system-reboot-controller");
3409 INIT_LIST_HEAD(&info->node);
3410 minfo = &info->minfo;
3413 * Pre-allocate messages
3414 * NEVER allocate more than what we can indicate in hdr.seq
3415 * if we have data description bug, force a fix..
3417 if (WARN_ON(desc->max_msgs >=
3418 1 << 8 * sizeof(((struct ti_sci_msg_hdr *)0)->seq)))
3421 minfo->xfer_block = devm_kcalloc(dev,
3423 sizeof(*minfo->xfer_block),
3425 if (!minfo->xfer_block)
3428 minfo->xfer_alloc_table = devm_kcalloc(dev,
3429 BITS_TO_LONGS(desc->max_msgs),
3430 sizeof(unsigned long),
3432 if (!minfo->xfer_alloc_table)
3434 bitmap_zero(minfo->xfer_alloc_table, desc->max_msgs);
3436 /* Pre-initialize the buffer pointer to pre-allocated buffers */
3437 for (i = 0, xfer = minfo->xfer_block; i < desc->max_msgs; i++, xfer++) {
3438 xfer->xfer_buf = devm_kcalloc(dev, 1, desc->max_msg_size,
3440 if (!xfer->xfer_buf)
3443 xfer->tx_message.buf = xfer->xfer_buf;
3444 init_completion(&xfer->done);
3447 ret = ti_sci_debugfs_create(pdev, info);
3449 dev_warn(dev, "Failed to create debug file\n");
3451 platform_set_drvdata(pdev, info);
3455 cl->tx_block = false;
3456 cl->rx_callback = ti_sci_rx_callback;
3457 cl->knows_txdone = true;
3459 spin_lock_init(&minfo->xfer_lock);
3460 sema_init(&minfo->sem_xfer_count, desc->max_msgs);
3462 info->chan_rx = mbox_request_channel_byname(cl, "rx");
3463 if (IS_ERR(info->chan_rx)) {
3464 ret = PTR_ERR(info->chan_rx);
3468 info->chan_tx = mbox_request_channel_byname(cl, "tx");
3469 if (IS_ERR(info->chan_tx)) {
3470 ret = PTR_ERR(info->chan_tx);
3473 ret = ti_sci_cmd_get_revision(info);
3475 dev_err(dev, "Unable to communicate with TISCI(%d)\n", ret);
3479 ti_sci_setup_ops(info);
3482 info->nb.notifier_call = tisci_reboot_handler;
3483 info->nb.priority = 128;
3485 ret = register_restart_handler(&info->nb);
3487 dev_err(dev, "reboot registration fail(%d)\n", ret);
3492 dev_info(dev, "ABI: %d.%d (firmware rev 0x%04x '%s')\n",
3493 info->handle.version.abi_major, info->handle.version.abi_minor,
3494 info->handle.version.firmware_revision,
3495 info->handle.version.firmware_description);
3497 mutex_lock(&ti_sci_list_mutex);
3498 list_add_tail(&info->node, &ti_sci_list);
3499 mutex_unlock(&ti_sci_list_mutex);
3501 return of_platform_populate(dev->of_node, NULL, NULL, dev);
3503 if (!IS_ERR(info->chan_tx))
3504 mbox_free_channel(info->chan_tx);
3505 if (!IS_ERR(info->chan_rx))
3506 mbox_free_channel(info->chan_rx);
3507 debugfs_remove(info->d);
3511 static int ti_sci_remove(struct platform_device *pdev)
3513 struct ti_sci_info *info;
3514 struct device *dev = &pdev->dev;
3517 of_platform_depopulate(dev);
3519 info = platform_get_drvdata(pdev);
3521 if (info->nb.notifier_call)
3522 unregister_restart_handler(&info->nb);
3524 mutex_lock(&ti_sci_list_mutex);
3528 list_del(&info->node);
3529 mutex_unlock(&ti_sci_list_mutex);
3532 ti_sci_debugfs_destroy(pdev, info);
3534 /* Safe to free channels since no more users */
3535 mbox_free_channel(info->chan_tx);
3536 mbox_free_channel(info->chan_rx);
3542 static struct platform_driver ti_sci_driver = {
3543 .probe = ti_sci_probe,
3544 .remove = ti_sci_remove,
3547 .of_match_table = of_match_ptr(ti_sci_of_match),
3550 module_platform_driver(ti_sci_driver);
3552 MODULE_LICENSE("GPL v2");
3553 MODULE_DESCRIPTION("TI System Control Interface(SCI) driver");
3554 MODULE_AUTHOR("Nishanth Menon");
3555 MODULE_ALIAS("platform:ti-sci");