diff mbox series

firmware: ti_sci: Add support for processor control

Message ID 20190605223334.30428-1-s-anna@ti.com
State Accepted
Commit 1e407f337f4015c8ffc56e7cfd70e06b2e9fc9da
Headers show
Series firmware: ti_sci: Add support for processor control | expand

Commit Message

Suman Anna June 5, 2019, 10:33 p.m. UTC 
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: Suman Anna <s-anna@ti.com>

---
Hi Santosh, Nishanth, Tero,

Appreciate it if this patch can be picked up for the 5.3 merge window.
This is a dependency patch for my various remoteproc drivers on TI K3
SoCs. Patch is on top of v5.2-rc1.

regards
Suman

 drivers/firmware/ti_sci.c              | 350 +++++++++++++++++++++++++
 drivers/firmware/ti_sci.h              | 135 ++++++++++
 include/linux/soc/ti/ti_sci_protocol.h |  31 +++
 3 files changed, 516 insertions(+)

-- 
2.21.0

Comments

Lokesh Vutla June 6, 2019, 4:04 a.m. UTC | #1 
On 06/06/19 4:03 AM, Suman Anna wrote:
> 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: Suman Anna <s-anna@ti.com>


Reviewed-by: Lokesh Vutla <lokeshvutla@ti.com>


Thanks and regards,
Lokesh

> ---

> Hi Santosh, Nishanth, Tero,

> 

> Appreciate it if this patch can be picked up for the 5.3 merge window.

> This is a dependency patch for my various remoteproc drivers on TI K3

> SoCs. Patch is on top of v5.2-rc1.

> 

> regards

> Suman

> 

>  drivers/firmware/ti_sci.c              | 350 +++++++++++++++++++++++++

>  drivers/firmware/ti_sci.h              | 135 ++++++++++

>  include/linux/soc/ti/ti_sci_protocol.h |  31 +++

>  3 files changed, 516 insertions(+)

> 

> diff --git a/drivers/firmware/ti_sci.c b/drivers/firmware/ti_sci.c

> index 36ce11a67235..596acad89e86 100644

> --- a/drivers/firmware/ti_sci.c

> +++ b/drivers/firmware/ti_sci.c

> @@ -2004,6 +2004,348 @@ static int ti_sci_cmd_free_event_map(const struct ti_sci_handle *handle,

>  			       ia_id, vint, global_event, vint_status_bit, 0);

>  }

>  

> +/**

> + * 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

> @@ -2016,6 +2358,7 @@ static void ti_sci_setup_ops(struct ti_sci_info *info)

>  	struct ti_sci_clk_ops *cops = &ops->clk_ops;

>  	struct ti_sci_rm_core_ops *rm_core_ops = &ops->rm_core_ops;

>  	struct ti_sci_rm_irq_ops *iops = &ops->rm_irq_ops;

> +	struct ti_sci_proc_ops *pops = &ops->proc_ops;

>  

>  	core_ops->reboot_device = ti_sci_cmd_core_reboot;

>  

> @@ -2055,6 +2398,13 @@ static void ti_sci_setup_ops(struct ti_sci_info *info)

>  	iops->set_event_map = ti_sci_cmd_set_event_map;

>  	iops->free_irq = ti_sci_cmd_free_irq;

>  	iops->free_event_map = ti_sci_cmd_free_event_map;

> +

> +	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;

>  }

>  

>  /**

> diff --git a/drivers/firmware/ti_sci.h b/drivers/firmware/ti_sci.h

> index 4983827151bf..557b17fea902 100644

> --- a/drivers/firmware/ti_sci.h

> +++ b/drivers/firmware/ti_sci.h

> @@ -42,6 +42,14 @@

>  #define TI_SCI_MSG_SET_IRQ		0x1000

>  #define TI_SCI_MSG_FREE_IRQ		0x1001

>  

> +/* 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

> @@ -563,4 +571,131 @@ struct ti_sci_msg_req_manage_irq {

>  	u8 secondary_host;

>  } __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 */

> diff --git a/include/linux/soc/ti/ti_sci_protocol.h b/include/linux/soc/ti/ti_sci_protocol.h

> index 568722a041bf..0e3cd739add5 100644

> --- a/include/linux/soc/ti/ti_sci_protocol.h

> +++ b/include/linux/soc/ti/ti_sci_protocol.h

> @@ -241,12 +241,42 @@ struct ti_sci_rm_irq_ops {

>  			      u16 global_event, u8 vint_status_bit);

>  };

>  

> +/**

> + * 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;

> @@ -254,6 +284,7 @@ struct ti_sci_ops {

>  	struct ti_sci_clk_ops clk_ops;

>  	struct ti_sci_rm_core_ops rm_core_ops;

>  	struct ti_sci_rm_irq_ops rm_irq_ops;

> +	struct ti_sci_proc_ops proc_ops;

>  };

>  

>  /**

>
Santosh Shilimkar June 7, 2019, 9:35 p.m. UTC | #2 
On 6/5/19 3:33 PM, Suman Anna wrote:
> 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: Suman Anna <s-anna@ti.com>

> ---

> Hi Santosh, Nishanth, Tero,

> 

> Appreciate it if this patch can be picked up for the 5.3 merge window.

> This is a dependency patch for my various remoteproc drivers on TI K3

> SoCs. Patch is on top of v5.2-rc1.

> 

I will pick this up for 5.3.

Regards,
Santosh
Tero Kristo June 10, 2019, 12:19 p.m. UTC | #3 
On 08/06/2019 00:35, santosh.shilimkar@oracle.com wrote:
> On 6/5/19 3:33 PM, Suman Anna wrote:

>> 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: Suman Anna <s-anna@ti.com>

>> ---

>> Hi Santosh, Nishanth, Tero,

>>

>> Appreciate it if this patch can be picked up for the 5.3 merge window.

>> This is a dependency patch for my various remoteproc drivers on TI K3

>> SoCs. Patch is on top of v5.2-rc1.

>>

> I will pick this up for 5.3.


Santosh,

There is a pile of drivers/firmware changes for ti-sci, which have cross 
dependencies, and will cause merge conflicts also as they touch same file.

Do you mind if I setup a pull-request for these all and send it to you? 
They are going to be on top of the keystone clock pull-request I just 
sent today though, otherwise it won't compile (the 32bit clock support 
has dependency towards the clock driver.)

-Tero
--
Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki. Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki
Santosh Shilimkar June 10, 2019, 5:16 p.m. UTC | #4 
On 6/10/19 5:19 AM, Tero Kristo wrote:
> On 08/06/2019 00:35, santosh.shilimkar@oracle.com wrote:

>> On 6/5/19 3:33 PM, Suman Anna wrote:

>>> 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: Suman Anna <s-anna@ti.com>

>>> ---

>>> Hi Santosh, Nishanth, Tero,

>>>

>>> Appreciate it if this patch can be picked up for the 5.3 merge window.

>>> This is a dependency patch for my various remoteproc drivers on TI K3

>>> SoCs. Patch is on top of v5.2-rc1.

>>>

>> I will pick this up for 5.3.

> 

> Santosh,

> 

> There is a pile of drivers/firmware changes for ti-sci, which have cross 

> dependencies, and will cause merge conflicts also as they touch same file.

> 

> Do you mind if I setup a pull-request for these all and send it to you? 

> They are going to be on top of the keystone clock pull-request I just 

> sent today though, otherwise it won't compile (the 32bit clock support 

> has dependency towards the clock driver.)

> 

That will be great Tero.

Regards,
Santosh
Tero Kristo June 11, 2019, 5:37 p.m. UTC | #5 
On 10/06/2019 20:16, santosh.shilimkar@oracle.com wrote:
> 

> 

> On 6/10/19 5:19 AM, Tero Kristo wrote:

>> On 08/06/2019 00:35, santosh.shilimkar@oracle.com wrote:

>>> On 6/5/19 3:33 PM, Suman Anna wrote:

>>>> 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: Suman Anna <s-anna@ti.com>

>>>> ---

>>>> Hi Santosh, Nishanth, Tero,

>>>>

>>>> Appreciate it if this patch can be picked up for the 5.3 merge window.

>>>> This is a dependency patch for my various remoteproc drivers on TI K3

>>>> SoCs. Patch is on top of v5.2-rc1.

>>>>

>>> I will pick this up for 5.3.

>>

>> Santosh,

>>

>> There is a pile of drivers/firmware changes for ti-sci, which have 

>> cross dependencies, and will cause merge conflicts also as they touch 

>> same file.

>>

>> Do you mind if I setup a pull-request for these all and send it to 

>> you? They are going to be on top of the keystone clock pull-request I 

>> just sent today though, otherwise it won't compile (the 32bit clock 

>> support has dependency towards the clock driver.)

>>

> That will be great Tero.


Ok doing that.

For this patch, queuing up for 5.3, thanks.

-Tero

> 

> Regards,

> Santosh

> 

> _______________________________________________

> linux-arm-kernel mailing list

> linux-arm-kernel@lists.infradead.org

> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel


--
Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki. Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki
diff mbox series

Patch

diff --git a/drivers/firmware/ti_sci.c b/drivers/firmware/ti_sci.c
index 36ce11a67235..596acad89e86 100644
--- a/drivers/firmware/ti_sci.c
+++ b/drivers/firmware/ti_sci.c
@@ -2004,6 +2004,348 @@  static int ti_sci_cmd_free_event_map(const struct ti_sci_handle *handle,
 			       ia_id, vint, global_event, vint_status_bit, 0);
 }
 
+/**
+ * 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
@@ -2016,6 +2358,7 @@  static void ti_sci_setup_ops(struct ti_sci_info *info)
 	struct ti_sci_clk_ops *cops = &ops->clk_ops;
 	struct ti_sci_rm_core_ops *rm_core_ops = &ops->rm_core_ops;
 	struct ti_sci_rm_irq_ops *iops = &ops->rm_irq_ops;
+	struct ti_sci_proc_ops *pops = &ops->proc_ops;
 
 	core_ops->reboot_device = ti_sci_cmd_core_reboot;
 
@@ -2055,6 +2398,13 @@  static void ti_sci_setup_ops(struct ti_sci_info *info)
 	iops->set_event_map = ti_sci_cmd_set_event_map;
 	iops->free_irq = ti_sci_cmd_free_irq;
 	iops->free_event_map = ti_sci_cmd_free_event_map;
+
+	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;
 }
 
 /**
diff --git a/drivers/firmware/ti_sci.h b/drivers/firmware/ti_sci.h
index 4983827151bf..557b17fea902 100644
--- a/drivers/firmware/ti_sci.h
+++ b/drivers/firmware/ti_sci.h
@@ -42,6 +42,14 @@ 
 #define TI_SCI_MSG_SET_IRQ		0x1000
 #define TI_SCI_MSG_FREE_IRQ		0x1001
 
+/* 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
@@ -563,4 +571,131 @@  struct ti_sci_msg_req_manage_irq {
 	u8 secondary_host;
 } __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 */
diff --git a/include/linux/soc/ti/ti_sci_protocol.h b/include/linux/soc/ti/ti_sci_protocol.h
index 568722a041bf..0e3cd739add5 100644
--- a/include/linux/soc/ti/ti_sci_protocol.h
+++ b/include/linux/soc/ti/ti_sci_protocol.h
@@ -241,12 +241,42 @@  struct ti_sci_rm_irq_ops {
 			      u16 global_event, u8 vint_status_bit);
 };
 
+/**
+ * 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;
@@ -254,6 +284,7 @@  struct ti_sci_ops {
 	struct ti_sci_clk_ops clk_ops;
 	struct ti_sci_rm_core_ops rm_core_ops;
 	struct ti_sci_rm_irq_ops rm_irq_ops;
+	struct ti_sci_proc_ops proc_ops;
 };
 
 /**