packages/ti/ipc/namesrv/NameServerRemoteRpmsg.c

   1 /*
   2  * Copyright (c) 2013, 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  */
  32 /*
  33  *  ======== NameServerRemoteRpmsg.c ========
  34  */
  35
  36 #include <xdc/std.h>
  37 #include <string.h>
  38
  39 #include <xdc/runtime/Assert.h>
  40 #include <xdc/runtime/Error.h>
  41 #include <xdc/runtime/Log.h>
  42 #include <xdc/runtime/Diags.h>
  43 #include <xdc/runtime/knl/ISync.h>
  44
  45 #include <ti/sysbios/gates/GateMutex.h>
  46 #include <ti/sysbios/knl/Semaphore.h>
  47 #include <ti/sdo/utils/_NameServer.h>
  48 #include <ti/sdo/utils/INameServerRemote.h>
  49 #include <ti/ipc/MultiProc.h>
  50 #include <ti/ipc/namesrv/_NameServerRemoteRpmsg.h>
  51 #include <ti/ipc/rpmsg/RPMessage.h>
  52
  53 #include "package/internal/NameServerRemoteRpmsg.xdc.h"
  54
  55 /* Storage for NameServer message replies. Protected by gateMutex: */
  56 static  NameServerRemote_Msg    NameServer_msg;
  57
  58 /*
  59  *************************************************************************
  60  *                       Instance functions
  61  *************************************************************************
  62  */
  63 #define FXNN "NameServerRemoteRpmsg_Instance_init"
  64 Void NameServerRemoteRpmsg_Instance_init(NameServerRemoteRpmsg_Object *obj,
  65         UInt16 remoteProcId,
  66         const NameServerRemoteRpmsg_Params *params)
  67 {
  68
  69     Log_print1(Diags_INFO, FXNN": remoteProc: %d", remoteProcId);
  70
  71     obj->remoteProcId = remoteProcId;
  72
  73     NameServerRemoteRpmsg_module->nsMsg = &NameServer_msg;
  74
  75     /* register the remote driver with NameServer */
  76     ti_sdo_utils_NameServer_registerRemoteDriver(
  77         NameServerRemoteRpmsg_Handle_upCast(obj), remoteProcId);
  78 }
  79 #undef FXNN
  80
  81 /*
  82  *  ======== NameServerRemoteRpmsg_Instance_finalize ========
  83  */
  84 Void NameServerRemoteRpmsg_Instance_finalize(NameServerRemoteRpmsg_Object *obj)
  85 {
  86     /* unregister remote driver from NameServer module */
  87     ti_sdo_utils_NameServer_unregisterRemoteDriver(obj->remoteProcId);
  88 }
  89
  90 /*
  91  *************************************************************************
  92  *                       Module functions
  93  *************************************************************************
  94  */
  95
  96  /*
  97  *  ======== NameServerRemoteRpmsg_attach ========
  98  *
  99  *  Typically called from Ipc_attach(), but since Rpmsg doesn't use Ipc
 100  *  module, this may need to be called manually.
 101  */
 102 #define FXNN "NameServerRemoteRpmsg_attach"
 103 Int NameServerRemoteRpmsg_attach(UInt16 remoteProcId, Ptr sharedAddr)
 104 {
 105     Int status = NameServerRemoteRpmsg_E_FAIL;
 106     NameServerRemoteRpmsg_Handle handle;
 107
 108     Log_print1(Diags_INFO, FXNN": remoteProcId: %d", remoteProcId);
 109
 110     handle = NameServerRemoteRpmsg_create(remoteProcId, NULL, NULL);
 111     if (handle != NULL) {
 112         status = NameServerRemoteRpmsg_S_SUCCESS;
 113     }
 114
 115     return (status);
 116 }
 117 #undef FXNN
 118
 119 /*
 120  *  ======== NameServerRemoteRpmsg_detach ========
 121  *
 122  *  Typically called from Ipc_detach(), but since Rpmsg doesn't use Ipc
 123  *  module, this may need to be called manually.
 124  */
 125 #define FXNN "NameServerRemoteRpmsg_detach"
 126 Int NameServerRemoteRpmsg_detach(UInt16 remoteProcId)
 127 {
 128     NameServerRemoteRpmsg_Handle handle;
 129     Int status = NameServerRemoteRpmsg_S_SUCCESS;
 130
 131     Log_print1(Diags_INFO, FXNN": remoteProcId: %d", remoteProcId);
 132
 133     for (handle = NameServerRemoteRpmsg_Object_first(); handle != NULL;
 134         handle = NameServerRemoteRpmsg_Object_next(handle)) {
 135         if (handle->remoteProcId == remoteProcId) {
 136             break;
 137         }
 138     }
 139
 140     if (handle == NULL) {
 141         status = NameServerRemoteRpmsg_E_FAIL;
 142     }
 143     else {
 144         NameServerRemoteRpmsg_delete(&handle);
 145     }
 146
 147     return (status);
 148 }
 149 #undef FXNN
 150
 151 /*
 152  *  ======== NameServerRemoteRpmsg_get ========
 153  */
 154 #define FXNN "NameServerRemoteRpmsg_get"
 155 Int NameServerRemoteRpmsg_get(NameServerRemoteRpmsg_Object *obj,
 156         String instanceName, String name, Ptr value, UInt32 *valueLen,
 157         ISync_Handle syncHandle, Error_Block *eb)
 158 {
 159     Int                   status = NameServer_E_NOTFOUND;
 160     Int                   len;
 161     IArg                  key;
 162     NameServerRemote_Msg  msg;
 163     NameServerRemote_Msg  *replyMsg;
 164     Semaphore_Handle      semRemoteWait =
 165                            NameServerRemoteRpmsg_module->semRemoteWait;
 166
 167     GateMutex_Handle gateMutex = NameServerRemoteRpmsg_module->gateMutex;
 168
 169     /* enter gate - prevent multiple threads from entering */
 170     key = GateMutex_enter(gateMutex);
 171
 172     /* Check that host NameServer is alive to avoid pinging the host: */
 173     if (NameServerRemoteRpmsg_module->nsPort == NAME_SERVER_PORT_INVALID) {
 174         status = NameServer_E_NOTFOUND;
 175         goto exit;
 176     }
 177
 178     Log_print1(Diags_INFO, FXNN": name: %s", (IArg)name);
 179
 180     /* Create request message and send to remote processor: */
 181     msg.request = NameServerRemoteRpmsg_REQUEST;
 182     msg.requestStatus = 0;
 183
 184     len = strlen(instanceName);
 185     Assert_isTrue(len < MAXNAMEINCHAR, NameServerRemoteRpmsg_A_nameIsTooLong);
 186     strncpy((Char *)msg.instanceName, instanceName, len+1);
 187
 188     len = strlen(name);
 189     Assert_isTrue(len < MAXNAMEINCHAR, NameServerRemoteRpmsg_A_nameIsTooLong);
 190     strncpy((Char *)msg.name, name, len+1);
 191
 192     Log_print3(Diags_INFO, FXNN": Requesting from procId %d, %s:%s...\n",
 193                obj->remoteProcId, (IArg)msg.instanceName, (IArg)msg.name);
 194     RPMessage_send(obj->remoteProcId, NameServerRemoteRpmsg_module->nsPort,
 195                RPMSG_MESSAGEQ_PORT, (Ptr)&msg, sizeof(msg));
 196
 197     /* Now pend for response */
 198     status = Semaphore_pend(semRemoteWait, NameServerRemoteRpmsg_timeout);
 199
 200     if (status == FALSE) {
 201         Log_print0(Diags_INFO, FXNN": Wait for NS reply timed out\n");
 202         /* return timeout failure */
 203         return (NameServer_E_OSFAILURE);
 204     }
 205
 206     /* get the message */
 207     replyMsg = NameServerRemoteRpmsg_module->nsMsg;
 208
 209     if (replyMsg->requestStatus) {
 210         /* name is found */
 211
 212         /* set length to amount of data that was copied */
 213         *valueLen = sizeof(Bits32);
 214
 215         /* set the contents of value */
 216         memcpy(value, &(replyMsg->value), sizeof(Bits32));
 217
 218         /* set the status to success */
 219         status = NameServer_S_SUCCESS;
 220         Log_print4(Diags_INFO, FXNN": Reply from: %d, %s:%s, value: 0x%x...\n",
 221               obj->remoteProcId, (IArg)msg.instanceName, (IArg)msg.name,
 222               *(UInt32 *)value);
 223     }
 224     else {
 225         /* name is not found */
 226         Log_print2(Diags_INFO, FXNN": value for %s:%s not found.\n",
 227                    (IArg)msg.instanceName, (IArg)msg.name);
 228
 229         /* set status to not found */
 230         status = NameServer_E_NOTFOUND;
 231     }
 232
 233 exit:
 234     /* leave the gate */
 235     GateMutex_leave(gateMutex, key);
 236
 237     return (status);
 238 }
 239 #undef FXNN
 240
 241 /*
 242  *  ======== NameServerRemoteRpmsg_sharedMemReq ========
 243  */
 244 SizeT NameServerRemoteRpmsg_sharedMemReq(Ptr sharedAddr)
 245 {
 246     return (0);
 247 }
 248
 249 #define FXNN "NameServerRemote_processMessage"
 250 void NameServerRemote_processMessage(NameServerRemote_Msg * msg)
 251 {
 252     NameServer_Handle handle;
 253     Int               status = NameServer_E_FAIL;
 254     Semaphore_Handle  semRemoteWait =
 255                         NameServerRemoteRpmsg_module->semRemoteWait;
 256     UInt16 dstProc  = MultiProc_getId("HOST");
 257
 258     Assert_isTrue(msg != NULL, NULL);
 259
 260     if (msg->request == NameServerRemoteRpmsg_REQUEST) {
 261         Log_print1(Diags_INFO, FXNN": Request from procId %d.\n", dstProc);
 262
 263         /*
 264          *  Message is a request. Lookup name in NameServer table.
 265          *  Send a response message back to source processor.
 266          */
 267         handle = NameServer_getHandle((String)msg->instanceName);
 268
 269         if (handle != NULL) {
 270             /* Search for the NameServer entry */
 271             status = NameServer_getLocalUInt32(handle,
 272                      (String)msg->name, &msg->value);
 273         }
 274
 275         /* set the request status */
 276         if (status < 0) {
 277             Log_print2(Diags_INFO, FXNN": Replying with: %s:%s not found\n",
 278                        (IArg)msg->instanceName, (IArg)msg->name);
 279             msg->requestStatus = 0;
 280         }
 281         else {
 282             Log_print3(Diags_INFO, FXNN": Replying with: %s:%s, value: 0x%x\n",
 283                (IArg)msg->instanceName, (IArg)msg->name, msg->value);
 284             msg->requestStatus = 1;
 285         }
 286
 287         /* specify message as a response */
 288         msg->request = NameServerRemoteRpmsg_RESPONSE;
 289
 290         /* send response message to remote processor */
 291         RPMessage_send(dstProc, NameServerRemoteRpmsg_module->nsPort,
 292                  RPMSG_MESSAGEQ_PORT, (Ptr)msg, sizeof(NameServerRemote_Msg));
 293     }
 294     else {
 295         Log_print0(Diags_INFO, FXNN": NameServer Reply. Posting Sem...\n");
 296
 297         /* Save the response message.  */
 298         memcpy(NameServerRemoteRpmsg_module->nsMsg, msg,
 299                 sizeof (NameServerRemote_Msg));
 300         /* Post the semaphore upon which NameServer_get() is waiting */
 301         Semaphore_post(semRemoteWait);
 302     }
 303 }
 304 #undef FXNN
 305
 306 #define FXNN "NameServerRemote_SetNameServerPort"
 307 void NameServerRemote_SetNameServerPort(UInt port)
 308 {
 309     Log_print1(Diags_INFO, FXNN": nsPort: %d", port);
 310     NameServerRemoteRpmsg_module->nsPort = port;
 311 }
 312 #undef FXNN