brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.02/*3 * Texas Instruments System Control Interface Protocol Driver4 *5 * Copyright (C) 2015-2022 Texas Instruments Incorporated - https://www.ti.com/6 *	Nishanth Menon7 */8 9#define pr_fmt(fmt) "%s: " fmt, __func__10 11#include <linux/bitmap.h>12#include <linux/debugfs.h>13#include <linux/export.h>14#include <linux/io.h>15#include <linux/iopoll.h>16#include <linux/kernel.h>17#include <linux/mailbox_client.h>18#include <linux/module.h>19#include <linux/of.h>20#include <linux/of_platform.h>21#include <linux/platform_device.h>22#include <linux/property.h>23#include <linux/semaphore.h>24#include <linux/slab.h>25#include <linux/soc/ti/ti-msgmgr.h>26#include <linux/soc/ti/ti_sci_protocol.h>27#include <linux/reboot.h>28 29#include "ti_sci.h"30 31/* List of all TI SCI devices active in system */32static LIST_HEAD(ti_sci_list);33/* Protection for the entire list */34static DEFINE_MUTEX(ti_sci_list_mutex);35 36/**37 * struct ti_sci_xfer - Structure representing a message flow38 * @tx_message:	Transmit message39 * @rx_len:	Receive message length40 * @xfer_buf:	Preallocated buffer to store receive message41 *		Since we work with request-ACK protocol, we can42 *		reuse the same buffer for the rx path as we43 *		use for the tx path.44 * @done:	completion event45 */46struct ti_sci_xfer {47	struct ti_msgmgr_message tx_message;48	u8 rx_len;49	u8 *xfer_buf;50	struct completion done;51};52 53/**54 * struct ti_sci_xfers_info - Structure to manage transfer information55 * @sem_xfer_count:	Counting Semaphore for managing max simultaneous56 *			Messages.57 * @xfer_block:		Preallocated Message array58 * @xfer_alloc_table:	Bitmap table for allocated messages.59 *			Index of this bitmap table is also used for message60 *			sequence identifier.61 * @xfer_lock:		Protection for message allocation62 */63struct ti_sci_xfers_info {64	struct semaphore sem_xfer_count;65	struct ti_sci_xfer *xfer_block;66	unsigned long *xfer_alloc_table;67	/* protect transfer allocation */68	spinlock_t xfer_lock;69};70 71/**72 * struct ti_sci_desc - Description of SoC integration73 * @default_host_id:	Host identifier representing the compute entity74 * @max_rx_timeout_ms:	Timeout for communication with SoC (in Milliseconds)75 * @max_msgs: Maximum number of messages that can be pending76 *		  simultaneously in the system77 * @max_msg_size: Maximum size of data per message that can be handled.78 */79struct ti_sci_desc {80	u8 default_host_id;81	int max_rx_timeout_ms;82	int max_msgs;83	int max_msg_size;84};85 86/**87 * struct ti_sci_info - Structure representing a TI SCI instance88 * @dev:	Device pointer89 * @desc:	SoC description for this instance90 * @d:		Debugfs file entry91 * @debug_region: Memory region where the debug message are available92 * @debug_region_size: Debug region size93 * @debug_buffer: Buffer allocated to copy debug messages.94 * @handle:	Instance of TI SCI handle to send to clients.95 * @cl:		Mailbox Client96 * @chan_tx:	Transmit mailbox channel97 * @chan_rx:	Receive mailbox channel98 * @minfo:	Message info99 * @node:	list head100 * @host_id:	Host ID101 * @users:	Number of users of this instance102 */103struct ti_sci_info {104	struct device *dev;105	const struct ti_sci_desc *desc;106	struct dentry *d;107	void __iomem *debug_region;108	char *debug_buffer;109	size_t debug_region_size;110	struct ti_sci_handle handle;111	struct mbox_client cl;112	struct mbox_chan *chan_tx;113	struct mbox_chan *chan_rx;114	struct ti_sci_xfers_info minfo;115	struct list_head node;116	u8 host_id;117	/* protected by ti_sci_list_mutex */118	int users;119};120 121#define cl_to_ti_sci_info(c)	container_of(c, struct ti_sci_info, cl)122#define handle_to_ti_sci_info(h) container_of(h, struct ti_sci_info, handle)123 124#ifdef CONFIG_DEBUG_FS125 126/**127 * ti_sci_debug_show() - Helper to dump the debug log128 * @s:	sequence file pointer129 * @unused:	unused.130 *131 * Return: 0132 */133static int ti_sci_debug_show(struct seq_file *s, void *unused)134{135	struct ti_sci_info *info = s->private;136 137	memcpy_fromio(info->debug_buffer, info->debug_region,138		      info->debug_region_size);139	/*140	 * We don't trust firmware to leave NULL terminated last byte (hence141	 * we have allocated 1 extra 0 byte). Since we cannot guarantee any142	 * specific data format for debug messages, We just present the data143	 * in the buffer as is - we expect the messages to be self explanatory.144	 */145	seq_puts(s, info->debug_buffer);146	return 0;147}148 149/* Provide the log file operations interface*/150DEFINE_SHOW_ATTRIBUTE(ti_sci_debug);151 152/**153 * ti_sci_debugfs_create() - Create log debug file154 * @pdev:	platform device pointer155 * @info:	Pointer to SCI entity information156 *157 * Return: 0 if all went fine, else corresponding error.158 */159static int ti_sci_debugfs_create(struct platform_device *pdev,160				 struct ti_sci_info *info)161{162	struct device *dev = &pdev->dev;163	struct resource *res;164	char debug_name[50];165 166	/* Debug region is optional */167	res = platform_get_resource_byname(pdev, IORESOURCE_MEM,168					   "debug_messages");169	info->debug_region = devm_ioremap_resource(dev, res);170	if (IS_ERR(info->debug_region))171		return 0;172	info->debug_region_size = resource_size(res);173 174	info->debug_buffer = devm_kcalloc(dev, info->debug_region_size + 1,175					  sizeof(char), GFP_KERNEL);176	if (!info->debug_buffer)177		return -ENOMEM;178	/* Setup NULL termination */179	info->debug_buffer[info->debug_region_size] = 0;180 181	snprintf(debug_name, sizeof(debug_name), "ti_sci_debug@%s",182		 dev_name(dev));183	info->d = debugfs_create_file(debug_name, 0444, NULL, info,184				      &ti_sci_debug_fops);185	if (IS_ERR(info->d))186		return PTR_ERR(info->d);187 188	dev_dbg(dev, "Debug region => %p, size = %zu bytes, resource: %pr\n",189		info->debug_region, info->debug_region_size, res);190	return 0;191}192 193#else /* CONFIG_DEBUG_FS */194static inline int ti_sci_debugfs_create(struct platform_device *dev,195					struct ti_sci_info *info)196{197	return 0;198}199 200static inline void ti_sci_debugfs_destroy(struct platform_device *dev,201					  struct ti_sci_info *info)202{203}204#endif /* CONFIG_DEBUG_FS */205 206/**207 * ti_sci_dump_header_dbg() - Helper to dump a message header.208 * @dev:	Device pointer corresponding to the SCI entity209 * @hdr:	pointer to header.210 */211static inline void ti_sci_dump_header_dbg(struct device *dev,212					  struct ti_sci_msg_hdr *hdr)213{214	dev_dbg(dev, "MSGHDR:type=0x%04x host=0x%02x seq=0x%02x flags=0x%08x\n",215		hdr->type, hdr->host, hdr->seq, hdr->flags);216}217 218/**219 * ti_sci_rx_callback() - mailbox client callback for receive messages220 * @cl:	client pointer221 * @m:	mailbox message222 *223 * Processes one received message to appropriate transfer information and224 * signals completion of the transfer.225 *226 * NOTE: This function will be invoked in IRQ context, hence should be227 * as optimal as possible.228 */229static void ti_sci_rx_callback(struct mbox_client *cl, void *m)230{231	struct ti_sci_info *info = cl_to_ti_sci_info(cl);232	struct device *dev = info->dev;233	struct ti_sci_xfers_info *minfo = &info->minfo;234	struct ti_msgmgr_message *mbox_msg = m;235	struct ti_sci_msg_hdr *hdr = (struct ti_sci_msg_hdr *)mbox_msg->buf;236	struct ti_sci_xfer *xfer;237	u8 xfer_id;238 239	xfer_id = hdr->seq;240 241	/*242	 * Are we even expecting this?243	 * NOTE: barriers were implicit in locks used for modifying the bitmap244	 */245	if (!test_bit(xfer_id, minfo->xfer_alloc_table)) {246		dev_err(dev, "Message for %d is not expected!\n", xfer_id);247		return;248	}249 250	xfer = &minfo->xfer_block[xfer_id];251 252	/* Is the message of valid length? */253	if (mbox_msg->len > info->desc->max_msg_size) {254		dev_err(dev, "Unable to handle %zu xfer(max %d)\n",255			mbox_msg->len, info->desc->max_msg_size);256		ti_sci_dump_header_dbg(dev, hdr);257		return;258	}259	if (mbox_msg->len < xfer->rx_len) {260		dev_err(dev, "Recv xfer %zu < expected %d length\n",261			mbox_msg->len, xfer->rx_len);262		ti_sci_dump_header_dbg(dev, hdr);263		return;264	}265 266	ti_sci_dump_header_dbg(dev, hdr);267	/* Take a copy to the rx buffer.. */268	memcpy(xfer->xfer_buf, mbox_msg->buf, xfer->rx_len);269	complete(&xfer->done);270}271 272/**273 * ti_sci_get_one_xfer() - Allocate one message274 * @info:	Pointer to SCI entity information275 * @msg_type:	Message type276 * @msg_flags:	Flag to set for the message277 * @tx_message_size: transmit message size278 * @rx_message_size: receive message size279 *280 * Helper function which is used by various command functions that are281 * exposed to clients of this driver for allocating a message traffic event.282 *283 * This function can sleep depending on pending requests already in the system284 * for the SCI entity. Further, this also holds a spinlock to maintain integrity285 * of internal data structures.286 *287 * Return: 0 if all went fine, else corresponding error.288 */289static struct ti_sci_xfer *ti_sci_get_one_xfer(struct ti_sci_info *info,290					       u16 msg_type, u32 msg_flags,291					       size_t tx_message_size,292					       size_t rx_message_size)293{294	struct ti_sci_xfers_info *minfo = &info->minfo;295	struct ti_sci_xfer *xfer;296	struct ti_sci_msg_hdr *hdr;297	unsigned long flags;298	unsigned long bit_pos;299	u8 xfer_id;300	int ret;301	int timeout;302 303	/* Ensure we have sane transfer sizes */304	if (rx_message_size > info->desc->max_msg_size ||305	    tx_message_size > info->desc->max_msg_size ||306	    rx_message_size < sizeof(*hdr) || tx_message_size < sizeof(*hdr))307		return ERR_PTR(-ERANGE);308 309	/*310	 * Ensure we have only controlled number of pending messages.311	 * Ideally, we might just have to wait a single message, be312	 * conservative and wait 5 times that..313	 */314	timeout = msecs_to_jiffies(info->desc->max_rx_timeout_ms) * 5;315	ret = down_timeout(&minfo->sem_xfer_count, timeout);316	if (ret < 0)317		return ERR_PTR(ret);318 319	/* Keep the locked section as small as possible */320	spin_lock_irqsave(&minfo->xfer_lock, flags);321	bit_pos = find_first_zero_bit(minfo->xfer_alloc_table,322				      info->desc->max_msgs);323	set_bit(bit_pos, minfo->xfer_alloc_table);324	spin_unlock_irqrestore(&minfo->xfer_lock, flags);325 326	/*327	 * We already ensured in probe that we can have max messages that can328	 * fit in  hdr.seq - NOTE: this improves access latencies329	 * to predictable O(1) access, BUT, it opens us to risk if330	 * remote misbehaves with corrupted message sequence responses.331	 * If that happens, we are going to be messed up anyways..332	 */333	xfer_id = (u8)bit_pos;334 335	xfer = &minfo->xfer_block[xfer_id];336 337	hdr = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;338	xfer->tx_message.len = tx_message_size;339	xfer->tx_message.chan_rx = info->chan_rx;340	xfer->tx_message.timeout_rx_ms = info->desc->max_rx_timeout_ms;341	xfer->rx_len = (u8)rx_message_size;342 343	reinit_completion(&xfer->done);344 345	hdr->seq = xfer_id;346	hdr->type = msg_type;347	hdr->host = info->host_id;348	hdr->flags = msg_flags;349 350	return xfer;351}352 353/**354 * ti_sci_put_one_xfer() - Release a message355 * @minfo:	transfer info pointer356 * @xfer:	message that was reserved by ti_sci_get_one_xfer357 *358 * This holds a spinlock to maintain integrity of internal data structures.359 */360static void ti_sci_put_one_xfer(struct ti_sci_xfers_info *minfo,361				struct ti_sci_xfer *xfer)362{363	unsigned long flags;364	struct ti_sci_msg_hdr *hdr;365	u8 xfer_id;366 367	hdr = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;368	xfer_id = hdr->seq;369 370	/*371	 * Keep the locked section as small as possible372	 * NOTE: we might escape with smp_mb and no lock here..373	 * but just be conservative and symmetric.374	 */375	spin_lock_irqsave(&minfo->xfer_lock, flags);376	clear_bit(xfer_id, minfo->xfer_alloc_table);377	spin_unlock_irqrestore(&minfo->xfer_lock, flags);378 379	/* Increment the count for the next user to get through */380	up(&minfo->sem_xfer_count);381}382 383/**384 * ti_sci_do_xfer() - Do one transfer385 * @info:	Pointer to SCI entity information386 * @xfer:	Transfer to initiate and wait for response387 *388 * Return: -ETIMEDOUT in case of no response, if transmit error,389 *	   return corresponding error, else if all goes well,390 *	   return 0.391 */392static inline int ti_sci_do_xfer(struct ti_sci_info *info,393				 struct ti_sci_xfer *xfer)394{395	int ret;396	int timeout;397	struct device *dev = info->dev;398	bool done_state = true;399 400	ret = mbox_send_message(info->chan_tx, &xfer->tx_message);401	if (ret < 0)402		return ret;403 404	ret = 0;405 406	if (system_state <= SYSTEM_RUNNING) {407		/* And we wait for the response. */408		timeout = msecs_to_jiffies(info->desc->max_rx_timeout_ms);409		if (!wait_for_completion_timeout(&xfer->done, timeout))410			ret = -ETIMEDOUT;411	} else {412		/*413		 * If we are !running, we cannot use wait_for_completion_timeout414		 * during noirq phase, so we must manually poll the completion.415		 */416		ret = read_poll_timeout_atomic(try_wait_for_completion, done_state,417					       done_state, 1,418					       info->desc->max_rx_timeout_ms * 1000,419					       false, &xfer->done);420	}421 422	if (ret == -ETIMEDOUT)423		dev_err(dev, "Mbox timedout in resp(caller: %pS)\n",424			(void *)_RET_IP_);425 426	/*427	 * NOTE: we might prefer not to need the mailbox ticker to manage the428	 * transfer queueing since the protocol layer queues things by itself.429	 * Unfortunately, we have to kick the mailbox framework after we have430	 * received our message.431	 */432	mbox_client_txdone(info->chan_tx, ret);433 434	return ret;435}436 437/**438 * ti_sci_cmd_get_revision() - command to get the revision of the SCI entity439 * @info:	Pointer to SCI entity information440 *441 * Updates the SCI information in the internal data structure.442 *443 * Return: 0 if all went fine, else return appropriate error.444 */445static int ti_sci_cmd_get_revision(struct ti_sci_info *info)446{447	struct device *dev = info->dev;448	struct ti_sci_handle *handle = &info->handle;449	struct ti_sci_version_info *ver = &handle->version;450	struct ti_sci_msg_resp_version *rev_info;451	struct ti_sci_xfer *xfer;452	int ret;453 454	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_VERSION,455				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,456				   sizeof(struct ti_sci_msg_hdr),457				   sizeof(*rev_info));458	if (IS_ERR(xfer)) {459		ret = PTR_ERR(xfer);460		dev_err(dev, "Message alloc failed(%d)\n", ret);461		return ret;462	}463 464	rev_info = (struct ti_sci_msg_resp_version *)xfer->xfer_buf;465 466	ret = ti_sci_do_xfer(info, xfer);467	if (ret) {468		dev_err(dev, "Mbox send fail %d\n", ret);469		goto fail;470	}471 472	ver->abi_major = rev_info->abi_major;473	ver->abi_minor = rev_info->abi_minor;474	ver->firmware_revision = rev_info->firmware_revision;475	strscpy(ver->firmware_description, rev_info->firmware_description,476		sizeof(ver->firmware_description));477 478fail:479	ti_sci_put_one_xfer(&info->minfo, xfer);480	return ret;481}482 483/**484 * ti_sci_is_response_ack() - Generic ACK/NACK message checkup485 * @r:	pointer to response buffer486 *487 * Return: true if the response was an ACK, else returns false.488 */489static inline bool ti_sci_is_response_ack(void *r)490{491	struct ti_sci_msg_hdr *hdr = r;492 493	return hdr->flags & TI_SCI_FLAG_RESP_GENERIC_ACK ? true : false;494}495 496/**497 * ti_sci_set_device_state() - Set device state helper498 * @handle:	pointer to TI SCI handle499 * @id:		Device identifier500 * @flags:	flags to setup for the device501 * @state:	State to move the device to502 *503 * Return: 0 if all went well, else returns appropriate error value.504 */505static int ti_sci_set_device_state(const struct ti_sci_handle *handle,506				   u32 id, u32 flags, u8 state)507{508	struct ti_sci_info *info;509	struct ti_sci_msg_req_set_device_state *req;510	struct ti_sci_msg_hdr *resp;511	struct ti_sci_xfer *xfer;512	struct device *dev;513	int ret = 0;514 515	if (IS_ERR(handle))516		return PTR_ERR(handle);517	if (!handle)518		return -EINVAL;519 520	info = handle_to_ti_sci_info(handle);521	dev = info->dev;522 523	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_DEVICE_STATE,524				   flags | TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,525				   sizeof(*req), sizeof(*resp));526	if (IS_ERR(xfer)) {527		ret = PTR_ERR(xfer);528		dev_err(dev, "Message alloc failed(%d)\n", ret);529		return ret;530	}531	req = (struct ti_sci_msg_req_set_device_state *)xfer->xfer_buf;532	req->id = id;533	req->state = state;534 535	ret = ti_sci_do_xfer(info, xfer);536	if (ret) {537		dev_err(dev, "Mbox send fail %d\n", ret);538		goto fail;539	}540 541	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;542 543	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;544 545fail:546	ti_sci_put_one_xfer(&info->minfo, xfer);547 548	return ret;549}550 551/**552 * ti_sci_get_device_state() - Get device state helper553 * @handle:	Handle to the device554 * @id:		Device Identifier555 * @clcnt:	Pointer to Context Loss Count556 * @resets:	pointer to resets557 * @p_state:	pointer to p_state558 * @c_state:	pointer to c_state559 *560 * Return: 0 if all went fine, else return appropriate error.561 */562static int ti_sci_get_device_state(const struct ti_sci_handle *handle,563				   u32 id,  u32 *clcnt,  u32 *resets,564				    u8 *p_state,  u8 *c_state)565{566	struct ti_sci_info *info;567	struct ti_sci_msg_req_get_device_state *req;568	struct ti_sci_msg_resp_get_device_state *resp;569	struct ti_sci_xfer *xfer;570	struct device *dev;571	int ret = 0;572 573	if (IS_ERR(handle))574		return PTR_ERR(handle);575	if (!handle)576		return -EINVAL;577 578	if (!clcnt && !resets && !p_state && !c_state)579		return -EINVAL;580 581	info = handle_to_ti_sci_info(handle);582	dev = info->dev;583 584	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_DEVICE_STATE,585				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,586				   sizeof(*req), sizeof(*resp));587	if (IS_ERR(xfer)) {588		ret = PTR_ERR(xfer);589		dev_err(dev, "Message alloc failed(%d)\n", ret);590		return ret;591	}592	req = (struct ti_sci_msg_req_get_device_state *)xfer->xfer_buf;593	req->id = id;594 595	ret = ti_sci_do_xfer(info, xfer);596	if (ret) {597		dev_err(dev, "Mbox send fail %d\n", ret);598		goto fail;599	}600 601	resp = (struct ti_sci_msg_resp_get_device_state *)xfer->xfer_buf;602	if (!ti_sci_is_response_ack(resp)) {603		ret = -ENODEV;604		goto fail;605	}606 607	if (clcnt)608		*clcnt = resp->context_loss_count;609	if (resets)610		*resets = resp->resets;611	if (p_state)612		*p_state = resp->programmed_state;613	if (c_state)614		*c_state = resp->current_state;615fail:616	ti_sci_put_one_xfer(&info->minfo, xfer);617 618	return ret;619}620 621/**622 * ti_sci_cmd_get_device() - command to request for device managed by TISCI623 *			     that can be shared with other hosts.624 * @handle:	Pointer to TISCI handle as retrieved by *ti_sci_get_handle625 * @id:		Device Identifier626 *627 * Request for the device - NOTE: the client MUST maintain integrity of628 * usage count by balancing get_device with put_device. No refcounting is629 * managed by driver for that purpose.630 *631 * Return: 0 if all went fine, else return appropriate error.632 */633static int ti_sci_cmd_get_device(const struct ti_sci_handle *handle, u32 id)634{635	return ti_sci_set_device_state(handle, id, 0,636				       MSG_DEVICE_SW_STATE_ON);637}638 639/**640 * ti_sci_cmd_get_device_exclusive() - command to request for device managed by641 *				       TISCI that is exclusively owned by the642 *				       requesting host.643 * @handle:	Pointer to TISCI handle as retrieved by *ti_sci_get_handle644 * @id:		Device Identifier645 *646 * Request for the device - NOTE: the client MUST maintain integrity of647 * usage count by balancing get_device with put_device. No refcounting is648 * managed by driver for that purpose.649 *650 * Return: 0 if all went fine, else return appropriate error.651 */652static int ti_sci_cmd_get_device_exclusive(const struct ti_sci_handle *handle,653					   u32 id)654{655	return ti_sci_set_device_state(handle, id,656				       MSG_FLAG_DEVICE_EXCLUSIVE,657				       MSG_DEVICE_SW_STATE_ON);658}659 660/**661 * ti_sci_cmd_idle_device() - Command to idle a device managed by TISCI662 * @handle:	Pointer to TISCI handle as retrieved by *ti_sci_get_handle663 * @id:		Device Identifier664 *665 * Request for the device - NOTE: the client MUST maintain integrity of666 * usage count by balancing get_device with put_device. No refcounting is667 * managed by driver for that purpose.668 *669 * Return: 0 if all went fine, else return appropriate error.670 */671static int ti_sci_cmd_idle_device(const struct ti_sci_handle *handle, u32 id)672{673	return ti_sci_set_device_state(handle, id, 0,674				       MSG_DEVICE_SW_STATE_RETENTION);675}676 677/**678 * ti_sci_cmd_idle_device_exclusive() - Command to idle a device managed by679 *					TISCI that is exclusively owned by680 *					requesting host.681 * @handle:	Pointer to TISCI handle as retrieved by *ti_sci_get_handle682 * @id:		Device Identifier683 *684 * Request for the device - NOTE: the client MUST maintain integrity of685 * usage count by balancing get_device with put_device. No refcounting is686 * managed by driver for that purpose.687 *688 * Return: 0 if all went fine, else return appropriate error.689 */690static int ti_sci_cmd_idle_device_exclusive(const struct ti_sci_handle *handle,691					    u32 id)692{693	return ti_sci_set_device_state(handle, id,694				       MSG_FLAG_DEVICE_EXCLUSIVE,695				       MSG_DEVICE_SW_STATE_RETENTION);696}697 698/**699 * ti_sci_cmd_put_device() - command to release a device managed by TISCI700 * @handle:	Pointer to TISCI handle as retrieved by *ti_sci_get_handle701 * @id:		Device Identifier702 *703 * Request for the device - NOTE: the client MUST maintain integrity of704 * usage count by balancing get_device with put_device. No refcounting is705 * managed by driver for that purpose.706 *707 * Return: 0 if all went fine, else return appropriate error.708 */709static int ti_sci_cmd_put_device(const struct ti_sci_handle *handle, u32 id)710{711	return ti_sci_set_device_state(handle, id,712				       0, MSG_DEVICE_SW_STATE_AUTO_OFF);713}714 715/**716 * ti_sci_cmd_dev_is_valid() - Is the device valid717 * @handle:	Pointer to TISCI handle as retrieved by *ti_sci_get_handle718 * @id:		Device Identifier719 *720 * Return: 0 if all went fine and the device ID is valid, else return721 * appropriate error.722 */723static int ti_sci_cmd_dev_is_valid(const struct ti_sci_handle *handle, u32 id)724{725	u8 unused;726 727	/* check the device state which will also tell us if the ID is valid */728	return ti_sci_get_device_state(handle, id, NULL, NULL, NULL, &unused);729}730 731/**732 * ti_sci_cmd_dev_get_clcnt() - Get context loss counter733 * @handle:	Pointer to TISCI handle734 * @id:		Device Identifier735 * @count:	Pointer to Context Loss counter to populate736 *737 * Return: 0 if all went fine, else return appropriate error.738 */739static int ti_sci_cmd_dev_get_clcnt(const struct ti_sci_handle *handle, u32 id,740				    u32 *count)741{742	return ti_sci_get_device_state(handle, id, count, NULL, NULL, NULL);743}744 745/**746 * ti_sci_cmd_dev_is_idle() - Check if the device is requested to be idle747 * @handle:	Pointer to TISCI handle748 * @id:		Device Identifier749 * @r_state:	true if requested to be idle750 *751 * Return: 0 if all went fine, else return appropriate error.752 */753static int ti_sci_cmd_dev_is_idle(const struct ti_sci_handle *handle, u32 id,754				  bool *r_state)755{756	int ret;757	u8 state;758 759	if (!r_state)760		return -EINVAL;761 762	ret = ti_sci_get_device_state(handle, id, NULL, NULL, &state, NULL);763	if (ret)764		return ret;765 766	*r_state = (state == MSG_DEVICE_SW_STATE_RETENTION);767 768	return 0;769}770 771/**772 * ti_sci_cmd_dev_is_stop() - Check if the device is requested to be stopped773 * @handle:	Pointer to TISCI handle774 * @id:		Device Identifier775 * @r_state:	true if requested to be stopped776 * @curr_state:	true if currently stopped.777 *778 * Return: 0 if all went fine, else return appropriate error.779 */780static int ti_sci_cmd_dev_is_stop(const struct ti_sci_handle *handle, u32 id,781				  bool *r_state,  bool *curr_state)782{783	int ret;784	u8 p_state, c_state;785 786	if (!r_state && !curr_state)787		return -EINVAL;788 789	ret =790	    ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);791	if (ret)792		return ret;793 794	if (r_state)795		*r_state = (p_state == MSG_DEVICE_SW_STATE_AUTO_OFF);796	if (curr_state)797		*curr_state = (c_state == MSG_DEVICE_HW_STATE_OFF);798 799	return 0;800}801 802/**803 * ti_sci_cmd_dev_is_on() - Check if the device is requested to be ON804 * @handle:	Pointer to TISCI handle805 * @id:		Device Identifier806 * @r_state:	true if requested to be ON807 * @curr_state:	true if currently ON and active808 *809 * Return: 0 if all went fine, else return appropriate error.810 */811static int ti_sci_cmd_dev_is_on(const struct ti_sci_handle *handle, u32 id,812				bool *r_state,  bool *curr_state)813{814	int ret;815	u8 p_state, c_state;816 817	if (!r_state && !curr_state)818		return -EINVAL;819 820	ret =821	    ti_sci_get_device_state(handle, id, NULL, NULL, &p_state, &c_state);822	if (ret)823		return ret;824 825	if (r_state)826		*r_state = (p_state == MSG_DEVICE_SW_STATE_ON);827	if (curr_state)828		*curr_state = (c_state == MSG_DEVICE_HW_STATE_ON);829 830	return 0;831}832 833/**834 * ti_sci_cmd_dev_is_trans() - Check if the device is currently transitioning835 * @handle:	Pointer to TISCI handle836 * @id:		Device Identifier837 * @curr_state:	true if currently transitioning.838 *839 * Return: 0 if all went fine, else return appropriate error.840 */841static int ti_sci_cmd_dev_is_trans(const struct ti_sci_handle *handle, u32 id,842				   bool *curr_state)843{844	int ret;845	u8 state;846 847	if (!curr_state)848		return -EINVAL;849 850	ret = ti_sci_get_device_state(handle, id, NULL, NULL, NULL, &state);851	if (ret)852		return ret;853 854	*curr_state = (state == MSG_DEVICE_HW_STATE_TRANS);855 856	return 0;857}858 859/**860 * ti_sci_cmd_set_device_resets() - command to set resets for device managed861 *				    by TISCI862 * @handle:	Pointer to TISCI handle as retrieved by *ti_sci_get_handle863 * @id:		Device Identifier864 * @reset_state: Device specific reset bit field865 *866 * Return: 0 if all went fine, else return appropriate error.867 */868static int ti_sci_cmd_set_device_resets(const struct ti_sci_handle *handle,869					u32 id, u32 reset_state)870{871	struct ti_sci_info *info;872	struct ti_sci_msg_req_set_device_resets *req;873	struct ti_sci_msg_hdr *resp;874	struct ti_sci_xfer *xfer;875	struct device *dev;876	int ret = 0;877 878	if (IS_ERR(handle))879		return PTR_ERR(handle);880	if (!handle)881		return -EINVAL;882 883	info = handle_to_ti_sci_info(handle);884	dev = info->dev;885 886	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_DEVICE_RESETS,887				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,888				   sizeof(*req), sizeof(*resp));889	if (IS_ERR(xfer)) {890		ret = PTR_ERR(xfer);891		dev_err(dev, "Message alloc failed(%d)\n", ret);892		return ret;893	}894	req = (struct ti_sci_msg_req_set_device_resets *)xfer->xfer_buf;895	req->id = id;896	req->resets = reset_state;897 898	ret = ti_sci_do_xfer(info, xfer);899	if (ret) {900		dev_err(dev, "Mbox send fail %d\n", ret);901		goto fail;902	}903 904	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;905 906	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;907 908fail:909	ti_sci_put_one_xfer(&info->minfo, xfer);910 911	return ret;912}913 914/**915 * ti_sci_cmd_get_device_resets() - Get reset state for device managed916 *				    by TISCI917 * @handle:		Pointer to TISCI handle918 * @id:			Device Identifier919 * @reset_state:	Pointer to reset state to populate920 *921 * Return: 0 if all went fine, else return appropriate error.922 */923static int ti_sci_cmd_get_device_resets(const struct ti_sci_handle *handle,924					u32 id, u32 *reset_state)925{926	return ti_sci_get_device_state(handle, id, NULL, reset_state, NULL,927				       NULL);928}929 930/**931 * ti_sci_set_clock_state() - Set clock state helper932 * @handle:	pointer to TI SCI handle933 * @dev_id:	Device identifier this request is for934 * @clk_id:	Clock identifier for the device for this request.935 *		Each device has it's own set of clock inputs. This indexes936 *		which clock input to modify.937 * @flags:	Header flags as needed938 * @state:	State to request for the clock.939 *940 * Return: 0 if all went well, else returns appropriate error value.941 */942static int ti_sci_set_clock_state(const struct ti_sci_handle *handle,943				  u32 dev_id, u32 clk_id,944				  u32 flags, u8 state)945{946	struct ti_sci_info *info;947	struct ti_sci_msg_req_set_clock_state *req;948	struct ti_sci_msg_hdr *resp;949	struct ti_sci_xfer *xfer;950	struct device *dev;951	int ret = 0;952 953	if (IS_ERR(handle))954		return PTR_ERR(handle);955	if (!handle)956		return -EINVAL;957 958	info = handle_to_ti_sci_info(handle);959	dev = info->dev;960 961	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CLOCK_STATE,962				   flags | TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,963				   sizeof(*req), sizeof(*resp));964	if (IS_ERR(xfer)) {965		ret = PTR_ERR(xfer);966		dev_err(dev, "Message alloc failed(%d)\n", ret);967		return ret;968	}969	req = (struct ti_sci_msg_req_set_clock_state *)xfer->xfer_buf;970	req->dev_id = dev_id;971	if (clk_id < 255) {972		req->clk_id = clk_id;973	} else {974		req->clk_id = 255;975		req->clk_id_32 = clk_id;976	}977	req->request_state = state;978 979	ret = ti_sci_do_xfer(info, xfer);980	if (ret) {981		dev_err(dev, "Mbox send fail %d\n", ret);982		goto fail;983	}984 985	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;986 987	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;988 989fail:990	ti_sci_put_one_xfer(&info->minfo, xfer);991 992	return ret;993}994 995/**996 * ti_sci_cmd_get_clock_state() - Get clock state helper997 * @handle:	pointer to TI SCI handle998 * @dev_id:	Device identifier this request is for999 * @clk_id:	Clock identifier for the device for this request.1000 *		Each device has it's own set of clock inputs. This indexes1001 *		which clock input to modify.1002 * @programmed_state:	State requested for clock to move to1003 * @current_state:	State that the clock is currently in1004 *1005 * Return: 0 if all went well, else returns appropriate error value.1006 */1007static int ti_sci_cmd_get_clock_state(const struct ti_sci_handle *handle,1008				      u32 dev_id, u32 clk_id,1009				      u8 *programmed_state, u8 *current_state)1010{1011	struct ti_sci_info *info;1012	struct ti_sci_msg_req_get_clock_state *req;1013	struct ti_sci_msg_resp_get_clock_state *resp;1014	struct ti_sci_xfer *xfer;1015	struct device *dev;1016	int ret = 0;1017 1018	if (IS_ERR(handle))1019		return PTR_ERR(handle);1020	if (!handle)1021		return -EINVAL;1022 1023	if (!programmed_state && !current_state)1024		return -EINVAL;1025 1026	info = handle_to_ti_sci_info(handle);1027	dev = info->dev;1028 1029	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_CLOCK_STATE,1030				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1031				   sizeof(*req), sizeof(*resp));1032	if (IS_ERR(xfer)) {1033		ret = PTR_ERR(xfer);1034		dev_err(dev, "Message alloc failed(%d)\n", ret);1035		return ret;1036	}1037	req = (struct ti_sci_msg_req_get_clock_state *)xfer->xfer_buf;1038	req->dev_id = dev_id;1039	if (clk_id < 255) {1040		req->clk_id = clk_id;1041	} else {1042		req->clk_id = 255;1043		req->clk_id_32 = clk_id;1044	}1045 1046	ret = ti_sci_do_xfer(info, xfer);1047	if (ret) {1048		dev_err(dev, "Mbox send fail %d\n", ret);1049		goto fail;1050	}1051 1052	resp = (struct ti_sci_msg_resp_get_clock_state *)xfer->xfer_buf;1053 1054	if (!ti_sci_is_response_ack(resp)) {1055		ret = -ENODEV;1056		goto fail;1057	}1058 1059	if (programmed_state)1060		*programmed_state = resp->programmed_state;1061	if (current_state)1062		*current_state = resp->current_state;1063 1064fail:1065	ti_sci_put_one_xfer(&info->minfo, xfer);1066 1067	return ret;1068}1069 1070/**1071 * ti_sci_cmd_get_clock() - Get control of a clock from TI SCI1072 * @handle:	pointer to TI SCI handle1073 * @dev_id:	Device identifier this request is for1074 * @clk_id:	Clock identifier for the device for this request.1075 *		Each device has it's own set of clock inputs. This indexes1076 *		which clock input to modify.1077 * @needs_ssc: 'true' if Spread Spectrum clock is desired, else 'false'1078 * @can_change_freq: 'true' if frequency change is desired, else 'false'1079 * @enable_input_term: 'true' if input termination is desired, else 'false'1080 *1081 * Return: 0 if all went well, else returns appropriate error value.1082 */1083static int ti_sci_cmd_get_clock(const struct ti_sci_handle *handle, u32 dev_id,1084				u32 clk_id, bool needs_ssc,1085				bool can_change_freq, bool enable_input_term)1086{1087	u32 flags = 0;1088 1089	flags |= needs_ssc ? MSG_FLAG_CLOCK_ALLOW_SSC : 0;1090	flags |= can_change_freq ? MSG_FLAG_CLOCK_ALLOW_FREQ_CHANGE : 0;1091	flags |= enable_input_term ? MSG_FLAG_CLOCK_INPUT_TERM : 0;1092 1093	return ti_sci_set_clock_state(handle, dev_id, clk_id, flags,1094				      MSG_CLOCK_SW_STATE_REQ);1095}1096 1097/**1098 * ti_sci_cmd_idle_clock() - Idle a clock which is in our control1099 * @handle:	pointer to TI SCI handle1100 * @dev_id:	Device identifier this request is for1101 * @clk_id:	Clock identifier for the device for this request.1102 *		Each device has it's own set of clock inputs. This indexes1103 *		which clock input to modify.1104 *1105 * NOTE: This clock must have been requested by get_clock previously.1106 *1107 * Return: 0 if all went well, else returns appropriate error value.1108 */1109static int ti_sci_cmd_idle_clock(const struct ti_sci_handle *handle,1110				 u32 dev_id, u32 clk_id)1111{1112	return ti_sci_set_clock_state(handle, dev_id, clk_id,1113				      MSG_FLAG_CLOCK_ALLOW_FREQ_CHANGE,1114				      MSG_CLOCK_SW_STATE_UNREQ);1115}1116 1117/**1118 * ti_sci_cmd_put_clock() - Release a clock from our control back to TISCI1119 * @handle:	pointer to TI SCI handle1120 * @dev_id:	Device identifier this request is for1121 * @clk_id:	Clock identifier for the device for this request.1122 *		Each device has it's own set of clock inputs. This indexes1123 *		which clock input to modify.1124 *1125 * NOTE: This clock must have been requested by get_clock previously.1126 *1127 * Return: 0 if all went well, else returns appropriate error value.1128 */1129static int ti_sci_cmd_put_clock(const struct ti_sci_handle *handle,1130				u32 dev_id, u32 clk_id)1131{1132	return ti_sci_set_clock_state(handle, dev_id, clk_id,1133				      MSG_FLAG_CLOCK_ALLOW_FREQ_CHANGE,1134				      MSG_CLOCK_SW_STATE_AUTO);1135}1136 1137/**1138 * ti_sci_cmd_clk_is_auto() - Is the clock being auto managed1139 * @handle:	pointer to TI SCI handle1140 * @dev_id:	Device identifier this request is for1141 * @clk_id:	Clock identifier for the device for this request.1142 *		Each device has it's own set of clock inputs. This indexes1143 *		which clock input to modify.1144 * @req_state: state indicating if the clock is auto managed1145 *1146 * Return: 0 if all went well, else returns appropriate error value.1147 */1148static int ti_sci_cmd_clk_is_auto(const struct ti_sci_handle *handle,1149				  u32 dev_id, u32 clk_id, bool *req_state)1150{1151	u8 state = 0;1152	int ret;1153 1154	if (!req_state)1155		return -EINVAL;1156 1157	ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id, &state, NULL);1158	if (ret)1159		return ret;1160 1161	*req_state = (state == MSG_CLOCK_SW_STATE_AUTO);1162	return 0;1163}1164 1165/**1166 * ti_sci_cmd_clk_is_on() - Is the clock ON1167 * @handle:	pointer to TI SCI handle1168 * @dev_id:	Device identifier this request is for1169 * @clk_id:	Clock identifier for the device for this request.1170 *		Each device has it's own set of clock inputs. This indexes1171 *		which clock input to modify.1172 * @req_state: state indicating if the clock is managed by us and enabled1173 * @curr_state: state indicating if the clock is ready for operation1174 *1175 * Return: 0 if all went well, else returns appropriate error value.1176 */1177static int ti_sci_cmd_clk_is_on(const struct ti_sci_handle *handle, u32 dev_id,1178				u32 clk_id, bool *req_state, bool *curr_state)1179{1180	u8 c_state = 0, r_state = 0;1181	int ret;1182 1183	if (!req_state && !curr_state)1184		return -EINVAL;1185 1186	ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,1187					 &r_state, &c_state);1188	if (ret)1189		return ret;1190 1191	if (req_state)1192		*req_state = (r_state == MSG_CLOCK_SW_STATE_REQ);1193	if (curr_state)1194		*curr_state = (c_state == MSG_CLOCK_HW_STATE_READY);1195	return 0;1196}1197 1198/**1199 * ti_sci_cmd_clk_is_off() - Is the clock OFF1200 * @handle:	pointer to TI SCI handle1201 * @dev_id:	Device identifier this request is for1202 * @clk_id:	Clock identifier for the device for this request.1203 *		Each device has it's own set of clock inputs. This indexes1204 *		which clock input to modify.1205 * @req_state: state indicating if the clock is managed by us and disabled1206 * @curr_state: state indicating if the clock is NOT ready for operation1207 *1208 * Return: 0 if all went well, else returns appropriate error value.1209 */1210static int ti_sci_cmd_clk_is_off(const struct ti_sci_handle *handle, u32 dev_id,1211				 u32 clk_id, bool *req_state, bool *curr_state)1212{1213	u8 c_state = 0, r_state = 0;1214	int ret;1215 1216	if (!req_state && !curr_state)1217		return -EINVAL;1218 1219	ret = ti_sci_cmd_get_clock_state(handle, dev_id, clk_id,1220					 &r_state, &c_state);1221	if (ret)1222		return ret;1223 1224	if (req_state)1225		*req_state = (r_state == MSG_CLOCK_SW_STATE_UNREQ);1226	if (curr_state)1227		*curr_state = (c_state == MSG_CLOCK_HW_STATE_NOT_READY);1228	return 0;1229}1230 1231/**1232 * ti_sci_cmd_clk_set_parent() - Set the clock source of a specific device clock1233 * @handle:	pointer to TI SCI handle1234 * @dev_id:	Device identifier this request is for1235 * @clk_id:	Clock identifier for the device for this request.1236 *		Each device has it's own set of clock inputs. This indexes1237 *		which clock input to modify.1238 * @parent_id:	Parent clock identifier to set1239 *1240 * Return: 0 if all went well, else returns appropriate error value.1241 */1242static int ti_sci_cmd_clk_set_parent(const struct ti_sci_handle *handle,1243				     u32 dev_id, u32 clk_id, u32 parent_id)1244{1245	struct ti_sci_info *info;1246	struct ti_sci_msg_req_set_clock_parent *req;1247	struct ti_sci_msg_hdr *resp;1248	struct ti_sci_xfer *xfer;1249	struct device *dev;1250	int ret = 0;1251 1252	if (IS_ERR(handle))1253		return PTR_ERR(handle);1254	if (!handle)1255		return -EINVAL;1256 1257	info = handle_to_ti_sci_info(handle);1258	dev = info->dev;1259 1260	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CLOCK_PARENT,1261				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1262				   sizeof(*req), sizeof(*resp));1263	if (IS_ERR(xfer)) {1264		ret = PTR_ERR(xfer);1265		dev_err(dev, "Message alloc failed(%d)\n", ret);1266		return ret;1267	}1268	req = (struct ti_sci_msg_req_set_clock_parent *)xfer->xfer_buf;1269	req->dev_id = dev_id;1270	if (clk_id < 255) {1271		req->clk_id = clk_id;1272	} else {1273		req->clk_id = 255;1274		req->clk_id_32 = clk_id;1275	}1276	if (parent_id < 255) {1277		req->parent_id = parent_id;1278	} else {1279		req->parent_id = 255;1280		req->parent_id_32 = parent_id;1281	}1282 1283	ret = ti_sci_do_xfer(info, xfer);1284	if (ret) {1285		dev_err(dev, "Mbox send fail %d\n", ret);1286		goto fail;1287	}1288 1289	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;1290 1291	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;1292 1293fail:1294	ti_sci_put_one_xfer(&info->minfo, xfer);1295 1296	return ret;1297}1298 1299/**1300 * ti_sci_cmd_clk_get_parent() - Get current parent clock source1301 * @handle:	pointer to TI SCI handle1302 * @dev_id:	Device identifier this request is for1303 * @clk_id:	Clock identifier for the device for this request.1304 *		Each device has it's own set of clock inputs. This indexes1305 *		which clock input to modify.1306 * @parent_id:	Current clock parent1307 *1308 * Return: 0 if all went well, else returns appropriate error value.1309 */1310static int ti_sci_cmd_clk_get_parent(const struct ti_sci_handle *handle,1311				     u32 dev_id, u32 clk_id, u32 *parent_id)1312{1313	struct ti_sci_info *info;1314	struct ti_sci_msg_req_get_clock_parent *req;1315	struct ti_sci_msg_resp_get_clock_parent *resp;1316	struct ti_sci_xfer *xfer;1317	struct device *dev;1318	int ret = 0;1319 1320	if (IS_ERR(handle))1321		return PTR_ERR(handle);1322	if (!handle || !parent_id)1323		return -EINVAL;1324 1325	info = handle_to_ti_sci_info(handle);1326	dev = info->dev;1327 1328	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_CLOCK_PARENT,1329				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1330				   sizeof(*req), sizeof(*resp));1331	if (IS_ERR(xfer)) {1332		ret = PTR_ERR(xfer);1333		dev_err(dev, "Message alloc failed(%d)\n", ret);1334		return ret;1335	}1336	req = (struct ti_sci_msg_req_get_clock_parent *)xfer->xfer_buf;1337	req->dev_id = dev_id;1338	if (clk_id < 255) {1339		req->clk_id = clk_id;1340	} else {1341		req->clk_id = 255;1342		req->clk_id_32 = clk_id;1343	}1344 1345	ret = ti_sci_do_xfer(info, xfer);1346	if (ret) {1347		dev_err(dev, "Mbox send fail %d\n", ret);1348		goto fail;1349	}1350 1351	resp = (struct ti_sci_msg_resp_get_clock_parent *)xfer->xfer_buf;1352 1353	if (!ti_sci_is_response_ack(resp)) {1354		ret = -ENODEV;1355	} else {1356		if (resp->parent_id < 255)1357			*parent_id = resp->parent_id;1358		else1359			*parent_id = resp->parent_id_32;1360	}1361 1362fail:1363	ti_sci_put_one_xfer(&info->minfo, xfer);1364 1365	return ret;1366}1367 1368/**1369 * ti_sci_cmd_clk_get_num_parents() - Get num parents of the current clk source1370 * @handle:	pointer to TI SCI handle1371 * @dev_id:	Device identifier this request is for1372 * @clk_id:	Clock identifier for the device for this request.1373 *		Each device has it's own set of clock inputs. This indexes1374 *		which clock input to modify.1375 * @num_parents: Returns he number of parents to the current clock.1376 *1377 * Return: 0 if all went well, else returns appropriate error value.1378 */1379static int ti_sci_cmd_clk_get_num_parents(const struct ti_sci_handle *handle,1380					  u32 dev_id, u32 clk_id,1381					  u32 *num_parents)1382{1383	struct ti_sci_info *info;1384	struct ti_sci_msg_req_get_clock_num_parents *req;1385	struct ti_sci_msg_resp_get_clock_num_parents *resp;1386	struct ti_sci_xfer *xfer;1387	struct device *dev;1388	int ret = 0;1389 1390	if (IS_ERR(handle))1391		return PTR_ERR(handle);1392	if (!handle || !num_parents)1393		return -EINVAL;1394 1395	info = handle_to_ti_sci_info(handle);1396	dev = info->dev;1397 1398	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_NUM_CLOCK_PARENTS,1399				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1400				   sizeof(*req), sizeof(*resp));1401	if (IS_ERR(xfer)) {1402		ret = PTR_ERR(xfer);1403		dev_err(dev, "Message alloc failed(%d)\n", ret);1404		return ret;1405	}1406	req = (struct ti_sci_msg_req_get_clock_num_parents *)xfer->xfer_buf;1407	req->dev_id = dev_id;1408	if (clk_id < 255) {1409		req->clk_id = clk_id;1410	} else {1411		req->clk_id = 255;1412		req->clk_id_32 = clk_id;1413	}1414 1415	ret = ti_sci_do_xfer(info, xfer);1416	if (ret) {1417		dev_err(dev, "Mbox send fail %d\n", ret);1418		goto fail;1419	}1420 1421	resp = (struct ti_sci_msg_resp_get_clock_num_parents *)xfer->xfer_buf;1422 1423	if (!ti_sci_is_response_ack(resp)) {1424		ret = -ENODEV;1425	} else {1426		if (resp->num_parents < 255)1427			*num_parents = resp->num_parents;1428		else1429			*num_parents = resp->num_parents_32;1430	}1431 1432fail:1433	ti_sci_put_one_xfer(&info->minfo, xfer);1434 1435	return ret;1436}1437 1438/**1439 * ti_sci_cmd_clk_get_match_freq() - Find a good match for frequency1440 * @handle:	pointer to TI SCI handle1441 * @dev_id:	Device identifier this request is for1442 * @clk_id:	Clock identifier for the device for this request.1443 *		Each device has it's own set of clock inputs. This indexes1444 *		which clock input to modify.1445 * @min_freq:	The minimum allowable frequency in Hz. This is the minimum1446 *		allowable programmed frequency and does not account for clock1447 *		tolerances and jitter.1448 * @target_freq: The target clock frequency in Hz. A frequency will be1449 *		processed as close to this target frequency as possible.1450 * @max_freq:	The maximum allowable frequency in Hz. This is the maximum1451 *		allowable programmed frequency and does not account for clock1452 *		tolerances and jitter.1453 * @match_freq:	Frequency match in Hz response.1454 *1455 * Return: 0 if all went well, else returns appropriate error value.1456 */1457static int ti_sci_cmd_clk_get_match_freq(const struct ti_sci_handle *handle,1458					 u32 dev_id, u32 clk_id, u64 min_freq,1459					 u64 target_freq, u64 max_freq,1460					 u64 *match_freq)1461{1462	struct ti_sci_info *info;1463	struct ti_sci_msg_req_query_clock_freq *req;1464	struct ti_sci_msg_resp_query_clock_freq *resp;1465	struct ti_sci_xfer *xfer;1466	struct device *dev;1467	int ret = 0;1468 1469	if (IS_ERR(handle))1470		return PTR_ERR(handle);1471	if (!handle || !match_freq)1472		return -EINVAL;1473 1474	info = handle_to_ti_sci_info(handle);1475	dev = info->dev;1476 1477	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_QUERY_CLOCK_FREQ,1478				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1479				   sizeof(*req), sizeof(*resp));1480	if (IS_ERR(xfer)) {1481		ret = PTR_ERR(xfer);1482		dev_err(dev, "Message alloc failed(%d)\n", ret);1483		return ret;1484	}1485	req = (struct ti_sci_msg_req_query_clock_freq *)xfer->xfer_buf;1486	req->dev_id = dev_id;1487	if (clk_id < 255) {1488		req->clk_id = clk_id;1489	} else {1490		req->clk_id = 255;1491		req->clk_id_32 = clk_id;1492	}1493	req->min_freq_hz = min_freq;1494	req->target_freq_hz = target_freq;1495	req->max_freq_hz = max_freq;1496 1497	ret = ti_sci_do_xfer(info, xfer);1498	if (ret) {1499		dev_err(dev, "Mbox send fail %d\n", ret);1500		goto fail;1501	}1502 1503	resp = (struct ti_sci_msg_resp_query_clock_freq *)xfer->xfer_buf;1504 1505	if (!ti_sci_is_response_ack(resp))1506		ret = -ENODEV;1507	else1508		*match_freq = resp->freq_hz;1509 1510fail:1511	ti_sci_put_one_xfer(&info->minfo, xfer);1512 1513	return ret;1514}1515 1516/**1517 * ti_sci_cmd_clk_set_freq() - Set a frequency for clock1518 * @handle:	pointer to TI SCI handle1519 * @dev_id:	Device identifier this request is for1520 * @clk_id:	Clock identifier for the device for this request.1521 *		Each device has it's own set of clock inputs. This indexes1522 *		which clock input to modify.1523 * @min_freq:	The minimum allowable frequency in Hz. This is the minimum1524 *		allowable programmed frequency and does not account for clock1525 *		tolerances and jitter.1526 * @target_freq: The target clock frequency in Hz. A frequency will be1527 *		processed as close to this target frequency as possible.1528 * @max_freq:	The maximum allowable frequency in Hz. This is the maximum1529 *		allowable programmed frequency and does not account for clock1530 *		tolerances and jitter.1531 *1532 * Return: 0 if all went well, else returns appropriate error value.1533 */1534static int ti_sci_cmd_clk_set_freq(const struct ti_sci_handle *handle,1535				   u32 dev_id, u32 clk_id, u64 min_freq,1536				   u64 target_freq, u64 max_freq)1537{1538	struct ti_sci_info *info;1539	struct ti_sci_msg_req_set_clock_freq *req;1540	struct ti_sci_msg_hdr *resp;1541	struct ti_sci_xfer *xfer;1542	struct device *dev;1543	int ret = 0;1544 1545	if (IS_ERR(handle))1546		return PTR_ERR(handle);1547	if (!handle)1548		return -EINVAL;1549 1550	info = handle_to_ti_sci_info(handle);1551	dev = info->dev;1552 1553	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CLOCK_FREQ,1554				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1555				   sizeof(*req), sizeof(*resp));1556	if (IS_ERR(xfer)) {1557		ret = PTR_ERR(xfer);1558		dev_err(dev, "Message alloc failed(%d)\n", ret);1559		return ret;1560	}1561	req = (struct ti_sci_msg_req_set_clock_freq *)xfer->xfer_buf;1562	req->dev_id = dev_id;1563	if (clk_id < 255) {1564		req->clk_id = clk_id;1565	} else {1566		req->clk_id = 255;1567		req->clk_id_32 = clk_id;1568	}1569	req->min_freq_hz = min_freq;1570	req->target_freq_hz = target_freq;1571	req->max_freq_hz = max_freq;1572 1573	ret = ti_sci_do_xfer(info, xfer);1574	if (ret) {1575		dev_err(dev, "Mbox send fail %d\n", ret);1576		goto fail;1577	}1578 1579	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;1580 1581	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;1582 1583fail:1584	ti_sci_put_one_xfer(&info->minfo, xfer);1585 1586	return ret;1587}1588 1589/**1590 * ti_sci_cmd_clk_get_freq() - Get current frequency1591 * @handle:	pointer to TI SCI handle1592 * @dev_id:	Device identifier this request is for1593 * @clk_id:	Clock identifier for the device for this request.1594 *		Each device has it's own set of clock inputs. This indexes1595 *		which clock input to modify.1596 * @freq:	Currently frequency in Hz1597 *1598 * Return: 0 if all went well, else returns appropriate error value.1599 */1600static int ti_sci_cmd_clk_get_freq(const struct ti_sci_handle *handle,1601				   u32 dev_id, u32 clk_id, u64 *freq)1602{1603	struct ti_sci_info *info;1604	struct ti_sci_msg_req_get_clock_freq *req;1605	struct ti_sci_msg_resp_get_clock_freq *resp;1606	struct ti_sci_xfer *xfer;1607	struct device *dev;1608	int ret = 0;1609 1610	if (IS_ERR(handle))1611		return PTR_ERR(handle);1612	if (!handle || !freq)1613		return -EINVAL;1614 1615	info = handle_to_ti_sci_info(handle);1616	dev = info->dev;1617 1618	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_CLOCK_FREQ,1619				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1620				   sizeof(*req), sizeof(*resp));1621	if (IS_ERR(xfer)) {1622		ret = PTR_ERR(xfer);1623		dev_err(dev, "Message alloc failed(%d)\n", ret);1624		return ret;1625	}1626	req = (struct ti_sci_msg_req_get_clock_freq *)xfer->xfer_buf;1627	req->dev_id = dev_id;1628	if (clk_id < 255) {1629		req->clk_id = clk_id;1630	} else {1631		req->clk_id = 255;1632		req->clk_id_32 = clk_id;1633	}1634 1635	ret = ti_sci_do_xfer(info, xfer);1636	if (ret) {1637		dev_err(dev, "Mbox send fail %d\n", ret);1638		goto fail;1639	}1640 1641	resp = (struct ti_sci_msg_resp_get_clock_freq *)xfer->xfer_buf;1642 1643	if (!ti_sci_is_response_ack(resp))1644		ret = -ENODEV;1645	else1646		*freq = resp->freq_hz;1647 1648fail:1649	ti_sci_put_one_xfer(&info->minfo, xfer);1650 1651	return ret;1652}1653 1654static int ti_sci_cmd_core_reboot(const struct ti_sci_handle *handle)1655{1656	struct ti_sci_info *info;1657	struct ti_sci_msg_req_reboot *req;1658	struct ti_sci_msg_hdr *resp;1659	struct ti_sci_xfer *xfer;1660	struct device *dev;1661	int ret = 0;1662 1663	if (IS_ERR(handle))1664		return PTR_ERR(handle);1665	if (!handle)1666		return -EINVAL;1667 1668	info = handle_to_ti_sci_info(handle);1669	dev = info->dev;1670 1671	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SYS_RESET,1672				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1673				   sizeof(*req), sizeof(*resp));1674	if (IS_ERR(xfer)) {1675		ret = PTR_ERR(xfer);1676		dev_err(dev, "Message alloc failed(%d)\n", ret);1677		return ret;1678	}1679	req = (struct ti_sci_msg_req_reboot *)xfer->xfer_buf;1680 1681	ret = ti_sci_do_xfer(info, xfer);1682	if (ret) {1683		dev_err(dev, "Mbox send fail %d\n", ret);1684		goto fail;1685	}1686 1687	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;1688 1689	if (!ti_sci_is_response_ack(resp))1690		ret = -ENODEV;1691	else1692		ret = 0;1693 1694fail:1695	ti_sci_put_one_xfer(&info->minfo, xfer);1696 1697	return ret;1698}1699 1700/**1701 * ti_sci_get_resource_range - Helper to get a range of resources assigned1702 *			       to a host. Resource is uniquely identified by1703 *			       type and subtype.1704 * @handle:		Pointer to TISCI handle.1705 * @dev_id:		TISCI device ID.1706 * @subtype:		Resource assignment subtype that is being requested1707 *			from the given device.1708 * @s_host:		Host processor ID to which the resources are allocated1709 * @desc:		Pointer to ti_sci_resource_desc to be updated with the1710 *			resource range start index and number of resources1711 *1712 * Return: 0 if all went fine, else return appropriate error.1713 */1714static int ti_sci_get_resource_range(const struct ti_sci_handle *handle,1715				     u32 dev_id, u8 subtype, u8 s_host,1716				     struct ti_sci_resource_desc *desc)1717{1718	struct ti_sci_msg_resp_get_resource_range *resp;1719	struct ti_sci_msg_req_get_resource_range *req;1720	struct ti_sci_xfer *xfer;1721	struct ti_sci_info *info;1722	struct device *dev;1723	int ret = 0;1724 1725	if (IS_ERR(handle))1726		return PTR_ERR(handle);1727	if (!handle || !desc)1728		return -EINVAL;1729 1730	info = handle_to_ti_sci_info(handle);1731	dev = info->dev;1732 1733	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_RESOURCE_RANGE,1734				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1735				   sizeof(*req), sizeof(*resp));1736	if (IS_ERR(xfer)) {1737		ret = PTR_ERR(xfer);1738		dev_err(dev, "Message alloc failed(%d)\n", ret);1739		return ret;1740	}1741 1742	req = (struct ti_sci_msg_req_get_resource_range *)xfer->xfer_buf;1743	req->secondary_host = s_host;1744	req->type = dev_id & MSG_RM_RESOURCE_TYPE_MASK;1745	req->subtype = subtype & MSG_RM_RESOURCE_SUBTYPE_MASK;1746 1747	ret = ti_sci_do_xfer(info, xfer);1748	if (ret) {1749		dev_err(dev, "Mbox send fail %d\n", ret);1750		goto fail;1751	}1752 1753	resp = (struct ti_sci_msg_resp_get_resource_range *)xfer->xfer_buf;1754 1755	if (!ti_sci_is_response_ack(resp)) {1756		ret = -ENODEV;1757	} else if (!resp->range_num && !resp->range_num_sec) {1758		/* Neither of the two resource range is valid */1759		ret = -ENODEV;1760	} else {1761		desc->start = resp->range_start;1762		desc->num = resp->range_num;1763		desc->start_sec = resp->range_start_sec;1764		desc->num_sec = resp->range_num_sec;1765	}1766 1767fail:1768	ti_sci_put_one_xfer(&info->minfo, xfer);1769 1770	return ret;1771}1772 1773/**1774 * ti_sci_cmd_get_resource_range - Get a range of resources assigned to host1775 *				   that is same as ti sci interface host.1776 * @handle:		Pointer to TISCI handle.1777 * @dev_id:		TISCI device ID.1778 * @subtype:		Resource assignment subtype that is being requested1779 *			from the given device.1780 * @desc:		Pointer to ti_sci_resource_desc to be updated with the1781 *			resource range start index and number of resources1782 *1783 * Return: 0 if all went fine, else return appropriate error.1784 */1785static int ti_sci_cmd_get_resource_range(const struct ti_sci_handle *handle,1786					 u32 dev_id, u8 subtype,1787					 struct ti_sci_resource_desc *desc)1788{1789	return ti_sci_get_resource_range(handle, dev_id, subtype,1790					 TI_SCI_IRQ_SECONDARY_HOST_INVALID,1791					 desc);1792}1793 1794/**1795 * ti_sci_cmd_get_resource_range_from_shost - Get a range of resources1796 *					      assigned to a specified host.1797 * @handle:		Pointer to TISCI handle.1798 * @dev_id:		TISCI device ID.1799 * @subtype:		Resource assignment subtype that is being requested1800 *			from the given device.1801 * @s_host:		Host processor ID to which the resources are allocated1802 * @desc:		Pointer to ti_sci_resource_desc to be updated with the1803 *			resource range start index and number of resources1804 *1805 * Return: 0 if all went fine, else return appropriate error.1806 */1807static1808int ti_sci_cmd_get_resource_range_from_shost(const struct ti_sci_handle *handle,1809					     u32 dev_id, u8 subtype, u8 s_host,1810					     struct ti_sci_resource_desc *desc)1811{1812	return ti_sci_get_resource_range(handle, dev_id, subtype, s_host, desc);1813}1814 1815/**1816 * ti_sci_manage_irq() - Helper api to configure/release the irq route between1817 *			 the requested source and destination1818 * @handle:		Pointer to TISCI handle.1819 * @valid_params:	Bit fields defining the validity of certain params1820 * @src_id:		Device ID of the IRQ source1821 * @src_index:		IRQ source index within the source device1822 * @dst_id:		Device ID of the IRQ destination1823 * @dst_host_irq:	IRQ number of the destination device1824 * @ia_id:		Device ID of the IA, if the IRQ flows through this IA1825 * @vint:		Virtual interrupt to be used within the IA1826 * @global_event:	Global event number to be used for the requesting event1827 * @vint_status_bit:	Virtual interrupt status bit to be used for the event1828 * @s_host:		Secondary host ID to which the irq/event is being1829 *			requested for.1830 * @type:		Request type irq set or release.1831 *1832 * Return: 0 if all went fine, else return appropriate error.1833 */1834static int ti_sci_manage_irq(const struct ti_sci_handle *handle,1835			     u32 valid_params, u16 src_id, u16 src_index,1836			     u16 dst_id, u16 dst_host_irq, u16 ia_id, u16 vint,1837			     u16 global_event, u8 vint_status_bit, u8 s_host,1838			     u16 type)1839{1840	struct ti_sci_msg_req_manage_irq *req;1841	struct ti_sci_msg_hdr *resp;1842	struct ti_sci_xfer *xfer;1843	struct ti_sci_info *info;1844	struct device *dev;1845	int ret = 0;1846 1847	if (IS_ERR(handle))1848		return PTR_ERR(handle);1849	if (!handle)1850		return -EINVAL;1851 1852	info = handle_to_ti_sci_info(handle);1853	dev = info->dev;1854 1855	xfer = ti_sci_get_one_xfer(info, type, TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,1856				   sizeof(*req), sizeof(*resp));1857	if (IS_ERR(xfer)) {1858		ret = PTR_ERR(xfer);1859		dev_err(dev, "Message alloc failed(%d)\n", ret);1860		return ret;1861	}1862	req = (struct ti_sci_msg_req_manage_irq *)xfer->xfer_buf;1863	req->valid_params = valid_params;1864	req->src_id = src_id;1865	req->src_index = src_index;1866	req->dst_id = dst_id;1867	req->dst_host_irq = dst_host_irq;1868	req->ia_id = ia_id;1869	req->vint = vint;1870	req->global_event = global_event;1871	req->vint_status_bit = vint_status_bit;1872	req->secondary_host = s_host;1873 1874	ret = ti_sci_do_xfer(info, xfer);1875	if (ret) {1876		dev_err(dev, "Mbox send fail %d\n", ret);1877		goto fail;1878	}1879 1880	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;1881 1882	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;1883 1884fail:1885	ti_sci_put_one_xfer(&info->minfo, xfer);1886 1887	return ret;1888}1889 1890/**1891 * ti_sci_set_irq() - Helper api to configure the irq route between the1892 *		      requested source and destination1893 * @handle:		Pointer to TISCI handle.1894 * @valid_params:	Bit fields defining the validity of certain params1895 * @src_id:		Device ID of the IRQ source1896 * @src_index:		IRQ source index within the source device1897 * @dst_id:		Device ID of the IRQ destination1898 * @dst_host_irq:	IRQ number of the destination device1899 * @ia_id:		Device ID of the IA, if the IRQ flows through this IA1900 * @vint:		Virtual interrupt to be used within the IA1901 * @global_event:	Global event number to be used for the requesting event1902 * @vint_status_bit:	Virtual interrupt status bit to be used for the event1903 * @s_host:		Secondary host ID to which the irq/event is being1904 *			requested for.1905 *1906 * Return: 0 if all went fine, else return appropriate error.1907 */1908static int ti_sci_set_irq(const struct ti_sci_handle *handle, u32 valid_params,1909			  u16 src_id, u16 src_index, u16 dst_id,1910			  u16 dst_host_irq, u16 ia_id, u16 vint,1911			  u16 global_event, u8 vint_status_bit, u8 s_host)1912{1913	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",1914		 __func__, valid_params, src_id, src_index,1915		 dst_id, dst_host_irq, ia_id, vint, global_event,1916		 vint_status_bit);1917 1918	return ti_sci_manage_irq(handle, valid_params, src_id, src_index,1919				 dst_id, dst_host_irq, ia_id, vint,1920				 global_event, vint_status_bit, s_host,1921				 TI_SCI_MSG_SET_IRQ);1922}1923 1924/**1925 * ti_sci_free_irq() - Helper api to free the irq route between the1926 *			   requested source and destination1927 * @handle:		Pointer to TISCI handle.1928 * @valid_params:	Bit fields defining the validity of certain params1929 * @src_id:		Device ID of the IRQ source1930 * @src_index:		IRQ source index within the source device1931 * @dst_id:		Device ID of the IRQ destination1932 * @dst_host_irq:	IRQ number of the destination device1933 * @ia_id:		Device ID of the IA, if the IRQ flows through this IA1934 * @vint:		Virtual interrupt to be used within the IA1935 * @global_event:	Global event number to be used for the requesting event1936 * @vint_status_bit:	Virtual interrupt status bit to be used for the event1937 * @s_host:		Secondary host ID to which the irq/event is being1938 *			requested for.1939 *1940 * Return: 0 if all went fine, else return appropriate error.1941 */1942static int ti_sci_free_irq(const struct ti_sci_handle *handle, u32 valid_params,1943			   u16 src_id, u16 src_index, u16 dst_id,1944			   u16 dst_host_irq, u16 ia_id, u16 vint,1945			   u16 global_event, u8 vint_status_bit, u8 s_host)1946{1947	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",1948		 __func__, valid_params, src_id, src_index,1949		 dst_id, dst_host_irq, ia_id, vint, global_event,1950		 vint_status_bit);1951 1952	return ti_sci_manage_irq(handle, valid_params, src_id, src_index,1953				 dst_id, dst_host_irq, ia_id, vint,1954				 global_event, vint_status_bit, s_host,1955				 TI_SCI_MSG_FREE_IRQ);1956}1957 1958/**1959 * ti_sci_cmd_set_irq() - Configure a host irq route between the requested1960 *			  source and destination.1961 * @handle:		Pointer to TISCI handle.1962 * @src_id:		Device ID of the IRQ source1963 * @src_index:		IRQ source index within the source device1964 * @dst_id:		Device ID of the IRQ destination1965 * @dst_host_irq:	IRQ number of the destination device1966 *1967 * Return: 0 if all went fine, else return appropriate error.1968 */1969static int ti_sci_cmd_set_irq(const struct ti_sci_handle *handle, u16 src_id,1970			      u16 src_index, u16 dst_id, u16 dst_host_irq)1971{1972	u32 valid_params = MSG_FLAG_DST_ID_VALID | MSG_FLAG_DST_HOST_IRQ_VALID;1973 1974	return ti_sci_set_irq(handle, valid_params, src_id, src_index, dst_id,1975			      dst_host_irq, 0, 0, 0, 0, 0);1976}1977 1978/**1979 * ti_sci_cmd_set_event_map() - Configure an event based irq route between the1980 *				requested source and Interrupt Aggregator.1981 * @handle:		Pointer to TISCI handle.1982 * @src_id:		Device ID of the IRQ source1983 * @src_index:		IRQ source index within the source device1984 * @ia_id:		Device ID of the IA, if the IRQ flows through this IA1985 * @vint:		Virtual interrupt to be used within the IA1986 * @global_event:	Global event number to be used for the requesting event1987 * @vint_status_bit:	Virtual interrupt status bit to be used for the event1988 *1989 * Return: 0 if all went fine, else return appropriate error.1990 */1991static int ti_sci_cmd_set_event_map(const struct ti_sci_handle *handle,1992				    u16 src_id, u16 src_index, u16 ia_id,1993				    u16 vint, u16 global_event,1994				    u8 vint_status_bit)1995{1996	u32 valid_params = MSG_FLAG_IA_ID_VALID | MSG_FLAG_VINT_VALID |1997			   MSG_FLAG_GLB_EVNT_VALID |1998			   MSG_FLAG_VINT_STS_BIT_VALID;1999 2000	return ti_sci_set_irq(handle, valid_params, src_id, src_index, 0, 0,2001			      ia_id, vint, global_event, vint_status_bit, 0);2002}2003 2004/**2005 * ti_sci_cmd_free_irq() - Free a host irq route between the between the2006 *			   requested source and destination.2007 * @handle:		Pointer to TISCI handle.2008 * @src_id:		Device ID of the IRQ source2009 * @src_index:		IRQ source index within the source device2010 * @dst_id:		Device ID of the IRQ destination2011 * @dst_host_irq:	IRQ number of the destination device2012 *2013 * Return: 0 if all went fine, else return appropriate error.2014 */2015static int ti_sci_cmd_free_irq(const struct ti_sci_handle *handle, u16 src_id,2016			       u16 src_index, u16 dst_id, u16 dst_host_irq)2017{2018	u32 valid_params = MSG_FLAG_DST_ID_VALID | MSG_FLAG_DST_HOST_IRQ_VALID;2019 2020	return ti_sci_free_irq(handle, valid_params, src_id, src_index, dst_id,2021			       dst_host_irq, 0, 0, 0, 0, 0);2022}2023 2024/**2025 * ti_sci_cmd_free_event_map() - Free an event map between the requested source2026 *				 and Interrupt Aggregator.2027 * @handle:		Pointer to TISCI handle.2028 * @src_id:		Device ID of the IRQ source2029 * @src_index:		IRQ source index within the source device2030 * @ia_id:		Device ID of the IA, if the IRQ flows through this IA2031 * @vint:		Virtual interrupt to be used within the IA2032 * @global_event:	Global event number to be used for the requesting event2033 * @vint_status_bit:	Virtual interrupt status bit to be used for the event2034 *2035 * Return: 0 if all went fine, else return appropriate error.2036 */2037static int ti_sci_cmd_free_event_map(const struct ti_sci_handle *handle,2038				     u16 src_id, u16 src_index, u16 ia_id,2039				     u16 vint, u16 global_event,2040				     u8 vint_status_bit)2041{2042	u32 valid_params = MSG_FLAG_IA_ID_VALID |2043			   MSG_FLAG_VINT_VALID | MSG_FLAG_GLB_EVNT_VALID |2044			   MSG_FLAG_VINT_STS_BIT_VALID;2045 2046	return ti_sci_free_irq(handle, valid_params, src_id, src_index, 0, 0,2047			       ia_id, vint, global_event, vint_status_bit, 0);2048}2049 2050/**2051 * ti_sci_cmd_rm_ring_cfg() - Configure a NAVSS ring2052 * @handle:	Pointer to TI SCI handle.2053 * @params:	Pointer to ti_sci_msg_rm_ring_cfg ring config structure2054 *2055 * Return: 0 if all went well, else returns appropriate error value.2056 *2057 * See @ti_sci_msg_rm_ring_cfg and @ti_sci_msg_rm_ring_cfg_req for2058 * more info.2059 */2060static int ti_sci_cmd_rm_ring_cfg(const struct ti_sci_handle *handle,2061				  const struct ti_sci_msg_rm_ring_cfg *params)2062{2063	struct ti_sci_msg_rm_ring_cfg_req *req;2064	struct ti_sci_msg_hdr *resp;2065	struct ti_sci_xfer *xfer;2066	struct ti_sci_info *info;2067	struct device *dev;2068	int ret = 0;2069 2070	if (IS_ERR_OR_NULL(handle))2071		return -EINVAL;2072 2073	info = handle_to_ti_sci_info(handle);2074	dev = info->dev;2075 2076	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_RM_RING_CFG,2077				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2078				   sizeof(*req), sizeof(*resp));2079	if (IS_ERR(xfer)) {2080		ret = PTR_ERR(xfer);2081		dev_err(dev, "RM_RA:Message config failed(%d)\n", ret);2082		return ret;2083	}2084	req = (struct ti_sci_msg_rm_ring_cfg_req *)xfer->xfer_buf;2085	req->valid_params = params->valid_params;2086	req->nav_id = params->nav_id;2087	req->index = params->index;2088	req->addr_lo = params->addr_lo;2089	req->addr_hi = params->addr_hi;2090	req->count = params->count;2091	req->mode = params->mode;2092	req->size = params->size;2093	req->order_id = params->order_id;2094	req->virtid = params->virtid;2095	req->asel = params->asel;2096 2097	ret = ti_sci_do_xfer(info, xfer);2098	if (ret) {2099		dev_err(dev, "RM_RA:Mbox config send fail %d\n", ret);2100		goto fail;2101	}2102 2103	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;2104	ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;2105 2106fail:2107	ti_sci_put_one_xfer(&info->minfo, xfer);2108	dev_dbg(dev, "RM_RA:config ring %u ret:%d\n", params->index, ret);2109	return ret;2110}2111 2112/**2113 * ti_sci_cmd_rm_psil_pair() - Pair PSI-L source to destination thread2114 * @handle:	Pointer to TI SCI handle.2115 * @nav_id:	Device ID of Navigator Subsystem which should be used for2116 *		pairing2117 * @src_thread:	Source PSI-L thread ID2118 * @dst_thread: Destination PSI-L thread ID2119 *2120 * Return: 0 if all went well, else returns appropriate error value.2121 */2122static int ti_sci_cmd_rm_psil_pair(const struct ti_sci_handle *handle,2123				   u32 nav_id, u32 src_thread, u32 dst_thread)2124{2125	struct ti_sci_msg_psil_pair *req;2126	struct ti_sci_msg_hdr *resp;2127	struct ti_sci_xfer *xfer;2128	struct ti_sci_info *info;2129	struct device *dev;2130	int ret = 0;2131 2132	if (IS_ERR(handle))2133		return PTR_ERR(handle);2134	if (!handle)2135		return -EINVAL;2136 2137	info = handle_to_ti_sci_info(handle);2138	dev = info->dev;2139 2140	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_RM_PSIL_PAIR,2141				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2142				   sizeof(*req), sizeof(*resp));2143	if (IS_ERR(xfer)) {2144		ret = PTR_ERR(xfer);2145		dev_err(dev, "RM_PSIL:Message reconfig failed(%d)\n", ret);2146		return ret;2147	}2148	req = (struct ti_sci_msg_psil_pair *)xfer->xfer_buf;2149	req->nav_id = nav_id;2150	req->src_thread = src_thread;2151	req->dst_thread = dst_thread;2152 2153	ret = ti_sci_do_xfer(info, xfer);2154	if (ret) {2155		dev_err(dev, "RM_PSIL:Mbox send fail %d\n", ret);2156		goto fail;2157	}2158 2159	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;2160	ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;2161 2162fail:2163	ti_sci_put_one_xfer(&info->minfo, xfer);2164 2165	return ret;2166}2167 2168/**2169 * ti_sci_cmd_rm_psil_unpair() - Unpair PSI-L source from destination thread2170 * @handle:	Pointer to TI SCI handle.2171 * @nav_id:	Device ID of Navigator Subsystem which should be used for2172 *		unpairing2173 * @src_thread:	Source PSI-L thread ID2174 * @dst_thread:	Destination PSI-L thread ID2175 *2176 * Return: 0 if all went well, else returns appropriate error value.2177 */2178static int ti_sci_cmd_rm_psil_unpair(const struct ti_sci_handle *handle,2179				     u32 nav_id, u32 src_thread, u32 dst_thread)2180{2181	struct ti_sci_msg_psil_unpair *req;2182	struct ti_sci_msg_hdr *resp;2183	struct ti_sci_xfer *xfer;2184	struct ti_sci_info *info;2185	struct device *dev;2186	int ret = 0;2187 2188	if (IS_ERR(handle))2189		return PTR_ERR(handle);2190	if (!handle)2191		return -EINVAL;2192 2193	info = handle_to_ti_sci_info(handle);2194	dev = info->dev;2195 2196	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_RM_PSIL_UNPAIR,2197				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2198				   sizeof(*req), sizeof(*resp));2199	if (IS_ERR(xfer)) {2200		ret = PTR_ERR(xfer);2201		dev_err(dev, "RM_PSIL:Message reconfig failed(%d)\n", ret);2202		return ret;2203	}2204	req = (struct ti_sci_msg_psil_unpair *)xfer->xfer_buf;2205	req->nav_id = nav_id;2206	req->src_thread = src_thread;2207	req->dst_thread = dst_thread;2208 2209	ret = ti_sci_do_xfer(info, xfer);2210	if (ret) {2211		dev_err(dev, "RM_PSIL:Mbox send fail %d\n", ret);2212		goto fail;2213	}2214 2215	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;2216	ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;2217 2218fail:2219	ti_sci_put_one_xfer(&info->minfo, xfer);2220 2221	return ret;2222}2223 2224/**2225 * ti_sci_cmd_rm_udmap_tx_ch_cfg() - Configure a UDMAP TX channel2226 * @handle:	Pointer to TI SCI handle.2227 * @params:	Pointer to ti_sci_msg_rm_udmap_tx_ch_cfg TX channel config2228 *		structure2229 *2230 * Return: 0 if all went well, else returns appropriate error value.2231 *2232 * See @ti_sci_msg_rm_udmap_tx_ch_cfg and @ti_sci_msg_rm_udmap_tx_ch_cfg_req for2233 * more info.2234 */2235static int ti_sci_cmd_rm_udmap_tx_ch_cfg(const struct ti_sci_handle *handle,2236			const struct ti_sci_msg_rm_udmap_tx_ch_cfg *params)2237{2238	struct ti_sci_msg_rm_udmap_tx_ch_cfg_req *req;2239	struct ti_sci_msg_hdr *resp;2240	struct ti_sci_xfer *xfer;2241	struct ti_sci_info *info;2242	struct device *dev;2243	int ret = 0;2244 2245	if (IS_ERR_OR_NULL(handle))2246		return -EINVAL;2247 2248	info = handle_to_ti_sci_info(handle);2249	dev = info->dev;2250 2251	xfer = ti_sci_get_one_xfer(info, TISCI_MSG_RM_UDMAP_TX_CH_CFG,2252				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2253				   sizeof(*req), sizeof(*resp));2254	if (IS_ERR(xfer)) {2255		ret = PTR_ERR(xfer);2256		dev_err(dev, "Message TX_CH_CFG alloc failed(%d)\n", ret);2257		return ret;2258	}2259	req = (struct ti_sci_msg_rm_udmap_tx_ch_cfg_req *)xfer->xfer_buf;2260	req->valid_params = params->valid_params;2261	req->nav_id = params->nav_id;2262	req->index = params->index;2263	req->tx_pause_on_err = params->tx_pause_on_err;2264	req->tx_filt_einfo = params->tx_filt_einfo;2265	req->tx_filt_pswords = params->tx_filt_pswords;2266	req->tx_atype = params->tx_atype;2267	req->tx_chan_type = params->tx_chan_type;2268	req->tx_supr_tdpkt = params->tx_supr_tdpkt;2269	req->tx_fetch_size = params->tx_fetch_size;2270	req->tx_credit_count = params->tx_credit_count;2271	req->txcq_qnum = params->txcq_qnum;2272	req->tx_priority = params->tx_priority;2273	req->tx_qos = params->tx_qos;2274	req->tx_orderid = params->tx_orderid;2275	req->fdepth = params->fdepth;2276	req->tx_sched_priority = params->tx_sched_priority;2277	req->tx_burst_size = params->tx_burst_size;2278	req->tx_tdtype = params->tx_tdtype;2279	req->extended_ch_type = params->extended_ch_type;2280 2281	ret = ti_sci_do_xfer(info, xfer);2282	if (ret) {2283		dev_err(dev, "Mbox send TX_CH_CFG fail %d\n", ret);2284		goto fail;2285	}2286 2287	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;2288	ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;2289 2290fail:2291	ti_sci_put_one_xfer(&info->minfo, xfer);2292	dev_dbg(dev, "TX_CH_CFG: chn %u ret:%u\n", params->index, ret);2293	return ret;2294}2295 2296/**2297 * ti_sci_cmd_rm_udmap_rx_ch_cfg() - Configure a UDMAP RX channel2298 * @handle:	Pointer to TI SCI handle.2299 * @params:	Pointer to ti_sci_msg_rm_udmap_rx_ch_cfg RX channel config2300 *		structure2301 *2302 * Return: 0 if all went well, else returns appropriate error value.2303 *2304 * See @ti_sci_msg_rm_udmap_rx_ch_cfg and @ti_sci_msg_rm_udmap_rx_ch_cfg_req for2305 * more info.2306 */2307static int ti_sci_cmd_rm_udmap_rx_ch_cfg(const struct ti_sci_handle *handle,2308			const struct ti_sci_msg_rm_udmap_rx_ch_cfg *params)2309{2310	struct ti_sci_msg_rm_udmap_rx_ch_cfg_req *req;2311	struct ti_sci_msg_hdr *resp;2312	struct ti_sci_xfer *xfer;2313	struct ti_sci_info *info;2314	struct device *dev;2315	int ret = 0;2316 2317	if (IS_ERR_OR_NULL(handle))2318		return -EINVAL;2319 2320	info = handle_to_ti_sci_info(handle);2321	dev = info->dev;2322 2323	xfer = ti_sci_get_one_xfer(info, TISCI_MSG_RM_UDMAP_RX_CH_CFG,2324				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2325				   sizeof(*req), sizeof(*resp));2326	if (IS_ERR(xfer)) {2327		ret = PTR_ERR(xfer);2328		dev_err(dev, "Message RX_CH_CFG alloc failed(%d)\n", ret);2329		return ret;2330	}2331	req = (struct ti_sci_msg_rm_udmap_rx_ch_cfg_req *)xfer->xfer_buf;2332	req->valid_params = params->valid_params;2333	req->nav_id = params->nav_id;2334	req->index = params->index;2335	req->rx_fetch_size = params->rx_fetch_size;2336	req->rxcq_qnum = params->rxcq_qnum;2337	req->rx_priority = params->rx_priority;2338	req->rx_qos = params->rx_qos;2339	req->rx_orderid = params->rx_orderid;2340	req->rx_sched_priority = params->rx_sched_priority;2341	req->flowid_start = params->flowid_start;2342	req->flowid_cnt = params->flowid_cnt;2343	req->rx_pause_on_err = params->rx_pause_on_err;2344	req->rx_atype = params->rx_atype;2345	req->rx_chan_type = params->rx_chan_type;2346	req->rx_ignore_short = params->rx_ignore_short;2347	req->rx_ignore_long = params->rx_ignore_long;2348	req->rx_burst_size = params->rx_burst_size;2349 2350	ret = ti_sci_do_xfer(info, xfer);2351	if (ret) {2352		dev_err(dev, "Mbox send RX_CH_CFG fail %d\n", ret);2353		goto fail;2354	}2355 2356	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;2357	ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;2358 2359fail:2360	ti_sci_put_one_xfer(&info->minfo, xfer);2361	dev_dbg(dev, "RX_CH_CFG: chn %u ret:%d\n", params->index, ret);2362	return ret;2363}2364 2365/**2366 * ti_sci_cmd_rm_udmap_rx_flow_cfg() - Configure UDMAP RX FLOW2367 * @handle:	Pointer to TI SCI handle.2368 * @params:	Pointer to ti_sci_msg_rm_udmap_flow_cfg RX FLOW config2369 *		structure2370 *2371 * Return: 0 if all went well, else returns appropriate error value.2372 *2373 * See @ti_sci_msg_rm_udmap_flow_cfg and @ti_sci_msg_rm_udmap_flow_cfg_req for2374 * more info.2375 */2376static int ti_sci_cmd_rm_udmap_rx_flow_cfg(const struct ti_sci_handle *handle,2377			const struct ti_sci_msg_rm_udmap_flow_cfg *params)2378{2379	struct ti_sci_msg_rm_udmap_flow_cfg_req *req;2380	struct ti_sci_msg_hdr *resp;2381	struct ti_sci_xfer *xfer;2382	struct ti_sci_info *info;2383	struct device *dev;2384	int ret = 0;2385 2386	if (IS_ERR_OR_NULL(handle))2387		return -EINVAL;2388 2389	info = handle_to_ti_sci_info(handle);2390	dev = info->dev;2391 2392	xfer = ti_sci_get_one_xfer(info, TISCI_MSG_RM_UDMAP_FLOW_CFG,2393				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2394				   sizeof(*req), sizeof(*resp));2395	if (IS_ERR(xfer)) {2396		ret = PTR_ERR(xfer);2397		dev_err(dev, "RX_FL_CFG: Message alloc failed(%d)\n", ret);2398		return ret;2399	}2400	req = (struct ti_sci_msg_rm_udmap_flow_cfg_req *)xfer->xfer_buf;2401	req->valid_params = params->valid_params;2402	req->nav_id = params->nav_id;2403	req->flow_index = params->flow_index;2404	req->rx_einfo_present = params->rx_einfo_present;2405	req->rx_psinfo_present = params->rx_psinfo_present;2406	req->rx_error_handling = params->rx_error_handling;2407	req->rx_desc_type = params->rx_desc_type;2408	req->rx_sop_offset = params->rx_sop_offset;2409	req->rx_dest_qnum = params->rx_dest_qnum;2410	req->rx_src_tag_hi = params->rx_src_tag_hi;2411	req->rx_src_tag_lo = params->rx_src_tag_lo;2412	req->rx_dest_tag_hi = params->rx_dest_tag_hi;2413	req->rx_dest_tag_lo = params->rx_dest_tag_lo;2414	req->rx_src_tag_hi_sel = params->rx_src_tag_hi_sel;2415	req->rx_src_tag_lo_sel = params->rx_src_tag_lo_sel;2416	req->rx_dest_tag_hi_sel = params->rx_dest_tag_hi_sel;2417	req->rx_dest_tag_lo_sel = params->rx_dest_tag_lo_sel;2418	req->rx_fdq0_sz0_qnum = params->rx_fdq0_sz0_qnum;2419	req->rx_fdq1_qnum = params->rx_fdq1_qnum;2420	req->rx_fdq2_qnum = params->rx_fdq2_qnum;2421	req->rx_fdq3_qnum = params->rx_fdq3_qnum;2422	req->rx_ps_location = params->rx_ps_location;2423 2424	ret = ti_sci_do_xfer(info, xfer);2425	if (ret) {2426		dev_err(dev, "RX_FL_CFG: Mbox send fail %d\n", ret);2427		goto fail;2428	}2429 2430	resp = (struct ti_sci_msg_hdr *)xfer->xfer_buf;2431	ret = ti_sci_is_response_ack(resp) ? 0 : -EINVAL;2432 2433fail:2434	ti_sci_put_one_xfer(&info->minfo, xfer);2435	dev_dbg(info->dev, "RX_FL_CFG: %u ret:%d\n", params->flow_index, ret);2436	return ret;2437}2438 2439/**2440 * ti_sci_cmd_proc_request() - Command to request a physical processor control2441 * @handle:	Pointer to TI SCI handle2442 * @proc_id:	Processor ID this request is for2443 *2444 * Return: 0 if all went well, else returns appropriate error value.2445 */2446static int ti_sci_cmd_proc_request(const struct ti_sci_handle *handle,2447				   u8 proc_id)2448{2449	struct ti_sci_msg_req_proc_request *req;2450	struct ti_sci_msg_hdr *resp;2451	struct ti_sci_info *info;2452	struct ti_sci_xfer *xfer;2453	struct device *dev;2454	int ret = 0;2455 2456	if (!handle)2457		return -EINVAL;2458	if (IS_ERR(handle))2459		return PTR_ERR(handle);2460 2461	info = handle_to_ti_sci_info(handle);2462	dev = info->dev;2463 2464	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_REQUEST,2465				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2466				   sizeof(*req), sizeof(*resp));2467	if (IS_ERR(xfer)) {2468		ret = PTR_ERR(xfer);2469		dev_err(dev, "Message alloc failed(%d)\n", ret);2470		return ret;2471	}2472	req = (struct ti_sci_msg_req_proc_request *)xfer->xfer_buf;2473	req->processor_id = proc_id;2474 2475	ret = ti_sci_do_xfer(info, xfer);2476	if (ret) {2477		dev_err(dev, "Mbox send fail %d\n", ret);2478		goto fail;2479	}2480 2481	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;2482 2483	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;2484 2485fail:2486	ti_sci_put_one_xfer(&info->minfo, xfer);2487 2488	return ret;2489}2490 2491/**2492 * ti_sci_cmd_proc_release() - Command to release a physical processor control2493 * @handle:	Pointer to TI SCI handle2494 * @proc_id:	Processor ID this request is for2495 *2496 * Return: 0 if all went well, else returns appropriate error value.2497 */2498static int ti_sci_cmd_proc_release(const struct ti_sci_handle *handle,2499				   u8 proc_id)2500{2501	struct ti_sci_msg_req_proc_release *req;2502	struct ti_sci_msg_hdr *resp;2503	struct ti_sci_info *info;2504	struct ti_sci_xfer *xfer;2505	struct device *dev;2506	int ret = 0;2507 2508	if (!handle)2509		return -EINVAL;2510	if (IS_ERR(handle))2511		return PTR_ERR(handle);2512 2513	info = handle_to_ti_sci_info(handle);2514	dev = info->dev;2515 2516	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_RELEASE,2517				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2518				   sizeof(*req), sizeof(*resp));2519	if (IS_ERR(xfer)) {2520		ret = PTR_ERR(xfer);2521		dev_err(dev, "Message alloc failed(%d)\n", ret);2522		return ret;2523	}2524	req = (struct ti_sci_msg_req_proc_release *)xfer->xfer_buf;2525	req->processor_id = proc_id;2526 2527	ret = ti_sci_do_xfer(info, xfer);2528	if (ret) {2529		dev_err(dev, "Mbox send fail %d\n", ret);2530		goto fail;2531	}2532 2533	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;2534 2535	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;2536 2537fail:2538	ti_sci_put_one_xfer(&info->minfo, xfer);2539 2540	return ret;2541}2542 2543/**2544 * ti_sci_cmd_proc_handover() - Command to handover a physical processor2545 *				control to a host in the processor's access2546 *				control list.2547 * @handle:	Pointer to TI SCI handle2548 * @proc_id:	Processor ID this request is for2549 * @host_id:	Host ID to get the control of the processor2550 *2551 * Return: 0 if all went well, else returns appropriate error value.2552 */2553static int ti_sci_cmd_proc_handover(const struct ti_sci_handle *handle,2554				    u8 proc_id, u8 host_id)2555{2556	struct ti_sci_msg_req_proc_handover *req;2557	struct ti_sci_msg_hdr *resp;2558	struct ti_sci_info *info;2559	struct ti_sci_xfer *xfer;2560	struct device *dev;2561	int ret = 0;2562 2563	if (!handle)2564		return -EINVAL;2565	if (IS_ERR(handle))2566		return PTR_ERR(handle);2567 2568	info = handle_to_ti_sci_info(handle);2569	dev = info->dev;2570 2571	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_HANDOVER,2572				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2573				   sizeof(*req), sizeof(*resp));2574	if (IS_ERR(xfer)) {2575		ret = PTR_ERR(xfer);2576		dev_err(dev, "Message alloc failed(%d)\n", ret);2577		return ret;2578	}2579	req = (struct ti_sci_msg_req_proc_handover *)xfer->xfer_buf;2580	req->processor_id = proc_id;2581	req->host_id = host_id;2582 2583	ret = ti_sci_do_xfer(info, xfer);2584	if (ret) {2585		dev_err(dev, "Mbox send fail %d\n", ret);2586		goto fail;2587	}2588 2589	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;2590 2591	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;2592 2593fail:2594	ti_sci_put_one_xfer(&info->minfo, xfer);2595 2596	return ret;2597}2598 2599/**2600 * ti_sci_cmd_proc_set_config() - Command to set the processor boot2601 *				    configuration flags2602 * @handle:		Pointer to TI SCI handle2603 * @proc_id:		Processor ID this request is for2604 * @bootvector:		Processor Boot vector (start address)2605 * @config_flags_set:	Configuration flags to be set2606 * @config_flags_clear:	Configuration flags to be cleared.2607 *2608 * Return: 0 if all went well, else returns appropriate error value.2609 */2610static int ti_sci_cmd_proc_set_config(const struct ti_sci_handle *handle,2611				      u8 proc_id, u64 bootvector,2612				      u32 config_flags_set,2613				      u32 config_flags_clear)2614{2615	struct ti_sci_msg_req_set_config *req;2616	struct ti_sci_msg_hdr *resp;2617	struct ti_sci_info *info;2618	struct ti_sci_xfer *xfer;2619	struct device *dev;2620	int ret = 0;2621 2622	if (!handle)2623		return -EINVAL;2624	if (IS_ERR(handle))2625		return PTR_ERR(handle);2626 2627	info = handle_to_ti_sci_info(handle);2628	dev = info->dev;2629 2630	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CONFIG,2631				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2632				   sizeof(*req), sizeof(*resp));2633	if (IS_ERR(xfer)) {2634		ret = PTR_ERR(xfer);2635		dev_err(dev, "Message alloc failed(%d)\n", ret);2636		return ret;2637	}2638	req = (struct ti_sci_msg_req_set_config *)xfer->xfer_buf;2639	req->processor_id = proc_id;2640	req->bootvector_low = bootvector & TI_SCI_ADDR_LOW_MASK;2641	req->bootvector_high = (bootvector & TI_SCI_ADDR_HIGH_MASK) >>2642				TI_SCI_ADDR_HIGH_SHIFT;2643	req->config_flags_set = config_flags_set;2644	req->config_flags_clear = config_flags_clear;2645 2646	ret = ti_sci_do_xfer(info, xfer);2647	if (ret) {2648		dev_err(dev, "Mbox send fail %d\n", ret);2649		goto fail;2650	}2651 2652	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;2653 2654	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;2655 2656fail:2657	ti_sci_put_one_xfer(&info->minfo, xfer);2658 2659	return ret;2660}2661 2662/**2663 * ti_sci_cmd_proc_set_control() - Command to set the processor boot2664 *				     control flags2665 * @handle:			Pointer to TI SCI handle2666 * @proc_id:			Processor ID this request is for2667 * @control_flags_set:		Control flags to be set2668 * @control_flags_clear:	Control flags to be cleared2669 *2670 * Return: 0 if all went well, else returns appropriate error value.2671 */2672static int ti_sci_cmd_proc_set_control(const struct ti_sci_handle *handle,2673				       u8 proc_id, u32 control_flags_set,2674				       u32 control_flags_clear)2675{2676	struct ti_sci_msg_req_set_ctrl *req;2677	struct ti_sci_msg_hdr *resp;2678	struct ti_sci_info *info;2679	struct ti_sci_xfer *xfer;2680	struct device *dev;2681	int ret = 0;2682 2683	if (!handle)2684		return -EINVAL;2685	if (IS_ERR(handle))2686		return PTR_ERR(handle);2687 2688	info = handle_to_ti_sci_info(handle);2689	dev = info->dev;2690 2691	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CTRL,2692				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2693				   sizeof(*req), sizeof(*resp));2694	if (IS_ERR(xfer)) {2695		ret = PTR_ERR(xfer);2696		dev_err(dev, "Message alloc failed(%d)\n", ret);2697		return ret;2698	}2699	req = (struct ti_sci_msg_req_set_ctrl *)xfer->xfer_buf;2700	req->processor_id = proc_id;2701	req->control_flags_set = control_flags_set;2702	req->control_flags_clear = control_flags_clear;2703 2704	ret = ti_sci_do_xfer(info, xfer);2705	if (ret) {2706		dev_err(dev, "Mbox send fail %d\n", ret);2707		goto fail;2708	}2709 2710	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;2711 2712	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;2713 2714fail:2715	ti_sci_put_one_xfer(&info->minfo, xfer);2716 2717	return ret;2718}2719 2720/**2721 * ti_sci_cmd_proc_get_status() - Command to get the processor boot status2722 * @handle:	Pointer to TI SCI handle2723 * @proc_id:	Processor ID this request is for2724 * @bv:		Processor Boot vector (start address)2725 * @cfg_flags:	Processor specific configuration flags2726 * @ctrl_flags:	Processor specific control flags2727 * @sts_flags:	Processor specific status flags2728 *2729 * Return: 0 if all went well, else returns appropriate error value.2730 */2731static int ti_sci_cmd_proc_get_status(const struct ti_sci_handle *handle,2732				      u8 proc_id, u64 *bv, u32 *cfg_flags,2733				      u32 *ctrl_flags, u32 *sts_flags)2734{2735	struct ti_sci_msg_resp_get_status *resp;2736	struct ti_sci_msg_req_get_status *req;2737	struct ti_sci_info *info;2738	struct ti_sci_xfer *xfer;2739	struct device *dev;2740	int ret = 0;2741 2742	if (!handle)2743		return -EINVAL;2744	if (IS_ERR(handle))2745		return PTR_ERR(handle);2746 2747	info = handle_to_ti_sci_info(handle);2748	dev = info->dev;2749 2750	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_STATUS,2751				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,2752				   sizeof(*req), sizeof(*resp));2753	if (IS_ERR(xfer)) {2754		ret = PTR_ERR(xfer);2755		dev_err(dev, "Message alloc failed(%d)\n", ret);2756		return ret;2757	}2758	req = (struct ti_sci_msg_req_get_status *)xfer->xfer_buf;2759	req->processor_id = proc_id;2760 2761	ret = ti_sci_do_xfer(info, xfer);2762	if (ret) {2763		dev_err(dev, "Mbox send fail %d\n", ret);2764		goto fail;2765	}2766 2767	resp = (struct ti_sci_msg_resp_get_status *)xfer->tx_message.buf;2768 2769	if (!ti_sci_is_response_ack(resp)) {2770		ret = -ENODEV;2771	} else {2772		*bv = (resp->bootvector_low & TI_SCI_ADDR_LOW_MASK) |2773		      (((u64)resp->bootvector_high << TI_SCI_ADDR_HIGH_SHIFT) &2774		       TI_SCI_ADDR_HIGH_MASK);2775		*cfg_flags = resp->config_flags;2776		*ctrl_flags = resp->control_flags;2777		*sts_flags = resp->status_flags;2778	}2779 2780fail:2781	ti_sci_put_one_xfer(&info->minfo, xfer);2782 2783	return ret;2784}2785 2786/*2787 * ti_sci_setup_ops() - Setup the operations structures2788 * @info:	pointer to TISCI pointer2789 */2790static void ti_sci_setup_ops(struct ti_sci_info *info)2791{2792	struct ti_sci_ops *ops = &info->handle.ops;2793	struct ti_sci_core_ops *core_ops = &ops->core_ops;2794	struct ti_sci_dev_ops *dops = &ops->dev_ops;2795	struct ti_sci_clk_ops *cops = &ops->clk_ops;2796	struct ti_sci_rm_core_ops *rm_core_ops = &ops->rm_core_ops;2797	struct ti_sci_rm_irq_ops *iops = &ops->rm_irq_ops;2798	struct ti_sci_rm_ringacc_ops *rops = &ops->rm_ring_ops;2799	struct ti_sci_rm_psil_ops *psilops = &ops->rm_psil_ops;2800	struct ti_sci_rm_udmap_ops *udmap_ops = &ops->rm_udmap_ops;2801	struct ti_sci_proc_ops *pops = &ops->proc_ops;2802 2803	core_ops->reboot_device = ti_sci_cmd_core_reboot;2804 2805	dops->get_device = ti_sci_cmd_get_device;2806	dops->get_device_exclusive = ti_sci_cmd_get_device_exclusive;2807	dops->idle_device = ti_sci_cmd_idle_device;2808	dops->idle_device_exclusive = ti_sci_cmd_idle_device_exclusive;2809	dops->put_device = ti_sci_cmd_put_device;2810 2811	dops->is_valid = ti_sci_cmd_dev_is_valid;2812	dops->get_context_loss_count = ti_sci_cmd_dev_get_clcnt;2813	dops->is_idle = ti_sci_cmd_dev_is_idle;2814	dops->is_stop = ti_sci_cmd_dev_is_stop;2815	dops->is_on = ti_sci_cmd_dev_is_on;2816	dops->is_transitioning = ti_sci_cmd_dev_is_trans;2817	dops->set_device_resets = ti_sci_cmd_set_device_resets;2818	dops->get_device_resets = ti_sci_cmd_get_device_resets;2819 2820	cops->get_clock = ti_sci_cmd_get_clock;2821	cops->idle_clock = ti_sci_cmd_idle_clock;2822	cops->put_clock = ti_sci_cmd_put_clock;2823	cops->is_auto = ti_sci_cmd_clk_is_auto;2824	cops->is_on = ti_sci_cmd_clk_is_on;2825	cops->is_off = ti_sci_cmd_clk_is_off;2826 2827	cops->set_parent = ti_sci_cmd_clk_set_parent;2828	cops->get_parent = ti_sci_cmd_clk_get_parent;2829	cops->get_num_parents = ti_sci_cmd_clk_get_num_parents;2830 2831	cops->get_best_match_freq = ti_sci_cmd_clk_get_match_freq;2832	cops->set_freq = ti_sci_cmd_clk_set_freq;2833	cops->get_freq = ti_sci_cmd_clk_get_freq;2834 2835	rm_core_ops->get_range = ti_sci_cmd_get_resource_range;2836	rm_core_ops->get_range_from_shost =2837				ti_sci_cmd_get_resource_range_from_shost;2838 2839	iops->set_irq = ti_sci_cmd_set_irq;2840	iops->set_event_map = ti_sci_cmd_set_event_map;2841	iops->free_irq = ti_sci_cmd_free_irq;2842	iops->free_event_map = ti_sci_cmd_free_event_map;2843 2844	rops->set_cfg = ti_sci_cmd_rm_ring_cfg;2845 2846	psilops->pair = ti_sci_cmd_rm_psil_pair;2847	psilops->unpair = ti_sci_cmd_rm_psil_unpair;2848 2849	udmap_ops->tx_ch_cfg = ti_sci_cmd_rm_udmap_tx_ch_cfg;2850	udmap_ops->rx_ch_cfg = ti_sci_cmd_rm_udmap_rx_ch_cfg;2851	udmap_ops->rx_flow_cfg = ti_sci_cmd_rm_udmap_rx_flow_cfg;2852 2853	pops->request = ti_sci_cmd_proc_request;2854	pops->release = ti_sci_cmd_proc_release;2855	pops->handover = ti_sci_cmd_proc_handover;2856	pops->set_config = ti_sci_cmd_proc_set_config;2857	pops->set_control = ti_sci_cmd_proc_set_control;2858	pops->get_status = ti_sci_cmd_proc_get_status;2859}2860 2861/**2862 * ti_sci_get_handle() - Get the TI SCI handle for a device2863 * @dev:	Pointer to device for which we want SCI handle2864 *2865 * NOTE: The function does not track individual clients of the framework2866 * and is expected to be maintained by caller of TI SCI protocol library.2867 * ti_sci_put_handle must be balanced with successful ti_sci_get_handle2868 * Return: pointer to handle if successful, else:2869 * -EPROBE_DEFER if the instance is not ready2870 * -ENODEV if the required node handler is missing2871 * -EINVAL if invalid conditions are encountered.2872 */2873const struct ti_sci_handle *ti_sci_get_handle(struct device *dev)2874{2875	struct device_node *ti_sci_np;2876	struct ti_sci_handle *handle = NULL;2877	struct ti_sci_info *info;2878 2879	if (!dev) {2880		pr_err("I need a device pointer\n");2881		return ERR_PTR(-EINVAL);2882	}2883	ti_sci_np = of_get_parent(dev->of_node);2884	if (!ti_sci_np) {2885		dev_err(dev, "No OF information\n");2886		return ERR_PTR(-EINVAL);2887	}2888 2889	mutex_lock(&ti_sci_list_mutex);2890	list_for_each_entry(info, &ti_sci_list, node) {2891		if (ti_sci_np == info->dev->of_node) {2892			handle = &info->handle;2893			info->users++;2894			break;2895		}2896	}2897	mutex_unlock(&ti_sci_list_mutex);2898	of_node_put(ti_sci_np);2899 2900	if (!handle)2901		return ERR_PTR(-EPROBE_DEFER);2902 2903	return handle;2904}2905EXPORT_SYMBOL_GPL(ti_sci_get_handle);2906 2907/**2908 * ti_sci_put_handle() - Release the handle acquired by ti_sci_get_handle2909 * @handle:	Handle acquired by ti_sci_get_handle2910 *2911 * NOTE: The function does not track individual clients of the framework2912 * and is expected to be maintained by caller of TI SCI protocol library.2913 * ti_sci_put_handle must be balanced with successful ti_sci_get_handle2914 *2915 * Return: 0 is successfully released2916 * if an error pointer was passed, it returns the error value back,2917 * if null was passed, it returns -EINVAL;2918 */2919int ti_sci_put_handle(const struct ti_sci_handle *handle)2920{2921	struct ti_sci_info *info;2922 2923	if (IS_ERR(handle))2924		return PTR_ERR(handle);2925	if (!handle)2926		return -EINVAL;2927 2928	info = handle_to_ti_sci_info(handle);2929	mutex_lock(&ti_sci_list_mutex);2930	if (!WARN_ON(!info->users))2931		info->users--;2932	mutex_unlock(&ti_sci_list_mutex);2933 2934	return 0;2935}2936EXPORT_SYMBOL_GPL(ti_sci_put_handle);2937 2938static void devm_ti_sci_release(struct device *dev, void *res)2939{2940	const struct ti_sci_handle **ptr = res;2941	const struct ti_sci_handle *handle = *ptr;2942	int ret;2943 2944	ret = ti_sci_put_handle(handle);2945	if (ret)2946		dev_err(dev, "failed to put handle %d\n", ret);2947}2948 2949/**2950 * devm_ti_sci_get_handle() - Managed get handle2951 * @dev:	device for which we want SCI handle for.2952 *2953 * NOTE: This releases the handle once the device resources are2954 * no longer needed. MUST NOT BE released with ti_sci_put_handle.2955 * The function does not track individual clients of the framework2956 * and is expected to be maintained by caller of TI SCI protocol library.2957 *2958 * Return: 0 if all went fine, else corresponding error.2959 */2960const struct ti_sci_handle *devm_ti_sci_get_handle(struct device *dev)2961{2962	const struct ti_sci_handle **ptr;2963	const struct ti_sci_handle *handle;2964 2965	ptr = devres_alloc(devm_ti_sci_release, sizeof(*ptr), GFP_KERNEL);2966	if (!ptr)2967		return ERR_PTR(-ENOMEM);2968	handle = ti_sci_get_handle(dev);2969 2970	if (!IS_ERR(handle)) {2971		*ptr = handle;2972		devres_add(dev, ptr);2973	} else {2974		devres_free(ptr);2975	}2976 2977	return handle;2978}2979EXPORT_SYMBOL_GPL(devm_ti_sci_get_handle);2980 2981/**2982 * ti_sci_get_by_phandle() - Get the TI SCI handle using DT phandle2983 * @np:		device node2984 * @property:	property name containing phandle on TISCI node2985 *2986 * NOTE: The function does not track individual clients of the framework2987 * and is expected to be maintained by caller of TI SCI protocol library.2988 * ti_sci_put_handle must be balanced with successful ti_sci_get_by_phandle2989 * Return: pointer to handle if successful, else:2990 * -EPROBE_DEFER if the instance is not ready2991 * -ENODEV if the required node handler is missing2992 * -EINVAL if invalid conditions are encountered.2993 */2994const struct ti_sci_handle *ti_sci_get_by_phandle(struct device_node *np,2995						  const char *property)2996{2997	struct ti_sci_handle *handle = NULL;2998	struct device_node *ti_sci_np;2999	struct ti_sci_info *info;3000 3001	if (!np) {3002		pr_err("I need a device pointer\n");3003		return ERR_PTR(-EINVAL);3004	}3005 3006	ti_sci_np = of_parse_phandle(np, property, 0);3007	if (!ti_sci_np)3008		return ERR_PTR(-ENODEV);3009 3010	mutex_lock(&ti_sci_list_mutex);3011	list_for_each_entry(info, &ti_sci_list, node) {3012		if (ti_sci_np == info->dev->of_node) {3013			handle = &info->handle;3014			info->users++;3015			break;3016		}3017	}3018	mutex_unlock(&ti_sci_list_mutex);3019	of_node_put(ti_sci_np);3020 3021	if (!handle)3022		return ERR_PTR(-EPROBE_DEFER);3023 3024	return handle;3025}3026EXPORT_SYMBOL_GPL(ti_sci_get_by_phandle);3027 3028/**3029 * devm_ti_sci_get_by_phandle() - Managed get handle using phandle3030 * @dev:	Device pointer requesting TISCI handle3031 * @property:	property name containing phandle on TISCI node3032 *3033 * NOTE: This releases the handle once the device resources are3034 * no longer needed. MUST NOT BE released with ti_sci_put_handle.3035 * The function does not track individual clients of the framework3036 * and is expected to be maintained by caller of TI SCI protocol library.3037 *3038 * Return: 0 if all went fine, else corresponding error.3039 */3040const struct ti_sci_handle *devm_ti_sci_get_by_phandle(struct device *dev,3041						       const char *property)3042{3043	const struct ti_sci_handle *handle;3044	const struct ti_sci_handle **ptr;3045 3046	ptr = devres_alloc(devm_ti_sci_release, sizeof(*ptr), GFP_KERNEL);3047	if (!ptr)3048		return ERR_PTR(-ENOMEM);3049	handle = ti_sci_get_by_phandle(dev_of_node(dev), property);3050 3051	if (!IS_ERR(handle)) {3052		*ptr = handle;3053		devres_add(dev, ptr);3054	} else {3055		devres_free(ptr);3056	}3057 3058	return handle;3059}3060EXPORT_SYMBOL_GPL(devm_ti_sci_get_by_phandle);3061 3062/**3063 * ti_sci_get_free_resource() - Get a free resource from TISCI resource.3064 * @res:	Pointer to the TISCI resource3065 *3066 * Return: resource num if all went ok else TI_SCI_RESOURCE_NULL.3067 */3068u16 ti_sci_get_free_resource(struct ti_sci_resource *res)3069{3070	unsigned long flags;3071	u16 set, free_bit;3072 3073	raw_spin_lock_irqsave(&res->lock, flags);3074	for (set = 0; set < res->sets; set++) {3075		struct ti_sci_resource_desc *desc = &res->desc[set];3076		int res_count = desc->num + desc->num_sec;3077 3078		free_bit = find_first_zero_bit(desc->res_map, res_count);3079		if (free_bit != res_count) {3080			__set_bit(free_bit, desc->res_map);3081			raw_spin_unlock_irqrestore(&res->lock, flags);3082 3083			if (desc->num && free_bit < desc->num)3084				return desc->start + free_bit;3085			else3086				return desc->start_sec + free_bit;3087		}3088	}3089	raw_spin_unlock_irqrestore(&res->lock, flags);3090 3091	return TI_SCI_RESOURCE_NULL;3092}3093EXPORT_SYMBOL_GPL(ti_sci_get_free_resource);3094 3095/**3096 * ti_sci_release_resource() - Release a resource from TISCI resource.3097 * @res:	Pointer to the TISCI resource3098 * @id:		Resource id to be released.3099 */3100void ti_sci_release_resource(struct ti_sci_resource *res, u16 id)3101{3102	unsigned long flags;3103	u16 set;3104 3105	raw_spin_lock_irqsave(&res->lock, flags);3106	for (set = 0; set < res->sets; set++) {3107		struct ti_sci_resource_desc *desc = &res->desc[set];3108 3109		if (desc->num && desc->start <= id &&3110		    (desc->start + desc->num) > id)3111			__clear_bit(id - desc->start, desc->res_map);3112		else if (desc->num_sec && desc->start_sec <= id &&3113			 (desc->start_sec + desc->num_sec) > id)3114			__clear_bit(id - desc->start_sec, desc->res_map);3115	}3116	raw_spin_unlock_irqrestore(&res->lock, flags);3117}3118EXPORT_SYMBOL_GPL(ti_sci_release_resource);3119 3120/**3121 * ti_sci_get_num_resources() - Get the number of resources in TISCI resource3122 * @res:	Pointer to the TISCI resource3123 *3124 * Return: Total number of available resources.3125 */3126u32 ti_sci_get_num_resources(struct ti_sci_resource *res)3127{3128	u32 set, count = 0;3129 3130	for (set = 0; set < res->sets; set++)3131		count += res->desc[set].num + res->desc[set].num_sec;3132 3133	return count;3134}3135EXPORT_SYMBOL_GPL(ti_sci_get_num_resources);3136 3137/**3138 * devm_ti_sci_get_resource_sets() - Get a TISCI resources assigned to a device3139 * @handle:	TISCI handle3140 * @dev:	Device pointer to which the resource is assigned3141 * @dev_id:	TISCI device id to which the resource is assigned3142 * @sub_types:	Array of sub_types assigned corresponding to device3143 * @sets:	Number of sub_types3144 *3145 * Return: Pointer to ti_sci_resource if all went well else appropriate3146 *	   error pointer.3147 */3148static struct ti_sci_resource *3149devm_ti_sci_get_resource_sets(const struct ti_sci_handle *handle,3150			      struct device *dev, u32 dev_id, u32 *sub_types,3151			      u32 sets)3152{3153	struct ti_sci_resource *res;3154	bool valid_set = false;3155	int i, ret, res_count;3156 3157	res = devm_kzalloc(dev, sizeof(*res), GFP_KERNEL);3158	if (!res)3159		return ERR_PTR(-ENOMEM);3160 3161	res->sets = sets;3162	res->desc = devm_kcalloc(dev, res->sets, sizeof(*res->desc),3163				 GFP_KERNEL);3164	if (!res->desc)3165		return ERR_PTR(-ENOMEM);3166 3167	for (i = 0; i < res->sets; i++) {3168		ret = handle->ops.rm_core_ops.get_range(handle, dev_id,3169							sub_types[i],3170							&res->desc[i]);3171		if (ret) {3172			dev_dbg(dev, "dev = %d subtype %d not allocated for this host\n",3173				dev_id, sub_types[i]);3174			memset(&res->desc[i], 0, sizeof(res->desc[i]));3175			continue;3176		}3177 3178		dev_dbg(dev, "dev/sub_type: %d/%d, start/num: %d/%d | %d/%d\n",3179			dev_id, sub_types[i], res->desc[i].start,3180			res->desc[i].num, res->desc[i].start_sec,3181			res->desc[i].num_sec);3182 3183		valid_set = true;3184		res_count = res->desc[i].num + res->desc[i].num_sec;3185		res->desc[i].res_map = devm_bitmap_zalloc(dev, res_count,3186							  GFP_KERNEL);3187		if (!res->desc[i].res_map)3188			return ERR_PTR(-ENOMEM);3189	}3190	raw_spin_lock_init(&res->lock);3191 3192	if (valid_set)3193		return res;3194 3195	return ERR_PTR(-EINVAL);3196}3197 3198/**3199 * devm_ti_sci_get_of_resource() - Get a TISCI resource assigned to a device3200 * @handle:	TISCI handle3201 * @dev:	Device pointer to which the resource is assigned3202 * @dev_id:	TISCI device id to which the resource is assigned3203 * @of_prop:	property name by which the resource are represented3204 *3205 * Return: Pointer to ti_sci_resource if all went well else appropriate3206 *	   error pointer.3207 */3208struct ti_sci_resource *3209devm_ti_sci_get_of_resource(const struct ti_sci_handle *handle,3210			    struct device *dev, u32 dev_id, char *of_prop)3211{3212	struct ti_sci_resource *res;3213	u32 *sub_types;3214	int sets;3215 3216	sets = of_property_count_elems_of_size(dev_of_node(dev), of_prop,3217					       sizeof(u32));3218	if (sets < 0) {3219		dev_err(dev, "%s resource type ids not available\n", of_prop);3220		return ERR_PTR(sets);3221	}3222 3223	sub_types = kcalloc(sets, sizeof(*sub_types), GFP_KERNEL);3224	if (!sub_types)3225		return ERR_PTR(-ENOMEM);3226 3227	of_property_read_u32_array(dev_of_node(dev), of_prop, sub_types, sets);3228	res = devm_ti_sci_get_resource_sets(handle, dev, dev_id, sub_types,3229					    sets);3230 3231	kfree(sub_types);3232	return res;3233}3234EXPORT_SYMBOL_GPL(devm_ti_sci_get_of_resource);3235 3236/**3237 * devm_ti_sci_get_resource() - Get a resource range assigned to the device3238 * @handle:	TISCI handle3239 * @dev:	Device pointer to which the resource is assigned3240 * @dev_id:	TISCI device id to which the resource is assigned3241 * @sub_type:	TISCI resource subytpe representing the resource.3242 *3243 * Return: Pointer to ti_sci_resource if all went well else appropriate3244 *	   error pointer.3245 */3246struct ti_sci_resource *3247devm_ti_sci_get_resource(const struct ti_sci_handle *handle, struct device *dev,3248			 u32 dev_id, u32 sub_type)3249{3250	return devm_ti_sci_get_resource_sets(handle, dev, dev_id, &sub_type, 1);3251}3252EXPORT_SYMBOL_GPL(devm_ti_sci_get_resource);3253 3254static int tisci_reboot_handler(struct sys_off_data *data)3255{3256	struct ti_sci_info *info = data->cb_data;3257	const struct ti_sci_handle *handle = &info->handle;3258 3259	ti_sci_cmd_core_reboot(handle);3260 3261	/* call fail OR pass, we should not be here in the first place */3262	return NOTIFY_BAD;3263}3264 3265/* Description for K2G */3266static const struct ti_sci_desc ti_sci_pmmc_k2g_desc = {3267	.default_host_id = 2,3268	/* Conservative duration */3269	.max_rx_timeout_ms = 1000,3270	/* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */3271	.max_msgs = 20,3272	.max_msg_size = 64,3273};3274 3275/* Description for AM654 */3276static const struct ti_sci_desc ti_sci_pmmc_am654_desc = {3277	.default_host_id = 12,3278	/* Conservative duration */3279	.max_rx_timeout_ms = 10000,3280	/* Limited by MBOX_TX_QUEUE_LEN. K2G can handle upto 128 messages! */3281	.max_msgs = 20,3282	.max_msg_size = 60,3283};3284 3285static const struct of_device_id ti_sci_of_match[] = {3286	{.compatible = "ti,k2g-sci", .data = &ti_sci_pmmc_k2g_desc},3287	{.compatible = "ti,am654-sci", .data = &ti_sci_pmmc_am654_desc},3288	{ /* Sentinel */ },3289};3290MODULE_DEVICE_TABLE(of, ti_sci_of_match);3291 3292static int ti_sci_probe(struct platform_device *pdev)3293{3294	struct device *dev = &pdev->dev;3295	const struct ti_sci_desc *desc;3296	struct ti_sci_xfer *xfer;3297	struct ti_sci_info *info = NULL;3298	struct ti_sci_xfers_info *minfo;3299	struct mbox_client *cl;3300	int ret = -EINVAL;3301	int i;3302	u32 h_id;3303 3304	desc = device_get_match_data(dev);3305 3306	info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);3307	if (!info)3308		return -ENOMEM;3309 3310	info->dev = dev;3311	info->desc = desc;3312	ret = of_property_read_u32(dev->of_node, "ti,host-id", &h_id);3313	/* if the property is not present in DT, use a default from desc */3314	if (ret < 0) {3315		info->host_id = info->desc->default_host_id;3316	} else {3317		if (!h_id) {3318			dev_warn(dev, "Host ID 0 is reserved for firmware\n");3319			info->host_id = info->desc->default_host_id;3320		} else {3321			info->host_id = h_id;3322		}3323	}3324 3325	INIT_LIST_HEAD(&info->node);3326	minfo = &info->minfo;3327 3328	/*3329	 * Pre-allocate messages3330	 * NEVER allocate more than what we can indicate in hdr.seq3331	 * if we have data description bug, force a fix..3332	 */3333	if (WARN_ON(desc->max_msgs >=3334		    1 << 8 * sizeof(((struct ti_sci_msg_hdr *)0)->seq)))3335		return -EINVAL;3336 3337	minfo->xfer_block = devm_kcalloc(dev,3338					 desc->max_msgs,3339					 sizeof(*minfo->xfer_block),3340					 GFP_KERNEL);3341	if (!minfo->xfer_block)3342		return -ENOMEM;3343 3344	minfo->xfer_alloc_table = devm_bitmap_zalloc(dev,3345						     desc->max_msgs,3346						     GFP_KERNEL);3347	if (!minfo->xfer_alloc_table)3348		return -ENOMEM;3349 3350	/* Pre-initialize the buffer pointer to pre-allocated buffers */3351	for (i = 0, xfer = minfo->xfer_block; i < desc->max_msgs; i++, xfer++) {3352		xfer->xfer_buf = devm_kcalloc(dev, 1, desc->max_msg_size,3353					      GFP_KERNEL);3354		if (!xfer->xfer_buf)3355			return -ENOMEM;3356 3357		xfer->tx_message.buf = xfer->xfer_buf;3358		init_completion(&xfer->done);3359	}3360 3361	ret = ti_sci_debugfs_create(pdev, info);3362	if (ret)3363		dev_warn(dev, "Failed to create debug file\n");3364 3365	platform_set_drvdata(pdev, info);3366 3367	cl = &info->cl;3368	cl->dev = dev;3369	cl->tx_block = false;3370	cl->rx_callback = ti_sci_rx_callback;3371	cl->knows_txdone = true;3372 3373	spin_lock_init(&minfo->xfer_lock);3374	sema_init(&minfo->sem_xfer_count, desc->max_msgs);3375 3376	info->chan_rx = mbox_request_channel_byname(cl, "rx");3377	if (IS_ERR(info->chan_rx)) {3378		ret = PTR_ERR(info->chan_rx);3379		goto out;3380	}3381 3382	info->chan_tx = mbox_request_channel_byname(cl, "tx");3383	if (IS_ERR(info->chan_tx)) {3384		ret = PTR_ERR(info->chan_tx);3385		goto out;3386	}3387	ret = ti_sci_cmd_get_revision(info);3388	if (ret) {3389		dev_err(dev, "Unable to communicate with TISCI(%d)\n", ret);3390		goto out;3391	}3392 3393	ti_sci_setup_ops(info);3394 3395	ret = devm_register_restart_handler(dev, tisci_reboot_handler, info);3396	if (ret) {3397		dev_err(dev, "reboot registration fail(%d)\n", ret);3398		goto out;3399	}3400 3401	dev_info(dev, "ABI: %d.%d (firmware rev 0x%04x '%s')\n",3402		 info->handle.version.abi_major, info->handle.version.abi_minor,3403		 info->handle.version.firmware_revision,3404		 info->handle.version.firmware_description);3405 3406	mutex_lock(&ti_sci_list_mutex);3407	list_add_tail(&info->node, &ti_sci_list);3408	mutex_unlock(&ti_sci_list_mutex);3409 3410	return of_platform_populate(dev->of_node, NULL, NULL, dev);3411out:3412	if (!IS_ERR(info->chan_tx))3413		mbox_free_channel(info->chan_tx);3414	if (!IS_ERR(info->chan_rx))3415		mbox_free_channel(info->chan_rx);3416	debugfs_remove(info->d);3417	return ret;3418}3419 3420static struct platform_driver ti_sci_driver = {3421	.probe = ti_sci_probe,3422	.driver = {3423		   .name = "ti-sci",3424		   .of_match_table = of_match_ptr(ti_sci_of_match),3425		   .suppress_bind_attrs = true,3426	},3427};3428module_platform_driver(ti_sci_driver);3429 3430MODULE_LICENSE("GPL v2");3431MODULE_DESCRIPTION("TI System Control Interface(SCI) driver");3432MODULE_AUTHOR("Nishanth Menon");3433MODULE_ALIAS("platform:ti-sci");3434