CMake: generic: ZynqMP R5: udpate to use libxil, libmetal
[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 void *mat_mul_lock;
32 int need_to_cal = 0;
33 static struct rpmsg_endpoint *rp_ept;
34 static matrix matrix_array[NUM_MATRIX];
35 static matrix matrix_result;
36 static struct remote_proc *proc = NULL;
37 static struct rsc_table_info rsc_info;
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()
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 (status < 0) {
64                 return -1;
65         }
67         do {
68                 hil_poll(proc->proc, 0);
69         } while (!app_rp_chnl);
71         while(app_rp_chnl) {
72                 hil_poll(proc->proc, 0);
73         }
75         return 0;
76 }
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         rpmsg_destroy_ept(rp_ept);
88         rp_ept = NULL;
89         app_rp_chnl = NULL;
90 }
92 static void rpmsg_read_cb(struct rpmsg_channel *rp_chnl, void *data, int len,
93                           void *priv, unsigned long src)
94 {
95         if ((*(int *)data) == SHUTDOWN_MSG) {
96                 remoteproc_resource_deinit(proc);
97                 cleanup_system();
98         } else {
99                 memcpy(matrix_array, data, len);
100                 /* Process received data and multiple matrices. */
101                 Matrix_Multiply(&matrix_array[0], &matrix_array[1],
102                                 &matrix_result);
104                 /* Send the result of matrix multiplication back to master. */
105                 rpmsg_send(app_rp_chnl, &matrix_result, sizeof(matrix));
106         }
109 static void Matrix_Multiply(const matrix * m, const matrix * n, matrix * r)
111         int i, j, k;
113         memset(r, 0x0, sizeof(matrix));
114         r->size = m->size;
116         for (i = 0; i < m->size; ++i) {
117                 for (j = 0; j < n->size; ++j) {
118                         for (k = 0; k < r->size; ++k) {
119                                 r->elements[i][j] +=
120                                     m->elements[i][k] * n->elements[k][j];
121                         }
122                 }
123         }