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