Added pre-main capabilities, cleaned up services and NameServer modules
[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_INIT)\r
261     {\r
262         resourceReqPkt->resourceReqType = Rm_resReqPktType_ALLOCATE_INIT;\r
263     }\r
264     else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE)\r
265     {\r
266         resourceReqPkt->resourceReqType = Rm_resReqPktType_ALLOCATE_USE;\r
267     }    \r
268     else if (transaction->type == Rm_service_RESOURCE_FREE)\r
269     {\r
270         resourceReqPkt->resourceReqType = Rm_resReqPktType_FREE;\r
271     }\r
272     else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)\r
273     {\r
274         resourceReqPkt->resourceReqType = Rm_resReqPktType_GET_NAMED;\r
275     }\r
276     /* Pass along the packet source and service source information */\r
277     strcpy(resourceReqPkt->pktSrcInstName, rmInst->instName);\r
278     strcpy(resourceReqPkt->serviceSrcInstName, transaction->serviceSrcInstName);\r
279     /* Copy the resource data */\r
280     memcpy ((void *)&(resourceReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
281             sizeof(Rm_ResourceInfo));\r
282 \r
283     return (rmPkt);\r
284 }\r
285 \r
286 Rm_Packet *Rm_transportCreateResourceResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
287                                                  Rm_Transaction *transaction)\r
288 {\r
289     Rm_Packet *rmPkt = NULL;\r
290     Rm_ResourceResponsePkt *resourceRespPkt = NULL;\r
291 \r
292     /* Make sure a buffer for the packet was allocated  */\r
293     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
294         NULL)\r
295     {\r
296         transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
297         return (NULL);\r
298     }\r
299 \r
300     /* Make sure allocated buffer is large enough to fit the request packet plus the \r
301      * rmPktLen and Rm_PktType fields */\r
302     if (rmPkt->pktLenBytes < (sizeof(Rm_ResourceResponsePkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
303     {   \r
304         transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
305         return (NULL);\r
306     }\r
307 \r
308     /* Set the Rm Packet type */    \r
309     rmPkt->pktType = Rm_pktType_RESOURCE_RESPONSE;\r
310                           \r
311     /* Assign the packet's data field to be the start of the resource response packet */\r
312     resourceRespPkt = (Rm_ResourceResponsePkt *)rmPkt->data;\r
313     /* Populate the resource response packet using the transaction information.  The\r
314      * responseId is the remoteOriginatingId.  The responseId must match the local ID \r
315      * of the transaction that originated the request */\r
316     resourceRespPkt->responseId = transaction->remoteOriginatingId;\r
317     resourceRespPkt->requestState = transaction->state;\r
318     /* Copy the resource data */\r
319     memcpy ((void *)&(resourceRespPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
320             sizeof(Rm_ResourceInfo));\r
321 \r
322     return (rmPkt);\r
323 }\r
324 \r
325 Rm_Packet *Rm_transportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
326                                           Rm_Transaction *transaction)\r
327 {\r
328     Rm_Packet *rmPkt = NULL;\r
329     Rm_NsRequestPkt *nsReqPkt = NULL;\r
330 \r
331     /* Make sure a buffer for the packet was allocated  */\r
332     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
333         NULL)\r
334     {\r
335         transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
336         return (NULL);\r
337     }\r
338 \r
339     /* Make sure allocated buffer is large enough to fit the request packet plus the \r
340      * rmPktLen and Rm_PktType fields */\r
341     if (rmPkt->pktLenBytes < (sizeof(Rm_NsRequestPkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
342     {   \r
343         transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
344         return (NULL);\r
345     }\r
346 \r
347     /* Set the Rm Packet type */    \r
348     rmPkt->pktType = Rm_pktType_NAMESERVER_REQUEST;\r
349                           \r
350     /* Assign the packet's data field to be the start of the NameServer request packet */\r
351     nsReqPkt = (Rm_NsRequestPkt *)rmPkt->data;\r
352     /* Populate the NameServer request packet using the transaction information */\r
353     nsReqPkt->requestId = transaction->localId;\r
354     if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME)\r
355     {\r
356         nsReqPkt->nsRequestType = Rm_nsReqPktType_MAP_RESOURCE;\r
357     }\r
358     else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME)\r
359     {\r
360         nsReqPkt->nsRequestType = Rm_nsReqPktType_UNMAP_RESOURCE;\r
361     }\r
362     /* Pass along the packet source and service source information */\r
363     strcpy(nsReqPkt->pktSrcInstName, rmInst->instName);\r
364     strcpy(nsReqPkt->serviceSrcInstName, transaction->serviceSrcInstName);\r
365     /* Copy the NameServer request data */\r
366     memcpy ((void *)&(nsReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
367             sizeof(Rm_ResourceInfo));\r
368 \r
369     return (rmPkt);\r
370 }\r
371 \r
372 Rm_Packet *Rm_transportCreateNsResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
373                                            Rm_Transaction *transaction)\r
374 {\r
375     Rm_Packet *rmPkt = NULL;\r
376     Rm_NsResponsePkt *nsRespPkt = NULL;\r
377 \r
378     /* Make sure a buffer for the packet was allocated  */\r
379     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
380         NULL)\r
381     {\r
382         transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
383         return (NULL);\r
384     }\r
385 \r
386     /* Make sure allocated buffer is large enough to fit the response packet plus the \r
387      * rmPktLen and Rm_PktType fields */\r
388     if (rmPkt->pktLenBytes < (sizeof(Rm_NsResponsePkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
389     {   \r
390         transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
391         return (NULL);\r
392     }\r
393 \r
394     /* Set the Rm Packet type */    \r
395     rmPkt->pktType = Rm_pktType_NAMESERVER_RESPONSE;\r
396                           \r
397     /* Assign the packet's data field to be the start of the NameServer response packet */\r
398     nsRespPkt = (Rm_NsResponsePkt *)rmPkt->data;\r
399     /* Populate the NameServer response packet using the transaction information. The\r
400      * responseId is the remoteOriginatingId.  The responseId must match the local ID \r
401      * of the transaction that originated the request */\r
402     nsRespPkt->responseId = transaction->remoteOriginatingId;\r
403     nsRespPkt->requestState = transaction->state;\r
404 \r
405     return (rmPkt);\r
406 }\r
407 \r
408 /**********************************************************************\r
409  ********************* Application visible APIs ***********************\r
410  **********************************************************************/\r
411 \r
412 Rm_TransportHandle Rm_transportRegister (Rm_Handle rmHandle, Rm_TransportCfg *transportCfg)\r
413 {\r
414     Rm_Inst *rmInst = (Rm_Inst *) rmHandle;\r
415     Rm_TransportNode *transportNode = NULL;\r
416     void *key;\r
417 \r
418     /* Lock access to the RM instance */\r
419     key = Rm_osalMtCsEnter();\r
420 \r
421     /* RM Servers cannot connect to other Servers.  RM Client Delegates cannot\r
422      * connect to other Client Delegates. */\r
423     if (((rmInst->instType == Rm_instType_SERVER) &&\r
424          (transportCfg->remoteInstType == Rm_instType_SERVER)) ||\r
425         ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
426          (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)))\r
427     {\r
428         goto exitCs; /* Error - return null */\r
429     }\r
430 \r
431     /* Verify Clients are not registering with more than one Client Delegate or Server. And\r
432      * that Client Delegate are not registering with more than one Server. */\r
433     if (rmInst->registeredWithDelegateOrServer &&\r
434         (((rmInst->instType == Rm_instType_CLIENT) &&\r
435           (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)) || \r
436          ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
437           (transportCfg->remoteInstType == Rm_instType_SERVER))))\r
438     {\r
439         goto exitCs; /* Error - return null */\r
440     }         \r
441 \r
442     /* Copy the transport callout function pointers into the RM instance as long as they're\r
443      * valid or not NULL */\r
444     if (transportCfg->transportCalloutsValid)\r
445     {\r
446         /* The transport APIs must not be NULL */\r
447         if ((transportCfg->transportCallouts.rmAllocPkt == NULL) ||\r
448             (transportCfg->transportCallouts.rmFreePkt == NULL) ||\r
449             (transportCfg->transportCallouts.rmSend == NULL) ||\r
450             (transportCfg->transportCallouts.rmReceive == NULL) ||\r
451             (transportCfg->transportCallouts.rmNumPktsReceived == NULL))\r
452         {\r
453             goto exitCs; /* Error - return null */\r
454         }\r
455             \r
456         /* Populate the instance transport callouts */\r
457         rmInst->transport.rmAllocPkt = transportCfg->transportCallouts.rmAllocPkt;\r
458         rmInst->transport.rmFreePkt = transportCfg->transportCallouts.rmFreePkt;\r
459         rmInst->transport.rmSend = transportCfg->transportCallouts.rmSend;\r
460         rmInst->transport.rmReceive = transportCfg->transportCallouts.rmReceive;\r
461         rmInst->transport.rmNumPktsReceived = transportCfg->transportCallouts.rmNumPktsReceived;\r
462     }\r
463 \r
464     /* Error checks passed - Create a new transport handle for the specified RM instance and\r
465      * create a new node in the RM instance's routing map. */\r
466     transportNode = Rm_transportNodeAdd(rmInst, transportCfg);\r
467 \r
468     /* Specify RM instance has registered with a higher level agent */\r
469     if ((transportNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
470         (transportNode->remoteInstType == Rm_instType_SERVER))\r
471     {\r
472         rmInst->registeredWithDelegateOrServer = true;\r
473     }\r
474 \r
475 exitCs:\r
476     \r
477     Rm_osalMtCsExit(key);\r
478     return ((Rm_TransportHandle) transportNode);\r
479 }\r
480 \r
481 Rm_TransportResult Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandle transportHandle)\r
482 {\r
483     Rm_Inst *rmInst = (Rm_Inst *) rmHandle;\r
484     Rm_TransportNode *transportNode = NULL;\r
485     Rm_TransportResult retVal = RM_TRANSPORT_SUCCESSFUL;\r
486     void *key;\r
487 \r
488     /* Lock access to the RM instance */\r
489     key = Rm_osalMtCsEnter();    \r
490 \r
491     /* Check if the transportHandle exists in the RM instance's route map */\r
492     transportNode = Rm_transportNodeFindTransportHandle(rmInst, transportHandle);\r
493 \r
494     if (transportNode == NULL)\r
495     {\r
496         /* Error - transport node does not exist in RM instance route map */\r
497         retVal = RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED;\r
498     }\r
499     else\r
500     {\r
501 \r
502         /* Remove specification that RM instance has been connected to an upper level agent\r
503          * if the node to be deleted has a remote instance type of Client Delegate or Server */\r
504         if ((transportNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
505             (transportNode->remoteInstType == Rm_instType_SERVER))\r
506         {\r
507             rmInst->registeredWithDelegateOrServer = false;\r
508         }\r
509 \r
510         /* Delete the transport node */\r
511         retVal = Rm_transportNodeDelete(rmInst, transportHandle);\r
512     }\r
513 \r
514     Rm_osalMtCsExit(key);\r
515     return (retVal);\r
516 }\r
517 \r
518 /* Used by the application to pass RM packets received from a transport to RM.\r
519  * CODE THE FUNCTION SUCH THAT IT CAN BE CALLED DIRECTLY BY APP OR BE PLUGGED\r
520  * AS PART OF AN ISR HANDLER FOR THE TRANSACTION RECEIVE */\r
521 int32_t Rm_receivePktIsr(Rm_TransportHandle transportHandle, Rm_Packet *pkt)\r
522 {\r\r\r
523     Rm_Inst *rmInst = (Rm_Inst *)((Rm_TransportNode *)transportHandle)->rmHandle;\r
524     Rm_Transaction *transaction;\r
525 \r
526     /* Make sure the transport handle is registered with the provided RM instance */\r
527     if (Rm_transportNodeFindTransportHandle(rmInst, transportHandle) == NULL)\r
528     {\r
529         /* Transport is not registered with the RM instance.  Return an error.\r
530          * The packet cannot be freed since the transport handle is not valid. */\r
531         return (RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED);\r
532     }\r
533 \r
534     /* Based on packet type transfer the data to a transaction or a policy structure */\r
535     switch (pkt->pktType)\r
536     {\r
537         case Rm_pktType_RESOURCE_REQUEST:\r
538         {\r
539             Rm_ResourceRequestPkt *resourceReqPkt = (Rm_ResourceRequestPkt *)pkt->data;\r
540 \r
541             /* Create the request transaction filling in the remoteOriginatingId using\r
542              * the request packet's ID.  The request packet's ID will map to the \r
543              * the request transaction that issued the request packet. */\r
544             transaction = Rm_transactionQueueAdd(rmInst);\r
545             transaction->remoteOriginatingId = resourceReqPkt->requestId;\r
546 \r
547             /* Transfer the rest of the data into the transaction */\r
548             if (resourceReqPkt->resourceReqType == Rm_resReqPktType_ALLOCATE_INIT)\r
549             {\r
550                 transaction->type = Rm_service_RESOURCE_ALLOCATE_INIT;\r
551             }\r
552             else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_ALLOCATE_USE)\r
553             {\r
554                 transaction->type = Rm_service_RESOURCE_ALLOCATE_USE;\r
555             }            \r
556             else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_FREE)\r
557             {\r
558                 transaction->type = Rm_service_RESOURCE_FREE;\r
559             }\r
560             else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_GET_NAMED)\r
561             {\r
562                 transaction->type = Rm_service_RESOURCE_GET_BY_NAME;\r
563             }            \r
564 \r
565             strcpy(transaction->pktSrcInstName, resourceReqPkt->pktSrcInstName);\r
566             strcpy(transaction->serviceSrcInstName, resourceReqPkt->serviceSrcInstName);\r
567             transaction->state = RM_SERVICE_PROCESSING;\r
568             memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceReqPkt->resourceInfo),\r
569                     sizeof(Rm_ResourceInfo));\r
570 \r
571             /* Process the transaction */\r
572             Rm_transactionProcessor(rmInst, transaction);\r
573             break;\r
574         }\r
575         case Rm_pktType_RESOURCE_RESPONSE:\r
576         {\r
577             Rm_ResourceResponsePkt *resourceRespPkt = (Rm_ResourceResponsePkt *)pkt->data;\r
578 \r
579             /* Find the transaction that is awaiting the response */\r
580             if (transaction = Rm_transactionQueueFind(rmInst,resourceRespPkt->responseId))\r
581             {\r
582                 /* Transfer the result of the request to the transaction */\r
583                 transaction->state = resourceRespPkt->requestState;\r
584 \r
585                 if ((transaction->state == RM_SERVICE_APPROVED_AND_COMPLETED) &&\r
586                     ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||\r
587                      (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||\r
588                      (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)))\r
589                 {\r
590                     /* Copy resources from request for allocations since an allocation\r
591                      * can be specified as unknown.  If the request resources were unspecified\r
592                      * the RM instance will specify the resources obtained */\r
593                     memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceRespPkt->resourceInfo),\r
594                             sizeof(Rm_ResourceInfo));\r
595                 }\r
596                 \r
597                 /* Process the transaction */\r
598                 Rm_transactionProcessor(rmInst, transaction);\r
599             }\r
600             else\r
601             {\r
602                 rmInst->transport.rmFreePkt(transportHandle, pkt);\r
603                 return (RM_TRANSPORT_ERROR_MATCHING_RESOURCE_REQUEST_NOT_FOUND);\r
604             }\r
605             break;\r
606         }\r
607         case Rm_pktType_NAMESERVER_REQUEST:\r
608         {\r
609             Rm_NsRequestPkt *nsRequestPkt = (Rm_NsRequestPkt *)pkt->data;\r
610 \r
611             transaction = Rm_transactionQueueAdd(rmInst);\r
612             transaction->remoteOriginatingId = nsRequestPkt->requestId;\r
613 \r
614             if (nsRequestPkt->nsRequestType == Rm_nsReqPktType_MAP_RESOURCE)\r
615             {\r
616                 transaction->type = Rm_service_RESOURCE_MAP_TO_NAME;\r
617             }\r
618             else if (nsRequestPkt->nsRequestType == Rm_nsReqPktType_UNMAP_RESOURCE)\r
619             {\r
620                 transaction->type = Rm_service_RESOURCE_UNMAP_NAME;\r
621             }\r
622 \r
623             strcpy(transaction->pktSrcInstName, nsRequestPkt->pktSrcInstName);\r
624             strcpy(transaction->serviceSrcInstName, nsRequestPkt->serviceSrcInstName);\r
625             transaction->state = RM_SERVICE_PROCESSING;\r
626             memcpy ((void *)&(transaction->resourceInfo), (void *)&(nsRequestPkt->resourceInfo),\r
627                     sizeof(Rm_ResourceInfo));\r
628 \r
629             /* Process the transaction */\r
630             Rm_transactionProcessor(rmInst, transaction);            \r
631             break;\r
632         }\r
633         case Rm_pktType_NAMESERVER_RESPONSE:\r
634         {\r
635             Rm_NsResponsePkt *nsResponsePkt = (Rm_NsResponsePkt *)pkt->data;\r
636 \r
637             /* Find the transaction that is awaiting the response */\r
638             if (transaction = Rm_transactionQueueFind(rmInst, nsResponsePkt->responseId))\r
639             {\r
640                 /* Transfer the state of the request to the transaction */\r
641                 transaction->state = nsResponsePkt->requestState;            \r
642 \r
643                 /* Process the transaction */\r
644                 Rm_transactionProcessor(rmInst, transaction);\r
645             }\r
646             else\r
647             {\r
648                 rmInst->transport.rmFreePkt(transportHandle, pkt);\r
649                 return (RM_TRANSPORT_ERROR_MATCHING_NAME_SERVER_REQUEST_NOT_FOUND);\r
650             }\r
651             break;\r
652         }\r
653         case Rm_pktType_POLICY_REQUEST:\r
654         {\r
655             Rm_PolicyRequestPkt *policyRequestPkt = (Rm_PolicyRequestPkt *)pkt->data;\r
656 \r
657             /* FILL IN POLICY API INFORMATION */\r
658             break;  \r
659         }\r
660         case Rm_pktType_POLICY_CHANGE:\r
661         {\r
662             Rm_PolicyChangePkt *policyChangePkt = (Rm_PolicyChangePkt *)pkt->data;\r
663 \r
664             /* FILL IN POLICY API INFORMATION */\r
665             break;\r
666         }\r
667         case Rm_pktType_RESOURCE_POOL_MODIFICATION_REQUEST:\r
668         {\r
669             Rm_ResourcePoolModRequestPkt *resPoolModReqPkt = (Rm_ResourcePoolModRequestPkt *)pkt->data;\r
670 \r
671             /* FILL IN RESOURCE POOL MODIFICATION API */\r
672             /* Rm_resourcePoolModRequestHandler(...); Server only - needs to allocate resources to\r
673              * the Client Delegate based on the policy and return those resources to the Client Delegate */\r
674             break;\r
675         }\r
676         case Rm_pktType_RESOURCE_POOL_MODIFICATION_RESPONSE:\r
677         {\r
678             Rm_ResourcePoolModResponsePkt *resPoolModRespPkt = (Rm_ResourcePoolModResponsePkt *)pkt->data;\r
679 \r
680             /* FILL IN RESOURCE POOL MODIFICAITON API */\r
681             /* Rm_resourcePoolModResponseHandler(...);  Handler needs to populate allocator with\r
682              * new resources provided in the response and then handle any request transactions waiting on\r
683              * the resource pool modification */\r
684             break;\r
685         }\r
686         default:\r
687             /* Invalid packet type.  Free the packet and return */\r
688             rmInst->transport.rmFreePkt(transportHandle, pkt);\r
689             return (RM_TRANSPORT_ERROR_INVALID_PACKET_TYPE);\r
690       }\r
691 \r
692     /* Free the packet after it has been processed */\r
693     rmInst->transport.rmFreePkt(transportHandle, pkt);\r
694     return (RM_TRANSPORT_SUCCESSFUL);\r
695 }\r
696 \r
697 /* Application can call this API so that RM handles reception of packets based on\r
698  * the RM handle and transport handle provided */\r
699 int32_t Rm_receivePktPolling(Rm_TransportHandle transportHandle)\r
700 {\r
701     Rm_Inst *rmInst = (Rm_Inst *)((Rm_TransportNode *)transportHandle)->rmHandle;\r
702     Rm_Packet *pkt = NULL;\r
703     int32_t retVal = RM_TRANSPORT_OK_BASE;\r
704 \r
705     /* Make sure the transport handle is registered with the provided RM instance */\r
706     if (Rm_transportNodeFindTransportHandle(rmInst, transportHandle) != NULL)\r
707     {\r
708         /* Check to see if any RM packets are available.  Process any available packets. */\r
709         while (rmInst->transport.rmNumPktsReceived(transportHandle) > 0)\r
710         {\r
711             pkt = rmInst->transport.rmReceive(transportHandle);\r
712 \r
713             if (pkt == NULL)\r
714             {\r
715                 retVal = RM_TRANSPORT_ERROR_PACKET_RECEPTION_ERROR;\r
716                 break;\r
717             }\r
718 \r
719             /* Pass the packet to RM.  The packet will be freed within the PktIsr API */\r
720             if (retVal = Rm_receivePktIsr(transportHandle, pkt) <= RM_SERVICE_ERROR_BASE)\r
721             {\r
722                 /* Return if an error is encountered */\r
723                 break;\r
724             }\r
725         }\r
726     }\r
727     else\r
728     {\r
729         /* Transport is not registered with the RM instance.  Return an error.\r
730          * The packet cannot be freed since the transport handle is not valid. */\r
731         retVal = RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED;\r
732     }\r
733 \r
734     return (retVal); \r
735 }\r
736 \r
737 /**\r
738 @}\r
739 */\r