1 /* 2 * (C) Copyright 2015 3 * Texas Instruments Incorporated - http://www.ti.com/ 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 #include <common.h> 7 #include <command.h> 8 #include <dm.h> 9 #include <errno.h> 10 #include <malloc.h> 11 #include <remoteproc.h> 12 13 /** 14 * print_remoteproc_list() - print all the remote processor devices 15 * 16 * Return: 0 if no error, else returns appropriate error value. 17 */ 18 static int print_remoteproc_list(void) 19 { 20 struct udevice *dev; 21 struct uclass *uc; 22 int ret; 23 char *type; 24 25 ret = uclass_get(UCLASS_REMOTEPROC, &uc); 26 if (ret) { 27 printf("Cannot find Remote processor class\n"); 28 return ret; 29 } 30 31 uclass_foreach_dev(dev, uc) { 32 struct dm_rproc_uclass_pdata *uc_pdata; 33 const struct dm_rproc_ops *ops = rproc_get_ops(dev); 34 35 uc_pdata = dev_get_uclass_platdata(dev); 36 37 switch (uc_pdata->mem_type) { 38 case RPROC_INTERNAL_MEMORY_MAPPED: 39 type = "internal memory mapped"; 40 break; 41 default: 42 type = "unknown"; 43 break; 44 } 45 printf("%d - Name:'%s' type:'%s' supports: %s%s%s%s%s%s\n", 46 dev->seq, 47 uc_pdata->name, 48 type, 49 ops->load ? "load " : "", 50 ops->start ? "start " : "", 51 ops->stop ? "stop " : "", 52 ops->reset ? "reset " : "", 53 ops->is_running ? "is_running " : "", 54 ops->ping ? "ping " : ""); 55 } 56 return 0; 57 } 58 59 /** 60 * do_rproc_init() - do basic initialization 61 * @cmdtp: unused 62 * @flag: unused 63 * @argc: unused 64 * @argv: unused 65 * 66 * Return: 0 if no error, else returns appropriate error value. 67 */ 68 static int do_rproc_init(cmd_tbl_t *cmdtp, int flag, int argc, 69 char *const argv[]) 70 { 71 if (rproc_is_initialized()) { 72 printf("\tRemote Processors are already initialized\n"); 73 } else { 74 if (!rproc_init()) 75 return 0; 76 printf("Few Remote Processors failed to be initalized\n"); 77 } 78 79 return CMD_RET_FAILURE; 80 } 81 82 /** 83 * do_remoteproc_list() - print list of remote proc devices. 84 * @cmdtp: unused 85 * @flag: unused 86 * @argc: unused 87 * @argv: unused 88 * 89 * Return: 0 if no error, else returns appropriate error value. 90 */ 91 static int do_remoteproc_list(cmd_tbl_t *cmdtp, int flag, int argc, 92 char *const argv[]) 93 { 94 if (!rproc_is_initialized()) { 95 printf("\t Remote Processors is not initialized\n"); 96 return CMD_RET_USAGE; 97 } 98 99 if (print_remoteproc_list()) 100 return CMD_RET_FAILURE; 101 102 return 0; 103 } 104 105 /** 106 * do_remoteproc_load() - Load a remote processor with binary image 107 * @cmdtp: unused 108 * @flag: unused 109 * @argc: argument count for the load function 110 * @argv: arguments for the load function 111 * 112 * Return: 0 if no error, else returns appropriate error value. 113 */ 114 static int do_remoteproc_load(cmd_tbl_t *cmdtp, int flag, int argc, 115 char *const argv[]) 116 { 117 ulong addr, size; 118 int id, ret; 119 120 if (argc != 4) 121 return CMD_RET_USAGE; 122 123 id = (int)simple_strtoul(argv[1], NULL, 3); 124 addr = simple_strtoul(argv[2], NULL, 16); 125 126 size = simple_strtoul(argv[3], NULL, 16); 127 128 if (!size) { 129 printf("\t Expect some size??\n"); 130 return CMD_RET_USAGE; 131 } 132 133 if (!rproc_is_initialized()) { 134 printf("\tRemote Processors are not initialized\n"); 135 return CMD_RET_USAGE; 136 } 137 138 ret = rproc_load(id, addr, size); 139 printf("Load Remote Processor %d with data@addr=0x%08lx %lu bytes:%s\n", 140 id, addr, size, ret ? " Failed!" : " Success!"); 141 142 return ret ? CMD_RET_FAILURE : 0; 143 } 144 145 /** 146 * do_remoteproc_wrapper() - wrapper for various rproc commands 147 * @cmdtp: unused 148 * @flag: unused 149 * @argc: argument count for the rproc command 150 * @argv: arguments for the rproc command 151 * 152 * Most of the commands just take id as a parameter andinvoke various 153 * helper routines in remote processor core. by using a set of 154 * common checks, we can reduce the amount of code used for this. 155 * 156 * Return: 0 if no error, else returns appropriate error value. 157 */ 158 static int do_remoteproc_wrapper(cmd_tbl_t *cmdtp, int flag, int argc, 159 char *const argv[]) 160 { 161 int id, ret = CMD_RET_USAGE; 162 163 if (argc != 2) 164 return CMD_RET_USAGE; 165 166 id = (int)simple_strtoul(argv[1], NULL, 3); 167 168 if (!rproc_is_initialized()) { 169 printf("\tRemote Processors are not initialized\n"); 170 return CMD_RET_USAGE; 171 } 172 173 if (!strcmp(argv[0], "start")) { 174 ret = rproc_start(id); 175 } else if (!strcmp(argv[0], "stop")) { 176 ret = rproc_stop(id); 177 } else if (!strcmp(argv[0], "reset")) { 178 ret = rproc_reset(id); 179 } else if (!strcmp(argv[0], "is_running")) { 180 ret = rproc_is_running(id); 181 if (!ret) { 182 printf("Remote processor is Running\n"); 183 } else if (ret == 1) { 184 printf("Remote processor is NOT Running\n"); 185 ret = 0; 186 } 187 /* Else error.. */ 188 } else if (!strcmp(argv[0], "ping")) { 189 ret = rproc_ping(id); 190 if (!ret) { 191 printf("Remote processor responds 'Pong'\n"); 192 } else if (ret == 1) { 193 printf("No response from Remote processor\n"); 194 ret = 0; 195 } 196 /* Else error.. */ 197 } 198 199 if (ret < 0) 200 printf("Operation Failed with error (%d)\n", ret); 201 202 return ret ? CMD_RET_FAILURE : 0; 203 } 204 205 static cmd_tbl_t cmd_remoteproc_sub[] = { 206 U_BOOT_CMD_MKENT(init, 0, 1, do_rproc_init, 207 "Enumerate and initialize all processors", ""), 208 U_BOOT_CMD_MKENT(list, 0, 1, do_remoteproc_list, 209 "list remote processors", ""), 210 U_BOOT_CMD_MKENT(load, 5, 1, do_remoteproc_load, 211 "Load remote processor with provided image", 212 "<id> [addr] [size]\n" 213 "- id: ID of the remote processor(see 'list' cmd)\n" 214 "- addr: Address in memory of the image to loadup\n" 215 "- size: Size of the image to loadup\n"), 216 U_BOOT_CMD_MKENT(start, 1, 1, do_remoteproc_wrapper, 217 "Start remote processor", 218 "id - ID of the remote processor (see 'list' cmd)\n"), 219 U_BOOT_CMD_MKENT(stop, 1, 1, do_remoteproc_wrapper, 220 "Stop remote processor", 221 "id - ID of the remote processor (see 'list' cmd)\n"), 222 U_BOOT_CMD_MKENT(reset, 1, 1, do_remoteproc_wrapper, 223 "Reset remote processor", 224 "id - ID of the remote processor (see 'list' cmd)\n"), 225 U_BOOT_CMD_MKENT(is_running, 1, 1, do_remoteproc_wrapper, 226 "Check to see if remote processor is running\n", 227 "id - ID of the remote processor (see 'list' cmd)\n"), 228 U_BOOT_CMD_MKENT(ping, 1, 1, do_remoteproc_wrapper, 229 "Ping to communicate with remote processor\n", 230 "id - ID of the remote processor (see 'list' cmd)\n"), 231 }; 232 233 /** 234 * do_remoteproc() - (replace: short desc) 235 * @cmdtp: unused 236 * @flag: unused 237 * @argc: argument count 238 * @argv: argument list 239 * 240 * parses up the command table to invoke the correct command. 241 * 242 * Return: 0 if no error, else returns appropriate error value. 243 */ 244 static int do_remoteproc(cmd_tbl_t *cmdtp, int flag, int argc, 245 char *const argv[]) 246 { 247 cmd_tbl_t *c = NULL; 248 249 /* Strip off leading 'rproc' command argument */ 250 argc--; 251 argv++; 252 253 if (argc) 254 c = find_cmd_tbl(argv[0], cmd_remoteproc_sub, 255 ARRAY_SIZE(cmd_remoteproc_sub)); 256 if (c) 257 return c->cmd(cmdtp, flag, argc, argv); 258 259 return CMD_RET_USAGE; 260 } 261 262 U_BOOT_CMD(rproc, 5, 1, do_remoteproc, 263 "Control operation of remote processors in an SoC", 264 " [init|list|load|start|stop|reset|is_running|ping]\n" 265 "\t\t Where:\n" 266 "\t\t[addr] is a memory address\n" 267 "\t\t<id> is a numerical identifier for the remote processor\n" 268 "\t\t provided by 'list' command.\n" 269 "\t\tNote: Remote processors must be initalized prior to usage\n" 270 "\t\tNote: Services are dependent on the driver capability\n" 271 "\t\t 'list' command shows the capability of each device\n" 272 "\n\tSubcommands:\n" 273 "\tinit - Enumerate and initalize the remote processors\n" 274 "\tlist - list available remote processors\n" 275 "\tload <id> [addr] [size]- Load the remote processor with binary\n" 276 "\t image stored at address [addr] in memory\n" 277 "\tstart <id> - Start the remote processor(must be loaded)\n" 278 "\tstop <id> - Stop the remote processor\n" 279 "\treset <id> - Reset the remote processor\n" 280 "\tis_running <id> - Reports if the remote processor is running\n" 281 "\tping <id> - Ping the remote processor for communication\n"); 282