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