Update demo apps to use new HIL proc APIs
[processor-sdk/open-amp.git] / apps / matrix_multiply / matrix_multiplyd.c
1 /* This is a sample demonstration application that showcases usage of remoteproc
2 and rpmsg APIs on the remote core. This application is meant to run on the remote CPU 
3 running baremetal code. This applicationr receives two matrices from the master, 
4 multiplies them and returns the result to the master core. */
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include "openamp/open_amp.h"
10 #include "rsc_table.h"
12 #define MAX_SIZE                6
13 #define NUM_MATRIX              2
14 #define SHUTDOWN_MSG            0xEF56A55A
16 typedef struct _matrix {
17         unsigned int size;
18         unsigned int elements[MAX_SIZE][MAX_SIZE];
19 } matrix;
21 /* Internal functions */
22 static void rpmsg_channel_created(struct rpmsg_channel *rp_chnl);
23 static void rpmsg_channel_deleted(struct rpmsg_channel *rp_chnl);
24 static void rpmsg_read_cb(struct rpmsg_channel *, void *, int, void *,
25                           unsigned long);
26 static void Matrix_Multiply(const matrix * m, const matrix * n, matrix * r);
28 /* Globals */
29 static struct rpmsg_channel *app_rp_chnl;
30 static struct rpmsg_endpoint *rp_ept;
31 static matrix matrix_array[NUM_MATRIX];
32 static matrix matrix_result;
33 static struct remote_proc *proc = NULL;
34 static struct rsc_table_info rsc_info;
35 static int evt_chnl_deleted = 0;
37 extern const struct remote_resource_table resources;
38 extern struct hil_proc *platform_create_proc(int proc_index);
40 /* External functions */
41 extern void init_system();
42 extern void cleanup_system();
44 /* Application entry point */
45 int main(void)
46 {
48         int status = 0;
49         struct hil_proc *hproc;
51         /* Initialize HW system components */
52         init_system();
54         rsc_info.rsc_tab = (struct resource_table *)&resources;
55         rsc_info.size = sizeof(resources);
57         /* Create HIL proc */
58         hproc = platform_create_proc(0);
59         if (!hproc)
60                 return -1;
62         /* Initialize RPMSG framework */
63         status =
64             remoteproc_resource_init(&rsc_info, hproc,
65                                      rpmsg_channel_created,
66                                      rpmsg_channel_deleted, rpmsg_read_cb,
67                                      &proc, 0);
68         if (RPROC_SUCCESS != status) {
69                 return -1;
70         }
72         do {
73                 hil_poll(proc->proc, 0);
74         } while (!evt_chnl_deleted);
76         remoteproc_resource_deinit(proc);
77         cleanup_system();
79         return 0;
80 }
83 static void rpmsg_channel_created(struct rpmsg_channel *rp_chnl)
84 {
85         app_rp_chnl = rp_chnl;
86         rp_ept = rpmsg_create_ept(rp_chnl, rpmsg_read_cb, RPMSG_NULL,
87                                   RPMSG_ADDR_ANY);
88 }
90 static void rpmsg_channel_deleted(struct rpmsg_channel *rp_chnl)
91 {
92         (void)rp_chnl;
94         rpmsg_destroy_ept(rp_ept);
95         rp_ept = NULL;
96         app_rp_chnl = NULL;
97 }
99 static void rpmsg_read_cb(struct rpmsg_channel *rp_chnl, void *data, int len,
100                           void *priv, unsigned long src)
102         (void)rp_chnl;
103         (void)priv;
104         (void)src;
106         if ((*(unsigned int *)data) == SHUTDOWN_MSG) {
107                 evt_chnl_deleted = 1;
108         } else {
109                 memcpy(matrix_array, data, len);
110                 /* Process received data and multiple matrices. */
111                 Matrix_Multiply(&matrix_array[0], &matrix_array[1],
112                                 &matrix_result);
114                 /* Send the result of matrix multiplication back to master. */
115                 rpmsg_send(app_rp_chnl, &matrix_result, sizeof(matrix));
116         }
119 static void Matrix_Multiply(const matrix * m, const matrix * n, matrix * r)
121         unsigned int i, j, k;
123         memset(r, 0x0, sizeof(matrix));
124         r->size = m->size;
126         for (i = 0; i < m->size; ++i) {
127                 for (j = 0; j < n->size; ++j) {
128                         for (k = 0; k < r->size; ++k) {
129                                 r->elements[i][j] +=
130                                     m->elements[i][k] * n->elements[k][j];
131                         }
132                 }
133         }