1 /*------------------------------------------------------------------------------------------------*/
\r
2 /* Unicens XML Parser */
\r
3 /* Copyright 2017, Microchip Technology Inc. and its subsidiaries. */
\r
5 /* Redistribution and use in source and binary forms, with or without */
\r
6 /* modification, are permitted provided that the following conditions are met: */
\r
8 /* 1. Redistributions of source code must retain the above copyright notice, this */
\r
9 /* list of conditions and the following disclaimer. */
\r
11 /* 2. Redistributions in binary form must reproduce the above copyright notice, */
\r
12 /* this list of conditions and the following disclaimer in the documentation */
\r
13 /* and/or other materials provided with the distribution. */
\r
15 /* 3. Neither the name of the copyright holder nor the names of its */
\r
16 /* contributors may be used to endorse or promote products derived from */
\r
17 /* this software without specific prior written permission. */
\r
19 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" */
\r
20 /* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE */
\r
21 /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */
\r
22 /* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE */
\r
23 /* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL */
\r
24 /* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR */
\r
25 /* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER */
\r
26 /* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, */
\r
27 /* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */
\r
28 /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
\r
29 /*------------------------------------------------------------------------------------------------*/
\r
34 #include "UcsXml_Private.h"
\r
36 static const char* USB_PHY_STANDARD = "Standard";
\r
37 static const char* USB_PHY_HSIC = "HSIC";
\r
39 static const char* CLOCK_8FS = "8Fs";
\r
40 static const char* CLOCK_16FS = "16Fs";
\r
41 static const char* CLOCK_32FS = "32Fs";
\r
42 static const char* CLOCK_64FS = "64Fs";
\r
43 static const char* CLOCK_128FS = "128Fs";
\r
44 static const char* CLOCK_256FS = "256Fs";
\r
45 static const char* CLOCK_512FS = "512Fs";
\r
46 static const char* CLOCK_1024FS = "1024Fs";
\r
47 static const char* CLOCK_2048FS = "2048Fs";
\r
48 static const char* CLOCK_3072FS = "3072Fs";
\r
49 static const char* CLOCK_4096FS = "4096Fs";
\r
50 static const char* CLOCK_6144FS = "6144Fs";
\r
51 static const char* CLOCK_8192FS = "8192Fs";
\r
52 static const char* CLOCK_WILDCARD = "Wildcard";
\r
54 static const char* STRM_ALIGN_L16 = "Left16Bit";
\r
55 static const char* STRM_ALIGN_L24 = "Left24Bit";
\r
56 static const char* STRM_ALIGN_R16 = "Right16Bit";
\r
57 static const char* STRM_ALIGN_R24 = "Right24Bit";
\r
58 static const char* STRM_ALIGN_SEQUENTIAL = "Seq";
\r
60 static const char* I2S_PIN_SRXA0 = "SRXA0";
\r
61 static const char* I2S_PIN_SRXA1 = "SRXA1";
\r
62 static const char* I2S_PIN_SRXB0 = "SRXB0";
\r
63 static const char* I2S_PIN_SRXB1 = "SRXB1";
\r
65 static const char* MUTE_OFF = "NoMuting";
\r
66 static const char* MUTE_SIGNAL = "MuteSignal";
\r
68 static const char* VAL_TRUE = "true";
\r
69 static const char* VAL_FALSE = "false";
\r
72 #define ASSERT_FALSE() { assert(false); return false; }
\r
73 #define CHECK_POINTER(PTR) if (NULL == PTR) { ASSERT_FALSE(); }
\r
75 static int32_t Str2Int(const char *val)
\r
77 return strtol( val, NULL, 0 );
\r
80 void *MCalloc(struct UcsXmlObjectList *list, uint32_t nElem, uint32_t elemSize)
\r
83 struct UcsXmlObjectList *tail = list;
\r
84 if (NULL == list || 0 == nElem || 0 == elemSize) return NULL;
\r
86 obj = calloc(nElem, elemSize);
\r
92 if (NULL == list->obj)
\r
97 while(tail->next) tail = tail->next;
\r
98 tail->next = calloc(1, sizeof(struct UcsXmlObjectList));
\r
99 if (NULL == tail->next)
\r
105 tail->next->obj = obj;
\r
109 void FreeObjList(struct UcsXmlObjectList *cur)
\r
111 struct UcsXmlObjectList *root = cur;
\r
114 struct UcsXmlObjectList *next = cur->next;
\r
115 assert(NULL != cur->obj);
\r
124 bool GetMostSocket(Ucs_Xrm_MostSocket_t **mostSoc, struct MostSocketParameters *param)
\r
126 Ucs_Xrm_MostSocket_t *soc = NULL;
\r
127 CHECK_POINTER(mostSoc);
\r
128 CHECK_POINTER(param);
\r
129 CHECK_POINTER(param->list);
\r
130 soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MostSocket_t));
\r
131 CHECK_POINTER(soc);
\r
133 soc->resource_type = UCS_XRM_RC_TYPE_MOST_SOCKET;
\r
134 soc->most_port_handle = 0x0D00;
\r
135 soc->bandwidth = param->bandwidth;
\r
136 soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;
\r
137 switch(param->dataType)
\r
140 soc->data_type = UCS_MOST_SCKT_SYNC_DATA;
\r
142 case AV_PACKETIZED:
\r
143 soc->data_type = UCS_MOST_SCKT_AV_PACKETIZED;
\r
146 soc->data_type = UCS_MOST_SCKT_QOS_IP;
\r
148 case DISC_FRAME_PHASE:
\r
149 soc->data_type = UCS_MOST_SCKT_DISC_FRAME_PHASE;
\r
157 bool GetUsbPort(Ucs_Xrm_UsbPort_t **usbPort, struct UsbPortParameters *param)
\r
159 Ucs_Xrm_UsbPort_t *port = NULL;
\r
160 CHECK_POINTER(usbPort);
\r
161 CHECK_POINTER(param);
\r
162 CHECK_POINTER(param->list);
\r
163 CHECK_POINTER(param->deviceInterfaces);
\r
164 CHECK_POINTER(param->streamInCount);
\r
165 CHECK_POINTER(param->streamOutCount);
\r
166 CHECK_POINTER(param->physicalLayer);
\r
167 port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbPort_t));
\r
168 CHECK_POINTER(port);
\r
170 port->resource_type = UCS_XRM_RC_TYPE_USB_PORT;
\r
172 port->devices_interfaces = (uint16_t)Str2Int(param->deviceInterfaces);
\r
173 port->streaming_if_ep_in_count = (uint8_t)Str2Int(param->streamInCount);
\r
174 port->streaming_if_ep_out_count = (uint8_t)Str2Int(param->streamOutCount);
\r
175 if (0 == strcmp(USB_PHY_STANDARD, param->physicalLayer))
\r
176 port->physical_layer = UCS_USB_PHY_LAYER_STANDARD;
\r
177 else if (0 == strcmp(USB_PHY_HSIC, param->physicalLayer))
\r
178 port->physical_layer = UCS_USB_PHY_LAYER_HSCI;
\r
179 else ASSERT_FALSE();
\r
183 bool GetUsbPortDefaultCreated(Ucs_Xrm_ResObject_t **usbPort, struct UcsXmlObjectList *list)
\r
185 Ucs_Xrm_DefaultCreatedPort_t *p;
\r
186 CHECK_POINTER(usbPort);
\r
187 CHECK_POINTER(list);
\r
188 p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t));
\r
190 p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;
\r
191 p->port_type = UCS_XRM_PORT_TYPE_USB;
\r
193 *usbPort = (Ucs_Xrm_ResObject_t *)p;
\r
197 bool GetUsbSocket(Ucs_Xrm_UsbSocket_t **usbSoc, struct UsbSocketParameters *param)
\r
199 Ucs_Xrm_UsbSocket_t *soc = NULL;
\r
200 CHECK_POINTER(usbSoc);
\r
201 CHECK_POINTER(param);
\r
202 CHECK_POINTER(param->list);
\r
203 CHECK_POINTER(param->endpointAddress);
\r
204 CHECK_POINTER(param->framesPerTrans);
\r
205 CHECK_POINTER(param->usbPort);
\r
206 soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbSocket_t));
\r
207 CHECK_POINTER(soc);
\r
209 soc->resource_type = UCS_XRM_RC_TYPE_USB_SOCKET;
\r
210 soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;
\r
211 switch(param->dataType)
\r
214 soc->data_type = UCS_USB_SCKT_SYNC_DATA;
\r
216 case AV_PACKETIZED:
\r
217 soc->data_type = UCS_USB_SCKT_AV_PACKETIZED;
\r
220 soc->data_type = UCS_USB_SCKT_IPC_PACKET;
\r
225 soc->end_point_addr = (uint8_t)Str2Int(param->endpointAddress);
\r
226 soc->frames_per_transfer = (uint16_t)Str2Int(param->framesPerTrans);
\r
227 soc->usb_port_obj_ptr = param->usbPort;
\r
231 bool GetMlbPort(Ucs_Xrm_MlbPort_t **mlbPort, struct MlbPortParameters *param)
\r
233 Ucs_Xrm_MlbPort_t *port = NULL;
\r
234 CHECK_POINTER(mlbPort);
\r
235 CHECK_POINTER(param);
\r
236 CHECK_POINTER(param->list);
\r
237 CHECK_POINTER(param->clockConfig);
\r
238 port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbPort_t));
\r
239 CHECK_POINTER(port);
\r
241 port->resource_type = UCS_XRM_RC_TYPE_MLB_PORT;
\r
243 if (0 == strcmp(param->clockConfig, CLOCK_256FS))
\r
244 port->clock_config = UCS_MLB_CLK_CFG_256_FS;
\r
245 else if (0 == strcmp(param->clockConfig, CLOCK_512FS))
\r
246 port->clock_config = UCS_MLB_CLK_CFG_512_FS;
\r
247 else if (0 == strcmp(param->clockConfig, CLOCK_1024FS))
\r
248 port->clock_config = UCS_MLB_CLK_CFG_1024_FS;
\r
249 else if (0 == strcmp(param->clockConfig, CLOCK_2048FS))
\r
250 port->clock_config = UCS_MLB_CLK_CFG_2048_FS;
\r
251 else if (0 == strcmp(param->clockConfig, CLOCK_3072FS))
\r
252 port->clock_config = UCS_MLB_CLK_CFG_3072_FS;
\r
253 else if (0 == strcmp(param->clockConfig, CLOCK_4096FS))
\r
254 port->clock_config = UCS_MLB_CLK_CFG_4096_FS;
\r
255 else if (0 == strcmp(param->clockConfig, CLOCK_6144FS))
\r
256 port->clock_config = UCS_MLB_CLK_CFG_6144_FS;
\r
257 else if (0 == strcmp(param->clockConfig, CLOCK_8192FS))
\r
258 port->clock_config = UCS_MLB_CLK_CFG_8192_FS;
\r
259 else ASSERT_FALSE();
\r
263 bool GetMlbPortDefaultCreated(Ucs_Xrm_ResObject_t **mlbPort, struct UcsXmlObjectList *list)
\r
265 Ucs_Xrm_DefaultCreatedPort_t *p;
\r
266 CHECK_POINTER(mlbPort);
\r
267 CHECK_POINTER(list)
\r
268 p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t));
\r
270 p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;
\r
271 p->port_type = UCS_XRM_PORT_TYPE_MLB;
\r
273 *mlbPort = (Ucs_Xrm_ResObject_t *)p;
\r
277 bool GetMlbSocket(Ucs_Xrm_MlbSocket_t **mlbSoc, struct MlbSocketParameters *param)
\r
279 Ucs_Xrm_MlbSocket_t *soc = NULL;
\r
280 CHECK_POINTER(mlbSoc);
\r
281 CHECK_POINTER(param);
\r
282 CHECK_POINTER(param->list);
\r
283 CHECK_POINTER(param->channelAddress);
\r
284 CHECK_POINTER(param->mlbPort);
\r
285 soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbSocket_t));
\r
286 CHECK_POINTER(soc);
\r
288 soc->resource_type = UCS_XRM_RC_TYPE_MLB_SOCKET;
\r
289 soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;
\r
290 soc->bandwidth = param->bandwidth;
\r
291 switch(param->dataType)
\r
294 soc->data_type = UCS_MLB_SCKT_SYNC_DATA;
\r
296 case AV_PACKETIZED:
\r
297 soc->data_type = UCS_MLB_SCKT_AV_PACKETIZED;
\r
300 soc->data_type = UCS_MLB_SCKT_QOS_IP;
\r
302 case DISC_FRAME_PHASE:
\r
303 soc->data_type = UCS_MLB_SCKT_DISC_FRAME_PHASE;
\r
306 soc->data_type = UCS_MLB_SCKT_IPC_PACKET;
\r
311 soc->channel_address = (uint16_t)Str2Int(param->channelAddress);
\r
312 soc->mlb_port_obj_ptr = param->mlbPort;
\r
316 bool GetStrmPort(Ucs_Xrm_StrmPort_t **strmPort, struct StrmPortParameters *param)
\r
318 Ucs_Xrm_StrmPort_t *port = NULL;
\r
319 CHECK_POINTER(strmPort);
\r
320 CHECK_POINTER(param);
\r
321 CHECK_POINTER(param->list);
\r
322 CHECK_POINTER(param->clockConfig);
\r
323 port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmPort_t));
\r
324 CHECK_POINTER(port);
\r
326 port->resource_type = UCS_XRM_RC_TYPE_STRM_PORT;
\r
327 port->index = param->index;
\r
328 if (0 == port->index)
\r
330 if (0 == strcmp(param->clockConfig, CLOCK_8FS))
\r
331 port->clock_config = UCS_STREAM_PORT_CLK_CFG_8FS;
\r
332 else if (0 == strcmp(param->clockConfig, CLOCK_16FS))
\r
333 port->clock_config = UCS_STREAM_PORT_CLK_CFG_16FS;
\r
334 else if (0 == strcmp(param->clockConfig, CLOCK_32FS))
\r
335 port->clock_config = UCS_STREAM_PORT_CLK_CFG_32FS;
\r
336 else if (0 == strcmp(param->clockConfig, CLOCK_64FS))
\r
337 port->clock_config = UCS_STREAM_PORT_CLK_CFG_64FS;
\r
338 else if (0 == strcmp(param->clockConfig, CLOCK_128FS))
\r
339 port->clock_config = UCS_STREAM_PORT_CLK_CFG_128FS;
\r
340 else if (0 == strcmp(param->clockConfig, CLOCK_256FS))
\r
341 port->clock_config = UCS_STREAM_PORT_CLK_CFG_256FS;
\r
342 else if (0 == strcmp(param->clockConfig, CLOCK_512FS))
\r
343 port->clock_config = UCS_STREAM_PORT_CLK_CFG_512FS;
\r
344 else if (0 == strcmp(param->clockConfig, CLOCK_WILDCARD))
\r
345 port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD;
\r
346 else ASSERT_FALSE();
\r
348 port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD;
\r
351 if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L16))
\r
352 port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT16BIT;
\r
353 else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L24))
\r
354 port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT24BIT;
\r
355 else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R16))
\r
356 port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT16BIT;
\r
357 else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R24))
\r
358 port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT24BIT;
\r
359 else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_SEQUENTIAL))
\r
360 port->data_alignment = UCS_STREAM_PORT_ALGN_SEQ;
\r
361 else ASSERT_FALSE();
\r
365 bool GetStrmSocket(Ucs_Xrm_StrmSocket_t **strmSoc, struct StrmSocketParameters *param)
\r
367 Ucs_Xrm_StrmSocket_t *soc = NULL;
\r
368 CHECK_POINTER(strmSoc);
\r
369 CHECK_POINTER(param);
\r
370 CHECK_POINTER(param->list);
\r
371 CHECK_POINTER(param->streamPin);
\r
372 CHECK_POINTER(param->streamPortA);
\r
373 CHECK_POINTER(param->streamPortB);
\r
374 soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmSocket_t));
\r
375 CHECK_POINTER(soc);
\r
377 soc->resource_type = UCS_XRM_RC_TYPE_STRM_SOCKET;
\r
378 soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;
\r
379 switch(param->dataType)
\r
382 soc->data_type = UCS_STREAM_PORT_SCKT_SYNC_DATA;
\r
387 soc->bandwidth = param->bandwidth;
\r
388 if (0 == strcmp(param->streamPin, I2S_PIN_SRXA0))
\r
390 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA0;
\r
391 soc->stream_port_obj_ptr = param->streamPortA;
\r
394 else if (0 == strcmp(param->streamPin, I2S_PIN_SRXA1))
\r
396 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA1;
\r
397 soc->stream_port_obj_ptr = param->streamPortA;
\r
400 else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB0))
\r
402 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB0;
\r
403 soc->stream_port_obj_ptr = param->streamPortB;
\r
406 else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB1))
\r
408 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB1;
\r
409 soc->stream_port_obj_ptr = param->streamPortB;
\r
412 else ASSERT_FALSE();
\r
416 bool GetSplitter(Ucs_Xrm_Splitter_t **splitter, struct SplitterParameters *param)
\r
418 Ucs_Xrm_Splitter_t *split = NULL;
\r
419 CHECK_POINTER(splitter);
\r
420 CHECK_POINTER(param);
\r
421 CHECK_POINTER(param->list);
\r
422 split = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Splitter_t));
\r
423 CHECK_POINTER(split);
\r
425 split->most_port_handle = 0x0D00;
\r
426 split->resource_type = UCS_XRM_RC_TYPE_SPLITTER;
\r
427 split->bytes_per_frame = param->bytesPerFrame;
\r
428 split->socket_in_obj_ptr = param->inSoc;
\r
432 bool GetCombiner(Ucs_Xrm_Combiner_t **combiner, struct CombinerParameters *param)
\r
434 Ucs_Xrm_Combiner_t *comb = NULL;
\r
435 CHECK_POINTER(combiner);
\r
436 CHECK_POINTER(param);
\r
437 CHECK_POINTER(param->list);
\r
438 comb = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Combiner_t));
\r
439 CHECK_POINTER(comb);
\r
441 comb->most_port_handle = 0x0D00;
\r
442 comb->resource_type = UCS_XRM_RC_TYPE_COMBINER;
\r
443 comb->bytes_per_frame = param->bytesPerFrame;
\r
444 comb->port_socket_obj_ptr = param->outSoc;
\r
448 bool GetSyncCon(Ucs_Xrm_SyncCon_t **syncCon, struct SyncConParameters *param)
\r
450 Ucs_Xrm_SyncCon_t *con = NULL;
\r
451 CHECK_POINTER(syncCon);
\r
452 CHECK_POINTER(param);
\r
453 CHECK_POINTER(param->list);
\r
454 CHECK_POINTER(param->muteMode);
\r
455 CHECK_POINTER(param->inSoc);
\r
456 CHECK_POINTER(param->outSoc);
\r
457 con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_SyncCon_t));
\r
458 CHECK_POINTER(con);
\r
460 con->resource_type = UCS_XRM_RC_TYPE_SYNC_CON;
\r
461 if (0 == strcmp(param->muteMode, MUTE_OFF))
\r
462 con->mute_mode = UCS_SYNC_MUTE_MODE_NO_MUTING;
\r
463 else if (0 == strcmp(param->muteMode, MUTE_SIGNAL))
\r
464 con->mute_mode = UCS_SYNC_MUTE_MODE_MUTE_SIGNAL;
\r
465 else ASSERT_FALSE();
\r
466 if (param->optional_offset)
\r
467 con->offset = (uint16_t)Str2Int(param->optional_offset);
\r
470 con->socket_in_obj_ptr = param->inSoc;
\r
471 con->socket_out_obj_ptr = param->outSoc;
\r
475 bool GetAvpCon(Ucs_Xrm_AvpCon_t **avpCon, struct AvpConParameters *param)
\r
477 Ucs_Xrm_AvpCon_t *con = NULL;
\r
478 CHECK_POINTER(avpCon);
\r
479 CHECK_POINTER(param);
\r
480 CHECK_POINTER(param->list);
\r
481 CHECK_POINTER(param->inSoc);
\r
482 CHECK_POINTER(param->outSoc);
\r
483 con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_AvpCon_t));
\r
484 CHECK_POINTER(con);
\r
486 con->resource_type = UCS_XRM_RC_TYPE_AVP_CON;
\r
487 con->socket_in_obj_ptr = param->inSoc;
\r
488 con->socket_out_obj_ptr = param->outSoc;
\r
489 if (param->optional_isocPacketSize)
\r
491 int32_t pSize = Str2Int(param->optional_isocPacketSize);
\r
495 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;
\r
498 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_196;
\r
501 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_206;
\r
507 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;
\r