47a22b37b23f50013760fd57737f688a7297b0cd
[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"
11 #include "platform_info.h"
13 #define MAX_SIZE                6
14 #define NUM_MATRIX              2
15 #define SHUTDOWN_MSG            0xEF56A55A
17 typedef struct _matrix {
18         unsigned int size;
19         unsigned int elements[MAX_SIZE][MAX_SIZE];
20 } matrix;
22 /* Internal functions */
23 static void rpmsg_channel_created(struct rpmsg_channel *rp_chnl);
24 static void rpmsg_channel_deleted(struct rpmsg_channel *rp_chnl);
25 static void rpmsg_read_cb(struct rpmsg_channel *, void *, int, void *,
26                           unsigned long);
27 static void Matrix_Multiply(const matrix * m, const matrix * n, matrix * r);
29 /* Globals */
30 static struct rpmsg_channel *app_rp_chnl;
31 static struct rpmsg_endpoint *rp_ept;
32 static matrix matrix_array[NUM_MATRIX];
33 static matrix matrix_result;
34 static struct remote_proc *proc = NULL;
35 static struct rsc_table_info rsc_info;
36 static int evt_chnl_deleted = 0;
38 extern const struct remote_resource_table resources;
39 extern struct rproc_info_plat_local proc_table;
41 /* External functions */
42 extern void init_system();
43 extern void cleanup_system();
45 /* Application entry point */
46 int main(void)
47 {
49         int status = 0;
51         /* Initialize HW system components */
52         init_system();
54         rsc_info.rsc_tab = (struct resource_table *)&resources;
55         rsc_info.size = sizeof(resources);
57         /* Initialize RPMSG framework */
58         status =
59             remoteproc_resource_init(&rsc_info, &proc_table,
60                                      rpmsg_channel_created,
61                                      rpmsg_channel_deleted, rpmsg_read_cb,
62                                      &proc, 0);
63         if (RPROC_SUCCESS != status) {
64                 return -1;
65         }
67         do {
68                 hil_poll(proc->proc, 0);
69         } while (!evt_chnl_deleted);
71         remoteproc_resource_deinit(proc);
72         cleanup_system();
74         return 0;
75 }
78 static void rpmsg_channel_created(struct rpmsg_channel *rp_chnl)
79 {
80         app_rp_chnl = rp_chnl;
81         rp_ept = rpmsg_create_ept(rp_chnl, rpmsg_read_cb, RPMSG_NULL,
82                                   RPMSG_ADDR_ANY);
83 }
85 static void rpmsg_channel_deleted(struct rpmsg_channel *rp_chnl)
86 {
87         (void)rp_chnl;
89         rpmsg_destroy_ept(rp_ept);
90         rp_ept = NULL;
91         app_rp_chnl = NULL;
92 }
94 static void rpmsg_read_cb(struct rpmsg_channel *rp_chnl, void *data, int len,
95                           void *priv, unsigned long src)
96 {
97         (void)rp_chnl;
98         (void)priv;
99         (void)src;
101         if ((*(unsigned int *)data) == SHUTDOWN_MSG) {
102                 evt_chnl_deleted = 1;
103         } else {
104                 memcpy(matrix_array, data, len);
105                 /* Process received data and multiple matrices. */
106                 Matrix_Multiply(&matrix_array[0], &matrix_array[1],
107                                 &matrix_result);
109                 /* Send the result of matrix multiplication back to master. */
110                 rpmsg_send(app_rp_chnl, &matrix_result, sizeof(matrix));
111         }
114 static void Matrix_Multiply(const matrix * m, const matrix * n, matrix * r)
116         unsigned int i, j, k;
118         memset(r, 0x0, sizeof(matrix));
119         r->size = m->size;
121         for (i = 0; i < m->size; ++i) {
122                 for (j = 0; j < n->size; ++j) {
123                         for (k = 0; k < r->size; ++k) {
124                                 r->elements[i][j] +=
125                                     m->elements[i][k] * n->elements[k][j];
126                         }
127                 }
128         }