RVC: Handling M4 message for reverse gear detection
[ivimm/rvc.git] / appA15HeartBeatHost.c
1 /*
2  * Copyright (c) 2016, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
33 /*
34  *  ======== appA15HeartBeatHost.c ========
35  *
36  */
38 /* host header files */
39 #include <stdio.h>
40 #include <unistd.h>
41 #include <time.h>
43 /* package header files */
44 #include <ti/ipc/Std.h>
45 #include <ti/ipc/Ipc.h>
46 #include <ti/ipc/transports/TransportRpmsg.h>
47 #include <ti/ipc/MessageQ.h>
48 #include <ti/ipc/MultiProc.h>
50 /* private functions */
51 static Int Main_main(Void);
52 static Int Main_parseArgs(Int argc, Char *argv[]);
54 /* local header files */
55 #include "appA15HeartBeatHost.h"
57 /* module structure */
58 typedef struct {
59     MessageQ_MsgHeader  reserved;
60     UInt32              cmd;
61 } App_Msg;
63 typedef struct {
64     MessageQ_Handle         hostQue;    // created locally
65     MessageQ_QueueId        slaveQue;   // opened remotely
66     UInt16                  heapId;     // MessageQ heapId
67     UInt32                  msgSize;
68 } App_Module;
70 /* private data */
71 static App_Module Module;
72 static String   Main_remoteProcName = NULL;
73 #ifdef DEBUG
74 static UInt32 MessageCount = 0;
75 #endif
76 /*
77  *  ======== App_create ========
78  */
80 Int App_create(UInt16 remoteProcId)
81 {
82     Int                 status = 0;
83     MessageQ_Params     msgqParams;
84     char                msgqName[32];
86     ALOGE("--> App_create:");
88     /* setting default values */
89     Module.hostQue = NULL;
90     Module.slaveQue = MessageQ_INVALIDMESSAGEQ;
91     Module.heapId = App_MsgHeapId;
92     Module.msgSize = sizeof(App_Msg);
94     /* create local message queue (inbound messages) */
95     MessageQ_Params_init(&msgqParams);
97     Module.hostQue = MessageQ_create(App_HostMsgQueName, &msgqParams);
99     if (Module.hostQue == NULL) {
100         ALOGE("App_create: Failed creating MessageQ");
101         status = -1;
102         goto leave;
103     }
105     /* open the remote message queue */
106     sprintf(msgqName, App_SlaveMsgQueName, MultiProc_getName(remoteProcId));
107     ALOGE("App_create: msgqName %s", msgqName);
108     do {
109         status = MessageQ_open(msgqName, &Module.slaveQue);
110         sleep(1);
111     } while (status == MessageQ_E_NOTFOUND);
113     if (status < 0) {
114         ALOGE("App_create: Failed opening MessageQ");
115         goto leave;
116     }
118     ALOGE("App_create: Host is ready");
120 leave:
121     ALOGE("<-- App_create:");
122     return(status);
126 /*
127  *  ======== App_delete ========
128  */
129 Int App_delete(Void)
131     Int         status;
133     ALOGE("--> App_delete:");
135     /* close remote resources */
136     status = MessageQ_close(&Module.slaveQue);
138     if (status < 0) {
139         goto leave;
140     }
142     /* delete the host message queue */
143     status = MessageQ_delete(&Module.hostQue);
145     if (status < 0) {
146         goto leave;
147     }
149 leave:
150     ALOGE("<-- App_delete:");
151     return(status);
155 /*
156  *  ======== App_exec ========
157  */
158 Int App_exec(Void)
160     Int         status;
161     Int         i;
162     App_Msg *   msg;
163     Bool        running = TRUE;
164     struct timeval tv;
166     ALOGE("--> App_exec:");
168     /* allocate message */
169     msg = (App_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);
171     if (msg == NULL) {
172         status = -1;
173         goto leave;
174     }
176     /* fill in message payload */
177     msg->cmd = App_CMD_START;
178 #ifdef DEBUG
179     MessageCount++;
180     // Get current time of day
181     gettimeofday(&tv, NULL);
182     ALOGE("%ld us: App_exec: sending #%d message %d \n",
183         (tv.tv_sec * 1000000) + tv.tv_usec, MessageCount, msg->cmd);
184 #endif
186     while (running) {
187         /* send START 1st message */
188         MessageQ_put(Module.slaveQue, (MessageQ_Msg)msg);
190         /* Wait for server message within 500ms */
191         status = MessageQ_get(Module.hostQue, (MessageQ_Msg *)&msg,
192             Microseconds);
193         /* Check the message from server that indicates GPIO reverse gear
194          * detected or non-reverse gear detected.
195          * If timeout, then reset the 500ms sleep and resend the A15 heartbeat
196          * to server.
197          * If reverse gear is detected, then set the A15 watchdog/panic
198          * timeout to 0 sec (no recovery/reboot should take place).
199          * If non-reverse is detected, then set the A15 watchdog/panic
200          * timout to 5 sec.
201          */
202         if ((status < 0) && (status != MessageQ_E_TIMEOUT)) {
203             ALOGE("--> App_exec: MessageQ_get FAILED");
204             status = -1;
205             goto leave;
206         }
208         if (status == MessageQ_S_SUCCESS) {
209             /* Received a message from server
210              * Extract message payload: check reverse or non-reverse indication
211              */
212             if (msg->cmd == App_CMD_RVC_UP) {
213                 ALOGE("--> App_exec: Message received App_CMD_RVC_UP");
214                 system("echo 0 > /proc/sys/kernel/panic");
215             }
216             else if (msg->cmd == App_CMD_RVC_DOWN) {
217                 ALOGE("--> App_exec: Message received App_CMD_RVC_DOWN");
218                 system("echo 5 > /proc/sys/kernel/panic");
219             }
221             /* Free the message from M4 -
222              * msg to indicate rvc reverse gear detected or not
223              */
224             MessageQ_free((MessageQ_Msg)msg);
225         }
227         if (status == MessageQ_E_TIMEOUT) {
228             /* Receive a TIMEOUT. No message from M4, continue heartbeat
229              */
230             //ALOGE("App_exec: message TIMEOUT, continue heartbeat \n");
231         }
233         /* Allocate message
234          */
235         msg = (App_Msg *)MessageQ_alloc(Module.heapId, Module.msgSize);
237         if (msg == NULL) {
238             ALOGE("--> App_exec: MessageQ_alloc FAILED");
239             status = -1;
240             goto leave;
241         }
243         /* Fill in message payload */
244         msg->cmd = App_CMD_ALIVE;
245 #ifdef DEBUG
246         MessageCount++;
247         gettimeofday(&tv, NULL);
248         ALOGE("%ld us: App_exec: sending #%d App_CMD_ALIVE \n",
249             (tv.tv_sec * 1000000) + tv.tv_usec, MessageCount);
250 #endif
251     }
253 leave:
254     ALOGE("<-- App_exec: %d\n", status);
255     return(status);
258 /*
259  *  ======== main ========
260  */
261 Int main(Int argc, Char* argv[])
263     Int status;
265     ALOGE("--> main:");
267     /* Configure the transport factory */
268     Ipc_transportConfig(&TransportRpmsg_Factory);
270     /* Parse command line */
271     status = Main_parseArgs(argc, argv);
273     if (status < 0) {
274         goto leave;
275     }
277     /* Ipc initialization */
278     status = Ipc_start();
280     if (status >= 0) {
281         /* Application create, exec, delete */
282         status = Main_main();
284         /* Ipc finalization */
285         Ipc_stop();
286     }
287     else {
288         ALOGE("Ipc_start failed: status = %d\n", status);
289         goto leave;
290     }
292 leave:
293     ALOGE("<-- main:\n");
294     status = (status >= 0 ? 0 : status);
296     return (status);
300 /*
301  *  ======== Main_main ========
302  */
303 Int Main_main(Void)
305     UInt16      remoteProcId;
306     Int         status = 0;
308     ALOGE("--> Main_main:\n");
310     remoteProcId = MultiProc_getId(Main_remoteProcName);
312     /* application create phase */
313     status = App_create(remoteProcId);
315     if (status < 0) {
316         goto leave;
317     }
319     /* application execute phase */
320     status = App_exec();
322     if (status < 0) {
323         goto leave;
324     }
326     /* application delete phase */
327     status = App_delete();
329     if (status < 0) {
330         goto leave;
331     }
333 leave:
334     ALOGE("<-- Main_main:");
336     status = (status >= 0 ? 0 : status);
337     return (status);
341 /*
342  *  ======== Main_parseArgs ========
343  */
344 Int Main_parseArgs(Int argc, Char *argv[])
346     Int             x, cp, opt, argNum;
347     UInt16          i, numProcs;
348     String          name;
349     Int             status = 0;
352     /* parse the command line options */
353     for (opt = 1; (opt < argc) && (argv[opt][0] == '-'); opt++) {
354         for (x = 0, cp = 1; argv[opt][cp] != '\0'; cp++) {
355             x = (x << 8) | (int)argv[opt][cp];
356         }
358         switch (x) {
359             case 'h': /* -h */
360                 ALOGE("%s", Main_USAGE);
361                 exit(0);
362                 break;
364             case 'l': /* -l */
365                 //ALOGE("Processor List");
366                 printf("Processor List\n");
367                 status = Ipc_start();
368                 if (status >= 0) {
369                     numProcs = MultiProc_getNumProcessors();
370                     for (i = 0; i < numProcs; i++) {
371                         name = MultiProc_getName(i);
372                         //ALOGE("    procId=%d, procName=%s", i, name);
373                         printf("    procId=%d, procName=%s\n", i, name);
374                     }
375                     Ipc_stop();
376                 }
377                 else {
378                     printf(
379                         "Error: %s, line %d: Ipc_start failed status %d\n",
380                         __FILE__, __LINE__, status);
381                     goto leave;
382                 }
383                 exit(0);
384                 break;
386             default:
387                 printf(
388                     "Error: %s, line %d: invalid option, %c\n",
389                     __FILE__, __LINE__, (Char)x);
390                 printf("%s", Main_USAGE);
391                 status = -1;
392                 goto leave;
393         }
394     }
396     /* parse the command line arguments */
397     for (argNum = 1; opt < argc; argNum++, opt++) {
399         switch (argNum) {
400             case 1: /* name of proc #1 */
401                 Main_remoteProcName = argv[opt];
402                 break;
404             default:
405                 printf(
406                     "Error: %s, line %d: too many arguments\n",
407                     __FILE__, __LINE__);
408                 printf("%s", Main_USAGE);
409                 status = -1;
410                 goto leave;
411         }
412     }
414     /* validate command line arguments */
415     if (Main_remoteProcName == NULL) {
416         printf("Error: missing procName argument\n");
417         printf("%s", Main_USAGE);
418         status = -1;
419         goto leave;
420     }
422 leave:
423     return(status);