Bug fixes, cleanup, expanded test code
[keystone-rtos/rm-lld.git] / src / rm_transport.c
1 /**\r
2  *   @file  rm.c\r
3  *\r
4  *   @brief   \r
5  *      This is the Resource Manager source.\r
6  *\r
7  *  \par\r
8  *  ============================================================================\r
9  *  @n   (C) Copyright 2012, Texas Instruments, Inc.\r
10  * \r
11  *  Redistribution and use in source and binary forms, with or without \r
12  *  modification, are permitted provided that the following conditions \r
13  *  are met:\r
14  *\r
15  *    Redistributions of source code must retain the above copyright \r
16  *    notice, this list of conditions and the following disclaimer.\r
17  *\r
18  *    Redistributions in binary form must reproduce the above copyright\r
19  *    notice, this list of conditions and the following disclaimer in the \r
20  *    documentation and/or other materials provided with the   \r
21  *    distribution.\r
22  *\r
23  *    Neither the name of Texas Instruments Incorporated nor the names of\r
24  *    its contributors may be used to endorse or promote products derived\r
25  *    from this software without specific prior written permission.\r
26  *\r
27  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
28  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
29  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
30  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
31  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
32  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
33  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
34  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
35  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
36  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
37  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
38  *\r
39  *  \par\r
40 */\r
41 \r
42 /* RM Types */\r
43 #include <ti/drv/rm/rm_types.h>\r
44 \r
45 /* RM external includes */\r
46 #include <ti/drv/rm/rm.h>\r
47 #include <ti/drv/rm/rm_transport.h>\r
48 \r
49 /* RM internal includes */\r
50 #include <ti/drv/rm/include/rm_loc.h>\r
51 #include <ti/drv/rm/include/rm_transportloc.h>\r
52 \r
53 /* RM OSAL layer */\r
54 #include <rm_osal.h>\r
55 \r
56 /**********************************************************************\r
57  ********************** Internal Functions ****************************\r
58  **********************************************************************/\r
59 \r
60 Rm_TransportNode *Rm_transportNodeAdd(Rm_Inst *rmInst, Rm_TransportCfg *transportCfg)\r
61 {\r
62     Rm_TransportNode *routeMap = (Rm_TransportNode *)rmInst->routeMap;\r
63     Rm_TransportNode *newTransportNode = NULL;\r
64 \r
65     /* Get memory for a new transport node from local memory */\r
66     newTransportNode = Rm_osalMalloc (sizeof(Rm_TransportNode));\r
67 \r
68     /* Return if the memory allocated for the transport node is NULL */\r
69     if (newTransportNode != NULL)\r
70     {\r
71         /* Populate the new entry */\r
72         newTransportNode->rmHandle = (Rm_Handle) rmInst;\r
73         newTransportNode->remoteInstType = transportCfg->remoteInstType;\r
74         strcpy(&(newTransportNode->remoteInstName)[0], transportCfg->remoteInstName);\r
75         newTransportNode->nextNode = NULL;  /* New node will always be NULL */\r
76 \r
77         /* Check if there are any nodes in the transport routing map */\r
78         if (routeMap)\r
79         {\r
80             /* At least one node in the routing map.  Add the new node to the end of the\r
81              * routing map */\r
82             while (routeMap->nextNode != NULL)\r
83             {\r
84                 /* Traverse the list until arriving at the last node */\r
85                 routeMap = (Rm_TransportNode *)routeMap->nextNode;\r
86             }\r
87 \r
88             /* Add the new node to the end of the list */\r
89             routeMap->nextNode = (void *)newTransportNode;\r
90         }\r
91         else\r
92         {\r
93             /* The transport routing map does not currently exist.  The new node is the first node */\r
94             rmInst->routeMap = (void *)newTransportNode;\r
95         }\r
96     }\r
97 \r
98     return (newTransportNode);\r
99 }\r
100 \r
101 Rm_TransportNode *Rm_transportNodeFindTransportHandle(Rm_Inst *rmInst, \r
102                                                       Rm_TransportHandle transportHandle)\r
103 {\r
104     Rm_TransportNode *transportNode = (Rm_TransportNode *)rmInst->routeMap;\r
105 \r
106     /* Make sure there is at least one node in the route map */\r
107     if (transportNode != NULL)\r
108     {\r
109         /* Find the transport node with the transport handle within the RM instance's\r
110          * route map.  If the end of the route map is reached without finding the node the \r
111          * node pointer will be NULL */\r
112         while (transportNode != NULL)\r
113         {\r
114             /* The transport handle is the address of the transport node */\r
115             if (transportNode == ((Rm_TransportNode *)transportHandle))\r
116             {\r
117                 /* Match: break out of loop and return the node */\r
118                 break;             \r
119             }\r
120             transportNode = (Rm_TransportNode *)transportNode->nextNode;\r
121         }\r
122     }\r
123 \r
124     return (transportNode);\r
125 }\r
126 \r
127 Rm_TransportNode *Rm_transportNodeFindRemoteName(Rm_Inst *rmInst, char *remoteName)\r
128 {\r
129     Rm_TransportNode *transportNode = (Rm_TransportNode *)rmInst->routeMap;\r
130 \r
131     /* Make sure there is at least one node in the route map */\r
132     if (transportNode != NULL)\r
133     {\r
134         /* Find the transport node with the provided remote instance name.\r
135          * If the end of the route map is reached without finding the node the \r
136          * node pointer will be NULL */\r
137         while (transportNode != NULL)\r
138         {\r
139             /* The transport handle is the address of the transport node */\r
140             if (strcmp(&(transportNode->remoteInstName)[0], remoteName) == 0)\r
141             {\r
142                 /* Match: break out of loop and return the node */\r
143                 break;             \r
144             }\r
145             transportNode = (Rm_TransportNode *)transportNode->nextNode;\r
146         }\r
147     }\r
148 \r
149     return (transportNode);\r
150 }\r
151 \r
152 Rm_TransportNode *Rm_transportNodeFindRemoteInstType(Rm_Inst *rmInst,\r
153                                                      Rm_InstType remoteInstType)\r
154 {\r
155     Rm_TransportNode *transportNode = (Rm_TransportNode *)rmInst->routeMap;\r
156 \r
157     /* Make sure there is at least one node in the route map */\r
158     if (transportNode != NULL)\r
159     {\r
160         /* Find the transport node with the provided remote instance type.\r
161          * If the end of the route map is reached without finding the node the \r
162          * node pointer will be NULL */\r
163         while (transportNode != NULL)\r
164         {\r
165             if (transportNode->remoteInstType == remoteInstType)\r
166             {\r
167                 /* Match: break out of loop and return the node */\r
168                 break;             \r
169             }\r
170             transportNode = (Rm_TransportNode *)transportNode->nextNode;\r
171         }\r
172     }\r
173 \r
174     return (transportNode);\r
175 }\r
176 \r
177 Rm_TransportResult Rm_transportNodeDelete(Rm_Inst *rmInst, Rm_TransportHandle transportHandle)\r
178 {\r
179     Rm_TransportNode *transportNode = (Rm_TransportNode *)rmInst->routeMap;\r
180     Rm_TransportNode *prevNode = NULL;\r
181 \r
182     /* Make sure there is at least one entry in the transaction queue */\r
183     if (transportNode == NULL)\r
184     {\r
185         return (RM_TRANSPORT_ERROR_NO_TRANSPORTS_REGISTERED);\r
186     }\r
187 \r
188     /* Find the transport handle within the RM instance's route map. */\r
189     while (transportNode != NULL)\r
190     {\r
191         if (transportNode == (Rm_TransportNode *) transportHandle)\r
192         {\r
193             /* Match: break out of loop and delete the entry */\r
194             break;             \r
195         }\r
196 \r
197         prevNode = transportNode;\r
198         transportNode = (Rm_TransportNode *)transportNode->nextNode;\r
199     }\r
200 \r
201     /* Traversed entire queue but did not find transaction */\r
202     if (transportNode == NULL)\r
203     {\r
204         return (RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED);\r
205     }\r
206     else\r
207     {\r
208         /* Delete the transport node */\r
209         if (prevNode == NULL)\r
210         {\r
211             /* Node to be deleted exists at start of route map.  Map second\r
212              * node to be start of route map as long as there are more than\r
213              * one nodes */\r
214             rmInst->routeMap = transportNode->nextNode;\r
215         }\r
216         else\r
217         {\r
218             /* Node to be deleted is in the middle or at end of the route map.  Adjust adjacent\r
219              * node pointers.  This covers the case where the node to be removed is at the\r
220              * end of the route map. */\r
221             prevNode->nextNode = transportNode->nextNode;\r
222         }\r
223 \r
224         /* Free the memory associated with the node. */\r
225         Rm_osalFree((void *) transportNode, sizeof(Rm_TransportNode));\r
226     }\r
227 \r
228     return (RM_TRANSPORT_SUCCESSFUL);\r
229 }\r
230 \r
231 Rm_Packet *Rm_transportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
232                                             Rm_Transaction *transaction)\r
233 {\r
234     Rm_Packet *rmPkt = NULL;\r
235     Rm_ResourceRequestPkt *resourceReqPkt = NULL;\r
236 \r
237     /* Make sure a buffer for the packet was allocated  */\r
238     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
239         NULL)\r
240     {\r
241         transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
242         return (NULL);\r
243     }\r
244 \r
245     /* Make sure allocated buffer is large enough to fit the request packet plus the \r
246      * rmPktLen and Rm_PktType fields */\r
247     if (rmPkt->pktLenBytes < (sizeof(Rm_ResourceRequestPkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
248     {   \r
249         transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
250         return (NULL);\r
251     }\r
252 \r
253     /* Set the Rm Packet type */    \r
254     rmPkt->pktType = Rm_pktType_RESOURCE_REQUEST;\r
255                           \r
256     /* Assign the packet's data field to be the start of the resource request packet */\r
257     resourceReqPkt = (Rm_ResourceRequestPkt *) rmPkt->data;\r
258     /* Populate the resource request packet using the transaction information */\r
259     resourceReqPkt->requestId = transaction->localId;\r
260     if (transaction->type == Rm_service_RESOURCE_ALLOCATE)\r
261     {\r
262         resourceReqPkt->resourceReqType = Rm_resReqPktType_ALLOCATE;\r
263     }\r
264     else if (transaction->type == Rm_service_RESOURCE_FREE)\r
265     {\r
266         resourceReqPkt->resourceReqType = Rm_resReqPktType_FREE;\r
267     }\r
268     else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)\r
269     {\r
270         resourceReqPkt->resourceReqType = Rm_resReqPktType_GET_NAMED;\r
271     }\r
272     strcpy(&(resourceReqPkt->instName)[0], rmInst->name);\r
273     /* Copy the resource data */\r
274     memcpy ((void *)&(resourceReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
275             sizeof(Rm_ResourceInfo));\r
276 \r
277     return (rmPkt);\r
278 }\r
279 \r
280 Rm_Packet *Rm_transportCreateResourceResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
281                                                  Rm_Transaction *transaction)\r
282 {\r
283     Rm_Packet *rmPkt = NULL;\r
284     Rm_ResourceResponsePkt *resourceRespPkt = NULL;\r
285 \r
286     /* Make sure a buffer for the packet was allocated  */\r
287     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
288         NULL)\r
289     {\r
290         transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
291         return (NULL);\r
292     }\r
293 \r
294     /* Make sure allocated buffer is large enough to fit the request packet plus the \r
295      * rmPktLen and Rm_PktType fields */\r
296     if (rmPkt->pktLenBytes < (sizeof(Rm_ResourceResponsePkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
297     {   \r
298         transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
299         return (NULL);\r
300     }\r
301 \r
302     /* Set the Rm Packet type */    \r
303     rmPkt->pktType = Rm_pktType_RESOURCE_RESPONSE;\r
304                           \r
305     /* Assign the packet's data field to be the start of the resource response packet */\r
306     resourceRespPkt = (Rm_ResourceResponsePkt *)rmPkt->data;\r
307     /* Populate the resource response packet using the transaction information.  The\r
308      * responseId is the remoteOriginatingId.  The responseId must match the local ID \r
309      * of the transaction that originated the request */\r
310     resourceRespPkt->responseId = transaction->remoteOriginatingId;\r
311     resourceRespPkt->requestState = transaction->state;\r
312     /* Copy the resource data */\r
313     memcpy ((void *)&(resourceRespPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
314             sizeof(Rm_ResourceInfo));\r
315 \r
316     return (rmPkt);\r
317 }\r
318 \r
319 Rm_Packet *Rm_transportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
320                                           Rm_Transaction *transaction)\r
321 {\r
322     Rm_Packet *rmPkt = NULL;\r
323     Rm_NsRequestPkt *nsReqPkt = NULL;\r
324 \r
325     /* Make sure a buffer for the packet was allocated  */\r
326     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
327         NULL)\r
328     {\r
329         transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
330         return (NULL);\r
331     }\r
332 \r
333     /* Make sure allocated buffer is large enough to fit the request packet plus the \r
334      * rmPktLen and Rm_PktType fields */\r
335     if (rmPkt->pktLenBytes < (sizeof(Rm_NsRequestPkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
336     {   \r
337         transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
338         return (NULL);\r
339     }\r
340 \r
341     /* Set the Rm Packet type */    \r
342     rmPkt->pktType = Rm_pktType_NAMESERVER_REQUEST;\r
343                           \r
344     /* Assign the packet's data field to be the start of the NameServer request packet */\r
345     nsReqPkt = (Rm_NsRequestPkt *)rmPkt->data;\r
346     /* Populate the NameServer request packet using the transaction information */\r
347     nsReqPkt->requestId = transaction->localId;\r
348     if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME)\r
349     {\r
350         nsReqPkt->nsRequestType = Rm_nsReqPktType_MAP_RESOURCE;\r
351     }\r
352     else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME)\r
353     {\r
354         nsReqPkt->nsRequestType = Rm_nsReqPktType_UNMAP_RESOURCE;\r
355     }\r
356     strcpy(&(nsReqPkt->instName)[0], rmInst->name);\r
357     /* Copy the NameServer request data */\r
358     memcpy ((void *)&(nsReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
359             sizeof(Rm_ResourceInfo));\r
360 \r
361     return (rmPkt);\r
362 }\r
363 \r
364 Rm_Packet *Rm_transportCreateNsResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
365                                            Rm_Transaction *transaction)\r
366 {\r
367     Rm_Packet *rmPkt = NULL;\r
368     Rm_NsResponsePkt *nsRespPkt = NULL;\r
369 \r
370     /* Make sure a buffer for the packet was allocated  */\r
371     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
372         NULL)\r
373     {\r
374         transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
375         return (NULL);\r
376     }\r
377 \r
378     /* Make sure allocated buffer is large enough to fit the response packet plus the \r
379      * rmPktLen and Rm_PktType fields */\r
380     if (rmPkt->pktLenBytes < (sizeof(Rm_NsResponsePkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
381     {   \r
382         transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
383         return (NULL);\r
384     }\r
385 \r
386     /* Set the Rm Packet type */    \r
387     rmPkt->pktType = Rm_pktType_NAMESERVER_RESPONSE;\r
388                           \r
389     /* Assign the packet's data field to be the start of the NameServer response packet */\r
390     nsRespPkt = (Rm_NsResponsePkt *)rmPkt->data;\r
391     /* Populate the NameServer response packet using the transaction information. The\r
392      * responseId is the remoteOriginatingId.  The responseId must match the local ID \r
393      * of the transaction that originated the request */\r
394     nsRespPkt->responseId = transaction->remoteOriginatingId;\r
395     nsRespPkt->requestState = transaction->state;\r
396 \r
397     return (rmPkt);\r
398 }\r
399 \r
400 /**********************************************************************\r
401  ********************* Application visible APIs ***********************\r
402  **********************************************************************/\r
403 \r
404 Rm_TransportHandle Rm_transportRegister (Rm_Handle rmHandle, Rm_TransportCfg *transportCfg)\r
405 {\r
406     Rm_Inst *rmInst = (Rm_Inst *) rmHandle;\r
407     Rm_TransportNode *transportNode = NULL;\r
408     void *key;\r
409 \r
410     /* Lock access to the RM instance */\r
411     key = Rm_osalMtCsEnter();\r
412 \r
413     /* RM Servers cannot connect to other Servers.  RM Client Delegates cannot\r
414      * connect to other Client Delegates. */\r
415     if (((rmInst->instType == Rm_instType_SERVER) &&\r
416          (transportCfg->remoteInstType == Rm_instType_SERVER)) ||\r
417         ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
418          (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)))\r
419     {\r
420         goto exitCs; /* Error - return null */\r
421     }\r
422 \r
423     /* Verify Clients are not registering with more than one Client Delegate or Server. And\r
424      * that Client Delegate are not registering with more than one Server. */\r
425     if (rmInst->registeredWithDelegateOrServer &&\r
426         (((rmInst->instType == Rm_instType_CLIENT) &&\r
427           (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)) || \r
428          ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
429           (transportCfg->remoteInstType == Rm_instType_SERVER))))\r
430     {\r
431         goto exitCs; /* Error - return null */\r
432     }         \r
433 \r
434     /* Copy the transport callout function pointers into the RM instance as long as they're\r
435      * valid or not NULL */\r
436     if (transportCfg->transportCalloutsValid)\r
437     {\r
438         /* The transport APIs must not be NULL */\r
439         if ((transportCfg->transportCallouts.rmAllocPkt == NULL) ||\r
440             (transportCfg->transportCallouts.rmFreePkt == NULL) ||\r
441             (transportCfg->transportCallouts.rmSend == NULL) ||\r
442             (transportCfg->transportCallouts.rmReceive == NULL) ||\r
443             (transportCfg->transportCallouts.rmNumPktsReceived == NULL))\r
444         {\r
445             goto exitCs; /* Error - return null */\r
446         }\r
447             \r
448         /* Populate the instance transport callouts */\r
449         rmInst->transport.rmAllocPkt = transportCfg->transportCallouts.rmAllocPkt;\r
450         rmInst->transport.rmFreePkt = transportCfg->transportCallouts.rmFreePkt;\r
451         rmInst->transport.rmSend = transportCfg->transportCallouts.rmSend;\r
452         rmInst->transport.rmReceive = transportCfg->transportCallouts.rmReceive;\r
453         rmInst->transport.rmNumPktsReceived = transportCfg->transportCallouts.rmNumPktsReceived;\r
454     }\r
455 \r
456     /* Error checks passed - Create a new transport handle for the specified RM instance and\r
457      * create a new node in the RM instance's routing map. */\r
458     transportNode = Rm_transportNodeAdd(rmInst, transportCfg);\r
459 \r
460     /* Specify RM instance has registered with a higher level agent */\r
461     if ((transportNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
462         (transportNode->remoteInstType == Rm_instType_SERVER))\r
463     {\r
464         rmInst->registeredWithDelegateOrServer = true;\r
465     }\r
466 \r
467 exitCs:\r
468     \r
469     Rm_osalMtCsExit(key);\r
470     return ((Rm_TransportHandle) transportNode);\r
471 }\r
472 \r
473 Rm_TransportResult Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandle transportHandle)\r
474 {\r
475     Rm_Inst *rmInst = (Rm_Inst *) rmHandle;\r
476     Rm_TransportNode *transportNode = NULL;\r
477     Rm_TransportResult retVal = RM_TRANSPORT_SUCCESSFUL;\r
478     void *key;\r
479 \r
480     /* Lock access to the RM instance */\r
481     key = Rm_osalMtCsEnter();    \r
482 \r
483     /* Check if the transportHandle exists in the RM instance's route map */\r
484     transportNode = Rm_transportNodeFindTransportHandle(rmInst, transportHandle);\r
485 \r
486     if (transportNode == NULL)\r
487     {\r
488         /* Error - transport node does not exist in RM instance route map */\r
489         retVal = RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED;\r
490     }\r
491     else\r
492     {\r
493 \r
494         /* Remove specification that RM instance has been connected to an upper level agent\r
495          * if the node to be deleted has a remote instance type of Client Delegate or Server */\r
496         if ((transportNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
497             (transportNode->remoteInstType == Rm_instType_SERVER))\r
498         {\r
499             rmInst->registeredWithDelegateOrServer = false;\r
500         }\r
501 \r
502         /* Delete the transport node */\r
503         retVal = Rm_transportNodeDelete(rmInst, transportHandle);\r
504     }\r
505 \r
506     Rm_osalMtCsExit(key);\r
507     return (retVal);\r
508 }\r
509 \r
510 /* Used by the application to pass RM packets received from a transport to RM.\r
511  * CODE THE FUNCTION SUCH THAT IT CAN BE CALLED DIRECTLY BY APP OR BE PLUGGED\r
512  * AS PART OF AN ISR HANDLER FOR THE TRANSACTION RECEIVE */\r
513 int32_t Rm_receivePktIsr(Rm_TransportHandle transportHandle, Rm_Packet *pkt)\r
514 {\r\r\r
515     Rm_Inst *rmInst = (Rm_Inst *)((Rm_TransportNode *)transportHandle)->rmHandle;\r
516     Rm_Transaction *transaction;\r
517 \r
518     /* Make sure the transport handle is registered with the provided RM instance */\r
519     if (Rm_transportNodeFindTransportHandle(rmInst, transportHandle) == NULL)\r
520     {\r
521         /* Transport is not registered with the RM instance.  Return an error.\r
522          * The packet cannot be freed since the transport handle is not valid. */\r
523         return (RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED);\r
524     }\r
525 \r
526     /* Based on packet type transfer the data to a transaction or a policy structure */\r
527     switch (pkt->pktType)\r
528     {\r
529         case Rm_pktType_RESOURCE_REQUEST:\r
530         {\r
531             Rm_ResourceRequestPkt *resourceReqPkt = (Rm_ResourceRequestPkt *)pkt->data;\r
532 \r
533             /* Create the request transaction filling in the remoteOriginatingId using\r
534              * the request packet's ID.  The request packet's ID will map to the \r
535              * the request transaction that issued the request packet. */\r
536             transaction = Rm_transactionQueueAdd(rmInst);\r
537             transaction->remoteOriginatingId = resourceReqPkt->requestId;\r
538 \r
539             /* Transfer the rest of the data into the transaction */\r
540             if (resourceReqPkt->resourceReqType == Rm_resReqPktType_ALLOCATE)\r
541             {\r
542                 transaction->type = Rm_service_RESOURCE_ALLOCATE;\r
543             }\r
544             else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_FREE)\r
545             {\r
546                 transaction->type = Rm_service_RESOURCE_FREE;\r
547             }\r
548             else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_GET_NAMED)\r
549             {\r
550                 transaction->type = Rm_service_RESOURCE_GET_BY_NAME;\r
551             }            \r
552 \r
553             strcpy(transaction->sourceInstName, resourceReqPkt->instName);\r
554             transaction->state = RM_SERVICE_PROCESSING;\r
555             memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceReqPkt->resourceInfo),\r
556                     sizeof(Rm_ResourceInfo));\r
557 \r
558             /* Process the transaction */\r
559             Rm_transactionProcessor(rmInst, transaction);\r
560             break;\r
561         }\r
562         case Rm_pktType_RESOURCE_RESPONSE:\r
563         {\r
564             Rm_ResourceResponsePkt *resourceRespPkt = (Rm_ResourceResponsePkt *)pkt->data;\r
565 \r
566             /* Find the transaction that is awaiting the response */\r
567             if (transaction = Rm_transactionQueueFind(rmInst,resourceRespPkt->responseId))\r
568             {\r
569                 /* Transfer the result of the request to the transaction */\r
570                 transaction->state = resourceRespPkt->requestState;\r
571 \r
572                 if ((transaction->state == RM_SERVICE_APPROVED_AND_COMPLETED) &&\r
573                     ((transaction->type == Rm_service_RESOURCE_ALLOCATE) ||\r
574                      (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)))\r
575                 {\r
576                     /* Copy resources from request for allocations since an allocation\r
577                      * can be specified as unknown.  If the request resources were unspecified\r
578                      * the RM instance will specify the resources obtained */\r
579                     memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceRespPkt->resourceInfo),\r
580                             sizeof(Rm_ResourceInfo));\r
581                 }\r
582                 \r
583                 /* Process the transaction */\r
584                 Rm_transactionProcessor(rmInst, transaction);\r
585             }\r
586             else\r
587             {\r
588                 rmInst->transport.rmFreePkt(transportHandle, pkt);\r
589                 return (RM_TRANSPORT_ERROR_MATCHING_RESOURCE_REQUEST_NOT_FOUND);\r
590             }\r
591             break;\r
592         }\r
593         case Rm_pktType_NAMESERVER_REQUEST:\r
594         {\r
595             Rm_NsRequestPkt *nsRequestPkt = (Rm_NsRequestPkt *)pkt->data;\r
596 \r
597             transaction = Rm_transactionQueueAdd(rmInst);\r
598             transaction->remoteOriginatingId = nsRequestPkt->requestId;\r
599 \r
600             if (nsRequestPkt->nsRequestType == Rm_nsReqPktType_MAP_RESOURCE)\r
601             {\r
602                 transaction->type = Rm_service_RESOURCE_MAP_TO_NAME;\r
603             }\r
604             else if (nsRequestPkt->nsRequestType == Rm_nsReqPktType_UNMAP_RESOURCE)\r
605             {\r
606                 transaction->type = Rm_service_RESOURCE_UNMAP_NAME;\r
607             }\r
608 \r
609             strcpy(transaction->sourceInstName, nsRequestPkt->instName);\r
610             transaction->state = Rm_transactionState_PROCESSING;\r
611             memcpy ((void *)&(transaction->resourceInfo), (void *)&(nsRequestPkt->resourceInfo),\r
612                     sizeof(Rm_ResourceInfo));\r
613 \r
614             /* Process the transaction */\r
615             Rm_transactionProcessor(rmInst, transaction);            \r
616             break;\r
617         }\r
618         case Rm_pktType_NAMESERVER_RESPONSE:\r
619         {\r
620             Rm_NsResponsePkt *nsResponsePkt = (Rm_NsResponsePkt *)pkt->data;\r
621 \r
622             /* Find the transaction that is awaiting the response */\r
623             if (transaction = Rm_transactionQueueFind(rmInst, nsResponsePkt->responseId))\r
624             {\r
625                 /* Transfer the state of the request to the transaction */\r
626                 transaction->state = nsResponsePkt->requestState;            \r
627 \r
628                 /* Process the transaction */\r
629                 Rm_transactionProcessor(rmInst, transaction);\r
630             }\r
631             else\r
632             {\r
633                 rmInst->transport.rmFreePkt(transportHandle, pkt);\r
634                 return (RM_TRANSPORT_ERROR_MATCHING_NAME_SERVER_REQUEST_NOT_FOUND);\r
635             }\r
636             break;\r
637         }\r
638         case Rm_pktType_POLICY_REQUEST:\r
639         {\r
640             Rm_PolicyRequestPkt *policyRequestPkt = (Rm_PolicyRequestPkt *)pkt->data;\r
641 \r
642             /* FILL IN POLICY API INFORMATION */\r
643             break;  \r
644         }\r
645         case Rm_pktType_POLICY_CHANGE:\r
646         {\r
647             Rm_PolicyChangePkt *policyChangePkt = (Rm_PolicyChangePkt *)pkt->data;\r
648 \r
649             /* FILL IN POLICY API INFORMATION */\r
650             break;\r
651         }\r
652         case Rm_pktType_RESOURCE_POOL_MODIFICATION_REQUEST:\r
653         {\r
654             Rm_ResourcePoolModRequestPkt *resPoolModReqPkt = (Rm_ResourcePoolModRequestPkt *)pkt->data;\r
655 \r
656             /* FILL IN RESOURCE POOL MODIFICATION API */\r
657             /* Rm_resourcePoolModRequestHandler(...); Server only - needs to allocate resources to\r
658              * the Client Delegate based on the policy and return those resources to the Client Delegate */\r
659             break;\r
660         }\r
661         case Rm_pktType_RESOURCE_POOL_MODIFICATION_RESPONSE:\r
662         {\r
663             Rm_ResourcePoolModResponsePkt *resPoolModRespPkt = (Rm_ResourcePoolModResponsePkt *)pkt->data;\r
664 \r
665             /* FILL IN RESOURCE POOL MODIFICAITON API */\r
666             /* Rm_resourcePoolModResponseHandler(...);  Handler needs to populate allocator with\r
667              * new resources provided in the response and then handle any request transactions waiting on\r
668              * the resource pool modification */\r
669             break;\r
670         }\r
671         default:\r
672             /* Invalid packet type.  Free the packet and return */\r
673             rmInst->transport.rmFreePkt(transportHandle, pkt);\r
674             return (RM_TRANSPORT_ERROR_INVALID_PACKET_TYPE);\r
675       }\r
676 \r
677     /* Free the packet after it has been processed */\r
678     rmInst->transport.rmFreePkt(transportHandle, pkt);\r
679     return (RM_TRANSPORT_SUCCESSFUL);\r
680 }\r
681 \r
682 /* Application can call this API so that RM handles reception of packets based on\r
683  * the RM handle and transport handle provided */\r
684 int32_t Rm_receivePktPolling(Rm_TransportHandle transportHandle)\r
685 {\r
686     Rm_Inst *rmInst = (Rm_Inst *)((Rm_TransportNode *)transportHandle)->rmHandle;\r
687     Rm_Packet *pkt = NULL;\r
688     int32_t retVal = RM_TRANSPORT_OK_BASE;\r
689 \r
690     /* Make sure the transport handle is registered with the provided RM instance */\r
691     if (Rm_transportNodeFindTransportHandle(rmInst, transportHandle) != NULL)\r
692     {\r
693         /* Check to see if any RM packets are available.  Process any available packets. */\r
694         while (rmInst->transport.rmNumPktsReceived(transportHandle) > 0)\r
695         {\r
696             pkt = rmInst->transport.rmReceive(transportHandle);\r
697 \r
698             if (pkt == NULL)\r
699             {\r
700                 retVal = RM_TRANSPORT_ERROR_PACKET_RECEPTION_ERROR;\r
701                 break;\r
702             }\r
703 \r
704             /* Pass the packet to RM.  The packet will be freed within the PktIsr API */\r
705             if (retVal = Rm_receivePktIsr(transportHandle, pkt) <= RM_SERVICE_ERROR_BASE)\r
706             {\r
707                 /* Return if an error is encountered */\r
708                 break;\r
709             }\r
710         }\r
711     }\r
712     else\r
713     {\r
714         /* Transport is not registered with the RM instance.  Return an error.\r
715          * The packet cannot be freed since the transport handle is not valid. */\r
716         retVal = RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED;\r
717     }\r
718 \r
719     return (retVal); \r
720 }\r
721 \r
722 /**\r
723 @}\r
724 */\r