1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Texas Instruments' K3 Remoteproc driver
4 *
5 * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/
6 * Lokesh Vutla <lokeshvutla@ti.com>
7 *
8 */
9
10 #include <common.h>
11 #include <dm.h>
12 #include <remoteproc.h>
13 #include <errno.h>
14 #include <clk.h>
15 #include <reset.h>
16 #include <asm/io.h>
17 #include <power-domain.h>
18 #include <linux/soc/ti/ti_sci_protocol.h>
19
20 #define INVALID_ID 0xffff
21
22 #define GTC_CNTCR_REG 0x0
23 #define GTC_CNTR_EN 0x3
24
25 /**
26 * struct k3_rproc_privdata - Structure representing Remote processor data.
27 * @rproc_pwrdmn: rproc power domain data
28 * @rproc_rst: rproc reset control data
29 * @sci: Pointer to TISCI handle
30 * @gtc_base: Timer base address.
31 * @proc_id: TISCI processor ID
32 * @host_id: TISCI host id to which the processor gets assigned to.
33 */
34 struct k3_rproc_privdata {
35 struct power_domain rproc_pwrdmn;
36 struct power_domain gtc_pwrdmn;
37 struct reset_ctl rproc_rst;
38 const struct ti_sci_handle *sci;
39 void *gtc_base;
40 u16 proc_id;
41 u16 host_id;
42 };
43
44 /**
45 * k3_rproc_load() - Load up the Remote processor image
46 * @dev: rproc device pointer
47 * @addr: Address at which image is available
48 * @size: size of the image
49 *
50 * Return: 0 if all goes good, else appropriate error message.
51 */
k3_rproc_load(struct udevice * dev,ulong addr,ulong size)52 static int k3_rproc_load(struct udevice *dev, ulong addr, ulong size)
53 {
54 struct k3_rproc_privdata *rproc = dev_get_priv(dev);
55 const struct ti_sci_proc_ops *pops = &rproc->sci->ops.proc_ops;
56 int ret;
57
58 dev_dbg(dev, "%s addr = 0x%lx, size = 0x%lx\n", __func__, addr, size);
59
60 /* request for the processor */
61 ret = pops->proc_request(rproc->sci, rproc->proc_id);
62 if (ret) {
63 dev_err(dev, "Requesting processor failed %d\n", ret);
64 return ret;
65 }
66
67 ret = pops->set_proc_boot_cfg(rproc->sci, rproc->proc_id, addr, 0, 0);
68 if (ret) {
69 dev_err(dev, "set_proc_boot_cfg failed %d\n", ret);
70 return ret;
71 }
72
73 dev_dbg(dev, "%s: rproc successfully loaded\n", __func__);
74
75 return 0;
76 }
77
78 /**
79 * k3_rproc_start() - Start the remote processor
80 * @dev: rproc device pointer
81 *
82 * Return: 0 if all went ok, else return appropriate error
83 */
k3_rproc_start(struct udevice * dev)84 static int k3_rproc_start(struct udevice *dev)
85 {
86 struct k3_rproc_privdata *rproc = dev_get_priv(dev);
87 const struct ti_sci_proc_ops *pops = &rproc->sci->ops.proc_ops;
88 int ret;
89
90 dev_dbg(dev, "%s\n", __func__);
91
92 ret = power_domain_on(&rproc->gtc_pwrdmn);
93 if (ret) {
94 dev_err(dev, "power_domain_on() failed: %d\n", ret);
95 return ret;
96 }
97
98 /* Enable the timer before starting remote core */
99 writel(GTC_CNTR_EN, rproc->gtc_base + GTC_CNTCR_REG);
100
101 /*
102 * Setting the right clock frequency would have taken care by
103 * assigned-clock-rates during the device probe. So no need to
104 * set the frequency again here.
105 */
106 ret = power_domain_on(&rproc->rproc_pwrdmn);
107 if (ret) {
108 dev_err(dev, "power_domain_on() failed: %d\n", ret);
109 return ret;
110 }
111
112 if (rproc->host_id != INVALID_ID) {
113 ret = pops->proc_handover(rproc->sci, rproc->proc_id,
114 rproc->host_id);
115 if (ret) {
116 dev_err(dev, "Handover processor failed %d\n", ret);
117 return ret;
118 }
119 } else {
120 ret = pops->proc_release(rproc->sci, rproc->proc_id);
121 if (ret) {
122 dev_err(dev, "Processor release failed %d\n", ret);
123 return ret;
124 }
125 }
126
127 dev_dbg(dev, "%s: rproc successfully started\n", __func__);
128
129 return 0;
130 }
131
132 /**
133 * k3_rproc_init() - Initialize the remote processor
134 * @dev: rproc device pointer
135 *
136 * Return: 0 if all went ok, else return appropriate error
137 */
k3_rproc_init(struct udevice * dev)138 static int k3_rproc_init(struct udevice *dev)
139 {
140 dev_dbg(dev, "%s\n", __func__);
141
142 /* Enable the module */
143 dev_dbg(dev, "%s: rproc successfully initialized\n", __func__);
144
145 return 0;
146 }
147
148 static const struct dm_rproc_ops k3_rproc_ops = {
149 .init = k3_rproc_init,
150 .load = k3_rproc_load,
151 .start = k3_rproc_start,
152 };
153
154 /**
155 * k3_of_to_priv() - generate private data from device tree
156 * @dev: corresponding k3 remote processor device
157 * @priv: pointer to driver specific private data
158 *
159 * Return: 0 if all goes good, else appropriate error message.
160 */
k3_rproc_of_to_priv(struct udevice * dev,struct k3_rproc_privdata * rproc)161 static int k3_rproc_of_to_priv(struct udevice *dev,
162 struct k3_rproc_privdata *rproc)
163 {
164 int ret;
165
166 dev_dbg(dev, "%s\n", __func__);
167
168 ret = power_domain_get_by_index(dev, &rproc->rproc_pwrdmn, 1);
169 if (ret) {
170 dev_err(dev, "power_domain_get() failed: %d\n", ret);
171 return ret;
172 }
173
174 ret = power_domain_get_by_index(dev, &rproc->gtc_pwrdmn, 0);
175 if (ret) {
176 dev_err(dev, "power_domain_get() failed: %d\n", ret);
177 return ret;
178 }
179
180 ret = reset_get_by_index(dev, 0, &rproc->rproc_rst);
181 if (ret) {
182 dev_err(dev, "reset_get() failed: %d\n", ret);
183 return ret;
184 }
185
186 rproc->sci = ti_sci_get_by_phandle(dev, "ti,sci");
187 if (IS_ERR(rproc->sci)) {
188 dev_err(dev, "ti_sci get failed: %d\n", ret);
189 return PTR_ERR(rproc->sci);
190 }
191
192 rproc->gtc_base = dev_read_addr_ptr(dev);
193 if (!rproc->gtc_base) {
194 dev_err(dev, "Get address failed\n");
195 return -ENODEV;
196 }
197
198 rproc->proc_id = dev_read_u32_default(dev, "ti,sci-proc-id",
199 INVALID_ID);
200 rproc->host_id = dev_read_u32_default(dev, "ti,sci-host-id",
201 INVALID_ID);
202
203 return 0;
204 }
205
206 /**
207 * k3_rproc_probe() - Basic probe
208 * @dev: corresponding k3 remote processor device
209 *
210 * Return: 0 if all goes good, else appropriate error message.
211 */
k3_rproc_probe(struct udevice * dev)212 static int k3_rproc_probe(struct udevice *dev)
213 {
214 struct k3_rproc_privdata *priv;
215 int ret;
216
217 dev_dbg(dev, "%s\n", __func__);
218
219 priv = dev_get_priv(dev);
220
221 ret = k3_rproc_of_to_priv(dev, priv);
222 if (ret) {
223 dev_dbg(dev, "%s: Probe failed with error %d\n", __func__, ret);
224 return ret;
225 }
226
227 dev_dbg(dev, "Remoteproc successfully probed\n");
228
229 return 0;
230 }
231
232 static const struct udevice_id k3_rproc_ids[] = {
233 { .compatible = "ti,am654-rproc"},
234 {}
235 };
236
237 U_BOOT_DRIVER(k3_rproc) = {
238 .name = "k3_rproc",
239 .of_match = k3_rproc_ids,
240 .id = UCLASS_REMOTEPROC,
241 .ops = &k3_rproc_ops,
242 .probe = k3_rproc_probe,
243 .priv_auto_alloc_size = sizeof(struct k3_rproc_privdata),
244 };
245