1 // SPDX-License-Identifier: GPL-2.0+
3 * Texas Instruments System Control Interface Protocol Driver
4 * Based on drivers/firmware/ti_sci.c from Linux.
6 * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/
7 * Lokesh Vutla <lokeshvutla@ti.com>
14 #include <dm/device.h>
15 #include <linux/err.h>
16 #include <linux/soc/ti/k3-sec-proxy.h>
17 #include <linux/soc/ti/ti_sci_protocol.h>
21 /* List of all TI SCI devices active in system */
22 static LIST_HEAD(ti_sci_list);
25 * struct ti_sci_xfer - Structure representing a message flow
26 * @tx_message: Transmit message
27 * @rx_len: Receive message length
30 struct k3_sec_proxy_msg tx_message;
35 * struct ti_sci_desc - Description of SoC integration
36 * @host_id: Host identifier representing the compute entity
37 * @max_rx_timeout_us: Timeout for communication with SoC (in Microseconds)
38 * @max_msg_size: Maximum size of data per message that can be handled.
42 int max_rx_timeout_us;
47 * struct ti_sci_info - Structure representing a TI SCI instance
48 * @dev: Device pointer
49 * @desc: SoC description for this instance
50 * @handle: Instance of TI SCI handle to send to clients.
51 * @chan_tx: Transmit mailbox channel
52 * @chan_rx: Receive mailbox channel
55 * @is_secure: Determines if the communication is through secure threads.
56 * @host_id: Host identifier representing the compute entity
57 * @seq: Seq id used for verification for tx and rx message.
61 const struct ti_sci_desc *desc;
62 struct ti_sci_handle handle;
63 struct mbox_chan chan_tx;
64 struct mbox_chan chan_rx;
65 struct mbox_chan chan_notify;
66 struct ti_sci_xfer xfer;
67 struct list_head list;
73 #define handle_to_ti_sci_info(h) container_of(h, struct ti_sci_info, handle)
76 * ti_sci_setup_one_xfer() - Setup one message type
77 * @info: Pointer to SCI entity information
78 * @msg_type: Message type
79 * @msg_flags: Flag to set for the message
80 * @buf: Buffer to be send to mailbox channel
81 * @tx_message_size: transmit message size
82 * @rx_message_size: receive message size
84 * Helper function which is used by various command functions that are
85 * exposed to clients of this driver for allocating a message traffic event.
87 * Return: Corresponding ti_sci_xfer pointer if all went fine,
88 * else appropriate error pointer.
90 static struct ti_sci_xfer *ti_sci_setup_one_xfer(struct ti_sci_info *info,
91 u16 msg_type, u32 msg_flags,
93 size_t tx_message_size,
94 size_t rx_message_size)
96 struct ti_sci_xfer *xfer = &info->xfer;
97 struct ti_sci_msg_hdr *hdr;
99 /* Ensure we have sane transfer sizes */
100 if (rx_message_size > info->desc->max_msg_size ||
101 tx_message_size > info->desc->max_msg_size ||
102 rx_message_size < sizeof(*hdr) || tx_message_size < sizeof(*hdr))
103 return ERR_PTR(-ERANGE);
105 info->seq = ~info->seq;
106 xfer->tx_message.buf = buf;
107 xfer->tx_message.len = tx_message_size;
108 xfer->rx_len = (u8)rx_message_size;
110 hdr = (struct ti_sci_msg_hdr *)buf;
111 hdr->seq = info->seq;
112 hdr->type = msg_type;
113 hdr->host = info->host_id;
114 hdr->flags = msg_flags;
120 * ti_sci_get_response() - Receive response from mailbox channel
121 * @info: Pointer to SCI entity information
122 * @xfer: Transfer to initiate and wait for response
123 * @chan: Channel to receive the response
125 * Return: -ETIMEDOUT in case of no response, if transmit error,
126 * return corresponding error, else if all goes well,
129 static inline int ti_sci_get_response(struct ti_sci_info *info,
130 struct ti_sci_xfer *xfer,
131 struct mbox_chan *chan)
133 struct k3_sec_proxy_msg *msg = &xfer->tx_message;
134 struct ti_sci_secure_msg_hdr *secure_hdr;
135 struct ti_sci_msg_hdr *hdr;
138 /* Receive the response */
139 ret = mbox_recv(chan, msg, info->desc->max_rx_timeout_us);
141 dev_err(info->dev, "%s: Message receive failed. ret = %d\n",
146 /* ToDo: Verify checksum */
147 if (info->is_secure) {
148 secure_hdr = (struct ti_sci_secure_msg_hdr *)msg->buf;
149 msg->buf = (u32 *)((void *)msg->buf + sizeof(*secure_hdr));
152 /* msg is updated by mailbox driver */
153 hdr = (struct ti_sci_msg_hdr *)msg->buf;
155 /* Sanity check for message response */
156 if (hdr->seq != info->seq) {
157 dev_dbg(info->dev, "%s: Message for %d is not expected\n",
162 if (msg->len > info->desc->max_msg_size) {
163 dev_err(info->dev, "%s: Unable to handle %zu xfer (max %d)\n",
164 __func__, msg->len, info->desc->max_msg_size);
168 if (msg->len < xfer->rx_len) {
169 dev_err(info->dev, "%s: Recv xfer %zu < expected %d length\n",
170 __func__, msg->len, xfer->rx_len);
177 * ti_sci_do_xfer() - Do one transfer
178 * @info: Pointer to SCI entity information
179 * @xfer: Transfer to initiate and wait for response
181 * Return: 0 if all went fine, else return appropriate error.
183 static inline int ti_sci_do_xfer(struct ti_sci_info *info,
184 struct ti_sci_xfer *xfer)
186 struct k3_sec_proxy_msg *msg = &xfer->tx_message;
187 u8 secure_buf[info->desc->max_msg_size];
188 struct ti_sci_secure_msg_hdr secure_hdr;
191 if (info->is_secure) {
192 /* ToDo: get checksum of the entire message */
193 secure_hdr.checksum = 0;
194 secure_hdr.reserved = 0;
195 memcpy(&secure_buf[sizeof(secure_hdr)], xfer->tx_message.buf,
196 xfer->tx_message.len);
198 xfer->tx_message.buf = (u32 *)secure_buf;
199 xfer->tx_message.len += sizeof(secure_hdr);
200 xfer->rx_len += sizeof(secure_hdr);
203 /* Send the message */
204 ret = mbox_send(&info->chan_tx, msg);
206 dev_err(info->dev, "%s: Message sending failed. ret = %d\n",
211 return ti_sci_get_response(info, xfer, &info->chan_rx);
215 * ti_sci_cmd_get_revision() - command to get the revision of the SCI entity
216 * @handle: pointer to TI SCI handle
218 * Updates the SCI information in the internal data structure.
220 * Return: 0 if all went fine, else return appropriate error.
222 static int ti_sci_cmd_get_revision(struct ti_sci_handle *handle)
224 struct ti_sci_msg_resp_version *rev_info;
225 struct ti_sci_version_info *ver;
226 struct ti_sci_msg_hdr hdr;
227 struct ti_sci_info *info;
228 struct ti_sci_xfer *xfer;
232 return PTR_ERR(handle);
236 info = handle_to_ti_sci_info(handle);
238 xfer = ti_sci_setup_one_xfer(info, TI_SCI_MSG_VERSION, 0x0,
239 (u32 *)&hdr, sizeof(struct ti_sci_msg_hdr),
243 dev_err(info->dev, "Message alloc failed(%d)\n", ret);
247 ret = ti_sci_do_xfer(info, xfer);
249 dev_err(info->dev, "Mbox communication fail %d\n", ret);
253 rev_info = (struct ti_sci_msg_resp_version *)xfer->tx_message.buf;
255 ver = &handle->version;
256 ver->abi_major = rev_info->abi_major;
257 ver->abi_minor = rev_info->abi_minor;
258 ver->firmware_revision = rev_info->firmware_revision;
259 strncpy(ver->firmware_description, rev_info->firmware_description,
260 sizeof(ver->firmware_description));
266 * ti_sci_is_response_ack() - Generic ACK/NACK message checkup
267 * @r: pointer to response buffer
269 * Return: true if the response was an ACK, else returns false.
271 static inline bool ti_sci_is_response_ack(void *r)
273 struct ti_sci_msg_hdr *hdr = r;
275 return hdr->flags & TI_SCI_FLAG_RESP_GENERIC_ACK ? true : false;
279 * ti_sci_get_handle_from_sysfw() - Get the TI SCI handle of the SYSFW
280 * @dev: Pointer to the SYSFW device
282 * Return: pointer to handle if successful, else EINVAL if invalid conditions
286 struct ti_sci_handle *ti_sci_get_handle_from_sysfw(struct udevice *sci_dev)
289 return ERR_PTR(-EINVAL);
291 struct ti_sci_info *info = dev_get_priv(sci_dev);
294 return ERR_PTR(-EINVAL);
296 struct ti_sci_handle *handle = &info->handle;
299 return ERR_PTR(-EINVAL);
305 * ti_sci_get_handle() - Get the TI SCI handle for a device
306 * @dev: Pointer to device for which we want SCI handle
308 * Return: pointer to handle if successful, else EINVAL if invalid conditions
311 const struct ti_sci_handle *ti_sci_get_handle(struct udevice *dev)
314 return ERR_PTR(-EINVAL);
316 struct udevice *sci_dev = dev_get_parent(dev);
318 return ti_sci_get_handle_from_sysfw(sci_dev);
322 * ti_sci_get_by_phandle() - Get the TI SCI handle using DT phandle
324 * @propname: property name containing phandle on TISCI node
326 * Return: pointer to handle if successful, else appropriate error value.
328 const struct ti_sci_handle *ti_sci_get_by_phandle(struct udevice *dev,
329 const char *property)
331 struct ti_sci_info *entry, *info = NULL;
335 err = ofnode_read_u32(dev_ofnode(dev), property, &phandle);
339 node = ofnode_get_by_phandle(phandle);
340 if (!ofnode_valid(node))
341 return ERR_PTR(-EINVAL);
343 list_for_each_entry(entry, &ti_sci_list, list)
344 if (ofnode_equal(dev_ofnode(entry->dev), node)) {
350 return ERR_PTR(-ENODEV);
352 return &info->handle;
356 * ti_sci_of_to_info() - generate private data from device tree
357 * @dev: corresponding system controller interface device
358 * @info: pointer to driver specific private data
360 * Return: 0 if all goes good, else appropriate error message.
362 static int ti_sci_of_to_info(struct udevice *dev, struct ti_sci_info *info)
366 ret = mbox_get_by_name(dev, "tx", &info->chan_tx);
368 dev_err(dev, "%s: Acquiring Tx channel failed. ret = %d\n",
373 ret = mbox_get_by_name(dev, "rx", &info->chan_rx);
375 dev_err(dev, "%s: Acquiring Rx channel failed. ret = %d\n",
380 /* Notify channel is optional. Enable only if populated */
381 ret = mbox_get_by_name(dev, "notify", &info->chan_notify);
383 dev_dbg(dev, "%s: Acquiring notify channel failed. ret = %d\n",
387 info->host_id = dev_read_u32_default(dev, "ti,host-id",
388 info->desc->host_id);
390 info->is_secure = dev_read_bool(dev, "ti,secure-host");
396 * ti_sci_probe() - Basic probe
397 * @dev: corresponding system controller interface device
399 * Return: 0 if all goes good, else appropriate error message.
401 static int ti_sci_probe(struct udevice *dev)
403 struct ti_sci_info *info;
406 debug("%s(dev=%p)\n", __func__, dev);
408 info = dev_get_priv(dev);
409 info->desc = (void *)dev_get_driver_data(dev);
411 ret = ti_sci_of_to_info(dev, info);
413 dev_err(dev, "%s: Probe failed with error %d\n", __func__, ret);
420 list_add_tail(&info->list, &ti_sci_list);
422 ret = ti_sci_cmd_get_revision(&info->handle);
427 /* Description for AM654 */
428 static const struct ti_sci_desc ti_sci_sysfw_am654_desc = {
430 .max_rx_timeout_us = 1000000,
434 static const struct udevice_id ti_sci_ids[] = {
436 .compatible = "ti,k2g-sci",
437 .data = (ulong)&ti_sci_sysfw_am654_desc
442 U_BOOT_DRIVER(ti_sci) = {
444 .id = UCLASS_FIRMWARE,
445 .of_match = ti_sci_ids,
446 .probe = ti_sci_probe,
447 .priv_auto_alloc_size = sizeof(struct ti_sci_info),