Commit 1e407f33 authored by Suman Anna's avatar Suman Anna Committed by Santosh Shilimkar
Browse files

firmware: ti_sci: Add support for processor control 



Texas Instrument's System Control Interface (TI-SCI) Message Protocol
is used in Texas Instrument's System on Chip (SoC) such as those
in K3 family AM654 SoC to communicate between various compute
processors with a central system controller entity.

The system controller provides various services including the control
of other compute processors within the SoC. Extend the TI-SCI protocol
support to add various TI-SCI commands to invoke services associated
with power and reset control, and boot vector management of the
various compute processors from the Linux kernel.

Signed-off-by: default avatarSuman Anna <s-anna@ti.com>
Signed-off-by: default avatarTero Kristo <t-kristo@ti.com>
Signed-off-by: default avatarSantosh Shilimkar <santosh.shilimkar@oracle.com>
parent 68608b5e

drivers/firmware/ti_sci.c

+350 −0
Original line number Diff line number Diff line
@@ -2479,6 +2479,348 @@ fail: 
	return ret;

}



/**

 * ti_sci_cmd_proc_request() - Command to request a physical processor control

 * @handle:	Pointer to TI SCI handle

 * @proc_id:	Processor ID this request is for

 *

 * Return: 0 if all went well, else returns appropriate error value.

 */

static int ti_sci_cmd_proc_request(const struct ti_sci_handle *handle,

				   u8 proc_id)

{

	struct ti_sci_msg_req_proc_request *req;

	struct ti_sci_msg_hdr *resp;

	struct ti_sci_info *info;

	struct ti_sci_xfer *xfer;

	struct device *dev;

	int ret = 0;



	if (!handle)

		return -EINVAL;

	if (IS_ERR(handle))

		return PTR_ERR(handle);



	info = handle_to_ti_sci_info(handle);

	dev = info->dev;



	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_REQUEST,

				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,

				   sizeof(*req), sizeof(*resp));

	if (IS_ERR(xfer)) {

		ret = PTR_ERR(xfer);

		dev_err(dev, "Message alloc failed(%d)\n", ret);

		return ret;

	}

	req = (struct ti_sci_msg_req_proc_request *)xfer->xfer_buf;

	req->processor_id = proc_id;



	ret = ti_sci_do_xfer(info, xfer);

	if (ret) {

		dev_err(dev, "Mbox send fail %d\n", ret);

		goto fail;

	}



	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;



	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;



fail:

	ti_sci_put_one_xfer(&info->minfo, xfer);



	return ret;

}



/**

 * ti_sci_cmd_proc_release() - Command to release a physical processor control

 * @handle:	Pointer to TI SCI handle

 * @proc_id:	Processor ID this request is for

 *

 * Return: 0 if all went well, else returns appropriate error value.

 */

static int ti_sci_cmd_proc_release(const struct ti_sci_handle *handle,

				   u8 proc_id)

{

	struct ti_sci_msg_req_proc_release *req;

	struct ti_sci_msg_hdr *resp;

	struct ti_sci_info *info;

	struct ti_sci_xfer *xfer;

	struct device *dev;

	int ret = 0;



	if (!handle)

		return -EINVAL;

	if (IS_ERR(handle))

		return PTR_ERR(handle);



	info = handle_to_ti_sci_info(handle);

	dev = info->dev;



	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_RELEASE,

				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,

				   sizeof(*req), sizeof(*resp));

	if (IS_ERR(xfer)) {

		ret = PTR_ERR(xfer);

		dev_err(dev, "Message alloc failed(%d)\n", ret);

		return ret;

	}

	req = (struct ti_sci_msg_req_proc_release *)xfer->xfer_buf;

	req->processor_id = proc_id;



	ret = ti_sci_do_xfer(info, xfer);

	if (ret) {

		dev_err(dev, "Mbox send fail %d\n", ret);

		goto fail;

	}



	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;



	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;



fail:

	ti_sci_put_one_xfer(&info->minfo, xfer);



	return ret;

}



/**

 * ti_sci_cmd_proc_handover() - Command to handover a physical processor

 *				control to a host in the processor's access

 *				control list.

 * @handle:	Pointer to TI SCI handle

 * @proc_id:	Processor ID this request is for

 * @host_id:	Host ID to get the control of the processor

 *

 * Return: 0 if all went well, else returns appropriate error value.

 */

static int ti_sci_cmd_proc_handover(const struct ti_sci_handle *handle,

				    u8 proc_id, u8 host_id)

{

	struct ti_sci_msg_req_proc_handover *req;

	struct ti_sci_msg_hdr *resp;

	struct ti_sci_info *info;

	struct ti_sci_xfer *xfer;

	struct device *dev;

	int ret = 0;



	if (!handle)

		return -EINVAL;

	if (IS_ERR(handle))

		return PTR_ERR(handle);



	info = handle_to_ti_sci_info(handle);

	dev = info->dev;



	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_PROC_HANDOVER,

				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,

				   sizeof(*req), sizeof(*resp));

	if (IS_ERR(xfer)) {

		ret = PTR_ERR(xfer);

		dev_err(dev, "Message alloc failed(%d)\n", ret);

		return ret;

	}

	req = (struct ti_sci_msg_req_proc_handover *)xfer->xfer_buf;

	req->processor_id = proc_id;

	req->host_id = host_id;



	ret = ti_sci_do_xfer(info, xfer);

	if (ret) {

		dev_err(dev, "Mbox send fail %d\n", ret);

		goto fail;

	}



	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;



	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;



fail:

	ti_sci_put_one_xfer(&info->minfo, xfer);



	return ret;

}



/**

 * ti_sci_cmd_proc_set_config() - Command to set the processor boot

 *				    configuration flags

 * @handle:		Pointer to TI SCI handle

 * @proc_id:		Processor ID this request is for

 * @config_flags_set:	Configuration flags to be set

 * @config_flags_clear:	Configuration flags to be cleared.

 *

 * Return: 0 if all went well, else returns appropriate error value.

 */

static int ti_sci_cmd_proc_set_config(const struct ti_sci_handle *handle,

				      u8 proc_id, u64 bootvector,

				      u32 config_flags_set,

				      u32 config_flags_clear)

{

	struct ti_sci_msg_req_set_config *req;

	struct ti_sci_msg_hdr *resp;

	struct ti_sci_info *info;

	struct ti_sci_xfer *xfer;

	struct device *dev;

	int ret = 0;



	if (!handle)

		return -EINVAL;

	if (IS_ERR(handle))

		return PTR_ERR(handle);



	info = handle_to_ti_sci_info(handle);

	dev = info->dev;



	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CONFIG,

				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,

				   sizeof(*req), sizeof(*resp));

	if (IS_ERR(xfer)) {

		ret = PTR_ERR(xfer);

		dev_err(dev, "Message alloc failed(%d)\n", ret);

		return ret;

	}

	req = (struct ti_sci_msg_req_set_config *)xfer->xfer_buf;

	req->processor_id = proc_id;

	req->bootvector_low = bootvector & TI_SCI_ADDR_LOW_MASK;

	req->bootvector_high = (bootvector & TI_SCI_ADDR_HIGH_MASK) >>

				TI_SCI_ADDR_HIGH_SHIFT;

	req->config_flags_set = config_flags_set;

	req->config_flags_clear = config_flags_clear;



	ret = ti_sci_do_xfer(info, xfer);

	if (ret) {

		dev_err(dev, "Mbox send fail %d\n", ret);

		goto fail;

	}



	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;



	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;



fail:

	ti_sci_put_one_xfer(&info->minfo, xfer);



	return ret;

}



/**

 * ti_sci_cmd_proc_set_control() - Command to set the processor boot

 *				     control flags

 * @handle:			Pointer to TI SCI handle

 * @proc_id:			Processor ID this request is for

 * @control_flags_set:		Control flags to be set

 * @control_flags_clear:	Control flags to be cleared

 *

 * Return: 0 if all went well, else returns appropriate error value.

 */

static int ti_sci_cmd_proc_set_control(const struct ti_sci_handle *handle,

				       u8 proc_id, u32 control_flags_set,

				       u32 control_flags_clear)

{

	struct ti_sci_msg_req_set_ctrl *req;

	struct ti_sci_msg_hdr *resp;

	struct ti_sci_info *info;

	struct ti_sci_xfer *xfer;

	struct device *dev;

	int ret = 0;



	if (!handle)

		return -EINVAL;

	if (IS_ERR(handle))

		return PTR_ERR(handle);



	info = handle_to_ti_sci_info(handle);

	dev = info->dev;



	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_SET_CTRL,

				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,

				   sizeof(*req), sizeof(*resp));

	if (IS_ERR(xfer)) {

		ret = PTR_ERR(xfer);

		dev_err(dev, "Message alloc failed(%d)\n", ret);

		return ret;

	}

	req = (struct ti_sci_msg_req_set_ctrl *)xfer->xfer_buf;

	req->processor_id = proc_id;

	req->control_flags_set = control_flags_set;

	req->control_flags_clear = control_flags_clear;



	ret = ti_sci_do_xfer(info, xfer);

	if (ret) {

		dev_err(dev, "Mbox send fail %d\n", ret);

		goto fail;

	}



	resp = (struct ti_sci_msg_hdr *)xfer->tx_message.buf;



	ret = ti_sci_is_response_ack(resp) ? 0 : -ENODEV;



fail:

	ti_sci_put_one_xfer(&info->minfo, xfer);



	return ret;

}



/**

 * ti_sci_cmd_get_boot_status() - Command to get the processor boot status

 * @handle:	Pointer to TI SCI handle

 * @proc_id:	Processor ID this request is for

 *

 * Return: 0 if all went well, else returns appropriate error value.

 */

static int ti_sci_cmd_proc_get_status(const struct ti_sci_handle *handle,

				      u8 proc_id, u64 *bv, u32 *cfg_flags,

				      u32 *ctrl_flags, u32 *sts_flags)

{

	struct ti_sci_msg_resp_get_status *resp;

	struct ti_sci_msg_req_get_status *req;

	struct ti_sci_info *info;

	struct ti_sci_xfer *xfer;

	struct device *dev;

	int ret = 0;



	if (!handle)

		return -EINVAL;

	if (IS_ERR(handle))

		return PTR_ERR(handle);



	info = handle_to_ti_sci_info(handle);

	dev = info->dev;



	xfer = ti_sci_get_one_xfer(info, TI_SCI_MSG_GET_STATUS,

				   TI_SCI_FLAG_REQ_ACK_ON_PROCESSED,

				   sizeof(*req), sizeof(*resp));

	if (IS_ERR(xfer)) {

		ret = PTR_ERR(xfer);

		dev_err(dev, "Message alloc failed(%d)\n", ret);

		return ret;

	}

	req = (struct ti_sci_msg_req_get_status *)xfer->xfer_buf;

	req->processor_id = proc_id;



	ret = ti_sci_do_xfer(info, xfer);

	if (ret) {

		dev_err(dev, "Mbox send fail %d\n", ret);

		goto fail;

	}



	resp = (struct ti_sci_msg_resp_get_status *)xfer->tx_message.buf;



	if (!ti_sci_is_response_ack(resp)) {

		ret = -ENODEV;

	} else {

		*bv = (resp->bootvector_low & TI_SCI_ADDR_LOW_MASK) |

		      (((u64)resp->bootvector_high << TI_SCI_ADDR_HIGH_SHIFT) &

		       TI_SCI_ADDR_HIGH_MASK);

		*cfg_flags = resp->config_flags;

		*ctrl_flags = resp->control_flags;

		*sts_flags = resp->status_flags;

	}



fail:

	ti_sci_put_one_xfer(&info->minfo, xfer);



	return ret;

}



/*

 * ti_sci_setup_ops() - Setup the operations structures

 * @info:	pointer to TISCI pointer
@@ -2494,6 +2836,7 @@ static void ti_sci_setup_ops(struct ti_sci_info *info) 
	struct ti_sci_rm_ringacc_ops *rops = &ops->rm_ring_ops;

	struct ti_sci_rm_psil_ops *psilops = &ops->rm_psil_ops;

	struct ti_sci_rm_udmap_ops *udmap_ops = &ops->rm_udmap_ops;

	struct ti_sci_proc_ops *pops = &ops->proc_ops;



	core_ops->reboot_device = ti_sci_cmd_core_reboot;
@@ -2543,6 +2886,13 @@ static void ti_sci_setup_ops(struct ti_sci_info *info) 
	udmap_ops->tx_ch_cfg = ti_sci_cmd_rm_udmap_tx_ch_cfg;

	udmap_ops->rx_ch_cfg = ti_sci_cmd_rm_udmap_rx_ch_cfg;

	udmap_ops->rx_flow_cfg = ti_sci_cmd_rm_udmap_rx_flow_cfg;



	pops->request = ti_sci_cmd_proc_request;

	pops->release = ti_sci_cmd_proc_release;

	pops->handover = ti_sci_cmd_proc_handover;

	pops->set_config = ti_sci_cmd_proc_set_config;

	pops->set_control = ti_sci_cmd_proc_set_control;

	pops->get_status = ti_sci_cmd_proc_get_status;

}



/**

drivers/firmware/ti_sci.h

+135 −0
Original line number Diff line number Diff line
@@ -71,6 +71,14 @@ 
#define TISCI_MSG_RM_UDMAP_FLOW_GET_CFG		0x1232

#define TISCI_MSG_RM_UDMAP_FLOW_SIZE_THRESH_GET_CFG	0x1233



/* Processor Control requests */

#define TI_SCI_MSG_PROC_REQUEST		0xc000

#define TI_SCI_MSG_PROC_RELEASE		0xc001

#define TI_SCI_MSG_PROC_HANDOVER	0xc005

#define TI_SCI_MSG_SET_CONFIG		0xc100

#define TI_SCI_MSG_SET_CTRL		0xc101

#define TI_SCI_MSG_GET_STATUS		0xc400



/**

 * struct ti_sci_msg_hdr - Generic Message Header for All messages and responses

 * @type:	Type of messages: One of TI_SCI_MSG* values
@@ -1238,4 +1246,131 @@ struct ti_sci_msg_rm_udmap_flow_cfg_req { 
	u8 rx_ps_location;

} __packed;



/**

 * struct ti_sci_msg_req_proc_request - Request a processor

 * @hdr:		Generic Header

 * @processor_id:	ID of processor being requested

 *

 * Request type is TI_SCI_MSG_PROC_REQUEST, response is a generic ACK/NACK

 * message.

 */

struct ti_sci_msg_req_proc_request {

	struct ti_sci_msg_hdr hdr;

	u8 processor_id;

} __packed;



/**

 * struct ti_sci_msg_req_proc_release - Release a processor

 * @hdr:		Generic Header

 * @processor_id:	ID of processor being released

 *

 * Request type is TI_SCI_MSG_PROC_RELEASE, response is a generic ACK/NACK

 * message.

 */

struct ti_sci_msg_req_proc_release {

	struct ti_sci_msg_hdr hdr;

	u8 processor_id;

} __packed;



/**

 * struct ti_sci_msg_req_proc_handover - Handover a processor to a host

 * @hdr:		Generic Header

 * @processor_id:	ID of processor being handed over

 * @host_id:		Host ID the control needs to be transferred to

 *

 * Request type is TI_SCI_MSG_PROC_HANDOVER, response is a generic ACK/NACK

 * message.

 */

struct ti_sci_msg_req_proc_handover {

	struct ti_sci_msg_hdr hdr;

	u8 processor_id;

	u8 host_id;

} __packed;



/* Boot Vector masks */

#define TI_SCI_ADDR_LOW_MASK			GENMASK_ULL(31, 0)

#define TI_SCI_ADDR_HIGH_MASK			GENMASK_ULL(63, 32)

#define TI_SCI_ADDR_HIGH_SHIFT			32



/**

 * struct ti_sci_msg_req_set_config - Set Processor boot configuration

 * @hdr:		Generic Header

 * @processor_id:	ID of processor being configured

 * @bootvector_low:	Lower 32 bit address (Little Endian) of boot vector

 * @bootvector_high:	Higher 32 bit address (Little Endian) of boot vector

 * @config_flags_set:	Optional Processor specific Config Flags to set.

 *			Setting a bit here implies the corresponding mode

 *			will be set

 * @config_flags_clear:	Optional Processor specific Config Flags to clear.

 *			Setting a bit here implies the corresponding mode

 *			will be cleared

 *

 * Request type is TI_SCI_MSG_PROC_HANDOVER, response is a generic ACK/NACK

 * message.

 */

struct ti_sci_msg_req_set_config {

	struct ti_sci_msg_hdr hdr;

	u8 processor_id;

	u32 bootvector_low;

	u32 bootvector_high;

	u32 config_flags_set;

	u32 config_flags_clear;

} __packed;



/**

 * struct ti_sci_msg_req_set_ctrl - Set Processor boot control flags

 * @hdr:		Generic Header

 * @processor_id:	ID of processor being configured

 * @control_flags_set:	Optional Processor specific Control Flags to set.

 *			Setting a bit here implies the corresponding mode

 *			will be set

 * @control_flags_clear:Optional Processor specific Control Flags to clear.

 *			Setting a bit here implies the corresponding mode

 *			will be cleared

 *

 * Request type is TI_SCI_MSG_SET_CTRL, response is a generic ACK/NACK

 * message.

 */

struct ti_sci_msg_req_set_ctrl {

	struct ti_sci_msg_hdr hdr;

	u8 processor_id;

	u32 control_flags_set;

	u32 control_flags_clear;

} __packed;



/**

 * struct ti_sci_msg_req_get_status - Processor boot status request

 * @hdr:		Generic Header

 * @processor_id:	ID of processor whose status is being requested

 *

 * Request type is TI_SCI_MSG_GET_STATUS, response is an appropriate

 * message, or NACK in case of inability to satisfy request.

 */

struct ti_sci_msg_req_get_status {

	struct ti_sci_msg_hdr hdr;

	u8 processor_id;

} __packed;



/**

 * struct ti_sci_msg_resp_get_status - Processor boot status response

 * @hdr:		Generic Header

 * @processor_id:	ID of processor whose status is returned

 * @bootvector_low:	Lower 32 bit address (Little Endian) of boot vector

 * @bootvector_high:	Higher 32 bit address (Little Endian) of boot vector

 * @config_flags:	Optional Processor specific Config Flags set currently

 * @control_flags:	Optional Processor specific Control Flags set currently

 * @status_flags:	Optional Processor specific Status Flags set currently

 *

 * Response structure to a TI_SCI_MSG_GET_STATUS request.

 */

struct ti_sci_msg_resp_get_status {

	struct ti_sci_msg_hdr hdr;

	u8 processor_id;

	u32 bootvector_low;

	u32 bootvector_high;

	u32 config_flags;

	u32 control_flags;

	u32 status_flags;

} __packed;



#endif /* __TI_SCI_H */

include/linux/soc/ti/ti_sci_protocol.h

+31 −0
Original line number Diff line number Diff line
@@ -453,12 +453,42 @@ struct ti_sci_rm_udmap_ops { 
			   const struct ti_sci_msg_rm_udmap_flow_cfg *params);

};



/**

 * struct ti_sci_proc_ops - Processor Control operations

 * @request:	Request to control a physical processor. The requesting host

 *		should be in the processor access list

 * @release:	Relinquish a physical processor control

 * @handover:	Handover a physical processor control to another host

 *		in the permitted list

 * @set_config:	Set base configuration of a processor

 * @set_control: Setup limited control flags in specific cases

 * @get_status: Get the state of physical processor

 *

 * NOTE: The following paramteres are generic in nature for all these ops,

 * -handle:	Pointer to TI SCI handle as retrieved by *ti_sci_get_handle

 * -pid:	Processor ID

 * -hid:	Host ID

 */

struct ti_sci_proc_ops {

	int (*request)(const struct ti_sci_handle *handle, u8 pid);

	int (*release)(const struct ti_sci_handle *handle, u8 pid);

	int (*handover)(const struct ti_sci_handle *handle, u8 pid, u8 hid);

	int (*set_config)(const struct ti_sci_handle *handle, u8 pid,

			  u64 boot_vector, u32 cfg_set, u32 cfg_clr);

	int (*set_control)(const struct ti_sci_handle *handle, u8 pid,

			   u32 ctrl_set, u32 ctrl_clr);

	int (*get_status)(const struct ti_sci_handle *handle, u8 pid,

			  u64 *boot_vector, u32 *cfg_flags, u32 *ctrl_flags,

			  u32 *status_flags);

};



/**

 * struct ti_sci_ops - Function support for TI SCI

 * @dev_ops:	Device specific operations

 * @clk_ops:	Clock specific operations

 * @rm_core_ops:	Resource management core operations.

 * @rm_irq_ops:		IRQ management specific operations

 * @proc_ops:	Processor Control specific operations

 */

struct ti_sci_ops {

	struct ti_sci_core_ops core_ops;
@@ -469,6 +499,7 @@ struct ti_sci_ops { 
	struct ti_sci_rm_ringacc_ops rm_ring_ops;

	struct ti_sci_rm_psil_ops rm_psil_ops;

	struct ti_sci_rm_udmap_ops rm_udmap_ops;

	struct ti_sci_proc_ops proc_ops;

};



/**

CRA Git | Maintained and supported by SUSTech CRA and CCSE