file substitute.

datalink814_ge/src/util/circ_queue.c

@@ -0,0 +1,141 @@
+/*****************************************************************************/
+/**
+ * Description: A simple circular FIFO bounded queue
+ *
+ * Author: Fan Hao
+ * Date: 2023-02-23 10:29
+ * LastEditors: Fan Hao
+ * LastEditTime: 2023-02-23 13:18
+ * Revisions: Rev 0.0
+ * History:
+ * [2023-02-23]: Initial Version.
+ *
+ * Copyright(c) 2023 Beijing Institute of Technology.
+ * Lab of Communication and Networking
+ * NOTE: Forked from https://github.com/chrismerck/rpa_queue.git
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ ******************************************************************************/
+
+#include "circ_queue.h"
+#include "common.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+inline bool isCircQueueFull(CIRC_QUEUE *queue)
+{
+  ASSERT(queue != NULL);
+  return ((queue)->nelts == (queue)->bounds);
+}
+
+inline bool isCircQueueEmpty(CIRC_QUEUE *queue)
+{
+  ASSERT(queue != NULL);
+  return ((queue)->nelts == 0);
+}
+
+void CircQueueFree(CIRC_QUEUE *queue)
+{
+  ASSERT(queue != NULL);
+  if (queue->data)
+    free(queue->data);
+  free(queue);
+}
+
+/**
+ * Initialize the CIRC_QUEUE.
+ */
+bool CircQueueCreate(CIRC_QUEUE **q, uint32_t queueCapacity)
+{
+  ASSERT(q != NULL);
+  CIRC_QUEUE *queue;
+  queue = malloc(sizeof(CIRC_QUEUE));
+  if (!queue)
+  {
+    return false;
+  }
+  *q = queue;
+  memset(queue, 0, sizeof(CIRC_QUEUE));
+
+  /* Set all the data in the queue to NULL */
+  queue->data = malloc(queueCapacity * sizeof(void *));
+  if (queue->data == NULL)
+  {
+    goto error;
+  }
+  queue->bounds = queueCapacity;
+  queue->nelts = 0;
+  queue->in = 0;
+  queue->out = 0;
+  return true;
+error:
+  free(queue);
+  return false;
+}
+
+/**
+ * Push new data onto the queue.
+ */
+bool CircQueuePush(CIRC_QUEUE *queue, void *data)
+{
+  ASSERT(queue != NULL);
+
+  if (isCircQueueFull(queue))
+  {
+    return false;
+  }
+
+  queue->data[queue->in] = data;
+  queue->in++;
+  if (queue->in >= queue->bounds)
+  {
+    queue->in -= queue->bounds;
+  }
+  queue->nelts++;
+
+  return true;
+}
+
+/**
+ * Return current number of element in queue.
+ */
+inline uint32_t CircQueueSize(CIRC_QUEUE *queue)
+{
+  return queue->nelts;
+}
+
+/**
+ * Retrieves the next item from the queue.
+ */
+bool CircQueuePop(CIRC_QUEUE *queue, void **data)
+{
+  ASSERT(queue != NULL);
+
+  if (isCircQueueEmpty(queue))
+  {
+    return false;
+  }
+
+  *data = queue->data[queue->out];
+  queue->nelts--;
+
+  queue->out++;
+  if (queue->out >= queue->bounds)
+  {
+    queue->out -= queue->bounds;
+  }
+  return true;
+}

datalink814_ge/src/util/circ_queue.h

@@ -0,0 +1,111 @@
+/*****************************************************************************/
+/**
+ * Description: A simple circular FIFO bounded queue
+ * 
+ * Author: Fan Hao
+ * Date: 2023-02-23 10:29
+ * LastEditors: Fan Hao
+ * LastEditTime: 2023-02-23 12:53
+ * Revisions: Rev 0.0
+ * History: 
+ * [2023-02-23]: Initial Version.
+ * 
+ * Copyright(c) 2023 Beijing Institute of Technology.
+ * Lab of Communication and Networking
+ * NOTE: Forked from https://github.com/chrismerck/rpa_queue.git
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+******************************************************************************/
+
+#ifndef CIRC_QUEUE_H
+#define CIRC_QUEUE_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+
+/**
+ * opaque structure
+ */
+typedef struct {
+  void **data;
+  volatile uint32_t nelts; /**< # elements */
+  uint32_t in;  /**< next empty location */
+  uint32_t out;   /**< next filled location */
+  uint32_t bounds;/**< max size of queue */
+} CIRC_QUEUE;
+
+
+
+/**
+ * create a FIFO queue
+ * @param queue The new queue
+ * @param queue_capacity maximum size of the queue
+ * @param a pool to allocate queue from
+ */
+bool CircQueueCreate(CIRC_QUEUE **queue, uint32_t queue_capacity);
+
+/** free queue memory -- call after destroy 
+ * @note we do not free in destroy() to follow pthreads convention
+*/
+void CircQueueFree(CIRC_QUEUE * queue);
+
+/**
+ * Detects when the CIRC_QUEUE is full. This utility function is expected
+ * to be called from within critical sections, and is not threadsafe.
+ */
+bool isCircQueueFull(CIRC_QUEUE *queue);
+
+/**
+ * Detects when the CIRC_QUEUE is empty. This utility function is expected
+ * to be called from within critical sections, and is not threadsafe.
+ */
+bool isCircQueueEmpty(CIRC_QUEUE *queue);
+
+/**
+ * push/add an object to the queue, blocking if the queue is already full
+ *
+ * @param queue the queue
+ * @param data the data
+ * @returns RPA_EINTR the blocking was interrupted (try again)
+ * @returns RPA_EOF the queue has been terminated
+ * @returns RPA_SUCCESS on a successful push
+ */
+bool CircQueuePush(CIRC_QUEUE *queue, void *data);
+
+
+/**
+ * pop/get an object from the queue, blocking if the queue is already empty
+ *
+ * @param queue the queue
+ * @param data the data
+ * @returns RPA_EINTR the blocking was interrupted (try again)
+ * @returns RPA_EOF if the queue has been terminated
+ * @returns RPA_SUCCESS on a successful pop
+ */
+bool CircQueuePop(CIRC_QUEUE *queue, void **data);
+
+/**
+ * returns the size of the queue.
+ *
+ * @warning this is not threadsafe, and is intended for reporting/monitoring
+ * of the queue.
+ * @param queue the queue
+ * @returns the size of the queue
+ */
+uint32_t CircQueueSize(CIRC_QUEUE *queue);
+
+#endif /* CIRC_QUEUE_H */

df_datalink/src/include/list.h

@@ -1,327 +1,118 @@
-/***************************************************************************//**
- *   @file   list.h
- *   @brief  List library header
- *   @author Mihail Chindris ([email protected])
-********************************************************************************
- *   @copyright
- * Copyright 2020(c) Analog Devices, Inc.
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *  - Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  - Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *  - Neither the name of Analog Devices, Inc. nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *  - The use of this software may or may not infringe the patent rights
- *    of one or more patent holders.  This license does not release you
- *    from the requirement that you obtain separate licenses from these
- *    patent holders to use this software.
- *  - Use of the software either in source or binary form, must be run
- *    on or directly connected to an Analog Devices Inc. component.
- *
- * THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT,
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-********************************************************************************
- *
- *  @section list_details Library description
- *   This library handles double linked lists and it expose inseart,
- *   read, get and delete functions. \n
- *   It also can be accesed using it member functions which wrapp function for
- *   usual list types.\n
- *  @subsection example Sample code
- *   @code{.c}
- *	// -- Use a generic list
- *	struct list_desc *list1;
- *	struct iterator  *it;
- *	uint32_t	 a;
- *	// Create list list1
- *	list_init(&list1, LIST_DEFAULT, NULL);
- *	// Add items to the list
- *	list_add_last(list1, 1);
- *	list_add_last(list1, 2);
- *	list_add_last(list1, 3);
- *	// Here the list will be: 1 -> 2 - > 3
- *
- *	list_read_last(list1, &a);
- *	printf("Last: %d\n", a);
- *	// 3 will be printed
- *	// Create an iterator on the end of the list
- *	iterator_init(&it, list1, 0);
- *	// Move the iterator backword with one position
- *	iterator_move(it, -1);
- *	// Read the data at the current position
- *	iterator_read(it, &a);
- *	printf("Current: %d\n", a);
- *	// 2 will be printed
- *	iterator_remove(it);
- *	list_remove(list1);
- *
- *	// -- Use a popular list
- *	struct list_desc *stack;
- *	// Create a FIFO list
- *	list_init(&stack, LIST_STACK, NULL);
- *	// Put elements in the list
- *	stack->push(stack, 1);
- *	stack->push(stack, 2);
- *	stack->push(stack, 3);
- *	// Read from the stack
- *	stack->pop(stack, &a);
- *	printf("Last: %d\n", a);
- *	// 3 will be printed
- *	list_remove(stack);
- *    @endcode
-*******************************************************************************/
 
-#ifndef _LIST_H_
+//
-#define _LIST_H_
+// list.h
+//
+// Copyright (c) 2010 TJ Holowaychuk <[email protected]>
+//
 
-/******************************************************************************/
+#ifndef __LIST_H__
-/***************************** Include Files **********************************/
+#define __LIST_H__
-/******************************************************************************/
 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdlib.h>
 #include <stdint.h>
-#include <stdbool.h>
 
-/******************************************************************************/
+  /*
-/*************************** Types Declarations *******************************/
+   * list_t iterator direction.
-/******************************************************************************/
-
-/**
- * @struct list_desc
- * @brief Structure storing the list and function wrapper for usual list types
- *
- * With this structure the funtionalities of usual list types
- * ( \ref adapter_type ) can be accesed with the functions referenced in this
- * structure.
- * For example:
- * @code{.c}
- * my_queue->push(my_queue, my_data);
- * @endcode
- */
-struct list_desc;
-
-/**
- * @struct list_iterator
- * @brief Structure used to iterate through the list using Iterator functions.
- */
-struct iterator;
-
-/**
- * @brief Prototype of the compare function.
- *
- * The function used to compare the elements of the liste when doing
- * operations on an ordered list.
- * @param data1 - First element to be compared
- * @param data2 - Second element to be compared
- * @return
- *  - -1 - If data1 < data2
- *  - 0 - If data1 == data2
- *  - 1 - If data1 > data2
- */
-typedef int32_t (*f_cmp)(void *data1, void *data2);
-
-/**
- * @name Generic functions
- * Each function interacting with the list have one of the following formats.\n
- * Aditionaly they may have one more parametere for specific functionalities.\n
- * In the Iterator functions, the list reference is replaced by the iterator's
- * one.
- * @{
    */
 
-/**
+  typedef enum
- * @brief Add an element in the list.
+  {
- *
+    LIST_HEAD,
- * The element of the list is created and the data field is stored in it.
+    LIST_TAIL
- * @param list_desc - Reference to the list. Created by \ref list_init.
+  } list_direction_t;
- * @param data - Data to store in a list element
+
- * @return
+  /*
- *  - 0 : On success
+   * list_t node struct.
- *  - -1 : Otherwise
    */
-typedef int32_t (*f_add)(struct list_desc *list_desc, void *data);
 
-/**
+  typedef struct list_node
- * @brief Edit an element in the list. The content is replaced by new_data.
+  {
- * @param list_desc - Reference to the list. Created by \ref list_init.
+    struct list_node *prev;
- * @param new_data - New data to replace the old one
+    struct list_node *next;
- * @return
+    void *val;
- *  - 0 : On success
+  } list_node_t;
- *  - -1 : Otherwise
+
+  /*
+   * list_t struct.
    */
-typedef int32_t (*f_edit)(struct list_desc *list_desc, void *new_data);
 
-/**
+  typedef struct
- * @brief Read an element from the list.
+  {
- * @param list_desc - Reference to the list. Created by \ref list_init.
+    list_node_t *head;
- * @param result - If not null, result is filled with:
+    list_node_t *tail;
- * @param data - Content of the list element, NULL if some error occur.
+    uint32_t len;
- * @return \n
+    void (*free)(void *val);
- *  - 0 : On success
+    int8_t (*compare)(void *a, void *b);
- *  - -1 : Otherwise
+  } list_t;
- * @note If the content of an element can be 0 then the result must be checked
+
- * to see if the functions has succeded
+  /*
+   * list_t iterator struct.
    */
-typedef int32_t (*f_read)(struct list_desc *list_desc, void **data);
 
-/**
+  typedef struct
- * @brief Read and remove an element from the list.
+  {
- * @param list_desc - Reference to the list. Created by \ref list_init.
+    list_node_t *next;
- * @param result - If not null, result is filled with:
+    list_direction_t direction;
- * @param data - Content of the list element, NULL if some error occur.
+  } list_iterator_t;
- * @return
- *  - 0 : On success
- *  - -1 : Otherwise
- */
-typedef int32_t (*f_get)(struct list_desc *list_desc, void **data);
 
-/** @} */
+  // Node prototypes.
 
-/**
+  list_node_t *
- * @enum adapter_type
+  list_node_new(void *val);
- * @brief Selects functionalities for functions in \ref list_desc
- */
-enum adapter_type {
-	/** Default type is LIST_STACK */
-	LIST_DEFAULT,
-	/**
-	 * Functions for a FIFO list (First-in first-out). Elements are inserted
-	 * in one end and extracted from the other end.
-	 *  - \e Push: Insert element
-	 *  - \e Pop: Get next element (Read and remove)
-	 *  - \e Top_next: Read next element
-	 *  - \e Back: Read first element
-	 *  - \e Swap: Edit the content of the next element
-	 */
-	LIST_QUEUE,
-	/**
-	 * Functions for a LIFO list (Last-in first-out). Elements are inserted
-	 * and extracted only from the same end.
-	 *  - \e Push: Insert element
-	 *  - \e Pop: Get top element (Read and remove)
-	 *  - \e Top_next: Read top element
-	 *  - \e Back: Read bottom element
-	 *  - \e Swap: Edit the content of the top element
-	 */
-	LIST_STACK,
-	/**
-	 * Functions for ordered list. The order of element is determinated
-	 * usinge the \ref f_cmp.
-	 *  - \e Push: Insert element
-	 *  - \e Pop: Get lowest element (Read and remove)
-	 *  - \e Top_next: Read lowest element
-	 *  - \e Back: Read the biggest element
-	 *  - \e Swap: Edit the lowest element
-	 */
-	LIST_PRIORITY_LIST
-};
 
-struct list_desc {
+  // list_t prototypes.
-	/** Refer to \ref adapter_type */
-	f_add	push;
-	/** Refer to \ref adapter_type */
-	f_get	pop;
-	/** Refer to \ref adapter_type */
-	f_read	top_next;
-	/** Refer to \ref adapter_type */
-	f_read	back;
-	/** Refer to \ref adapter_type */
-	f_edit	swap;
-	/** Structure storing the list internal parameters */
-	void	*priv_desc;
-};
 
-/******************************************************************************/
+  list_t *
-/************************ Functions Declarations ******************************/
+  list_new(void);
-/******************************************************************************/
 
-int32_t list_init(struct list_desc **list_desc,
+  list_node_t *
-			enum adapter_type type,
+  list_rpush(list_t *self, list_node_t *node);
-			f_cmp comparator);
-int32_t list_remove(struct list_desc *list_desc);
-int32_t list_get_size(struct list_desc *list_desc,
-			    uint32_t *out_size);
 
-/**
+  list_node_t *
- * @name Iterator functions
+  list_lpush(list_t *self, list_node_t *node);
- * An iterator is used to iterate through the list. For a list, any number of
- * iterators can be created. All must be removed before removing a list.
- * @{
- */
-int32_t iterator_init(struct iterator **iter,
-			    struct list_desc *list_desc,
-			    bool start);
-int32_t iterator_remove(struct iterator *iter);
-int32_t iterator_move(struct iterator *iter, int32_t steps);
-int32_t iterator_move_to_idx(struct iterator *iter, int32_t idx);
-int32_t iterator_find(struct iterator *iter, void *cmp_data);
-int32_t iterator_insert(struct iterator *iter, void *data,
-			      bool after);
-int32_t iterator_edit(struct iterator *iter, void *new_data);
-int32_t iterator_read(struct iterator *iter, void **data);
-int32_t iterator_get(struct iterator *iter, void **data);
-/** @}*/
 
-/**
+  list_node_t *
- * @name Operations on the ends of the list
+  list_find(list_t *self, void *val);
- * These functions will operate on the first or last element of the list
- * @{
- */
-int32_t list_add_first(struct list_desc *list_desc, void *data);
-int32_t list_edit_first(struct list_desc *list_desc,
-			      void *new_data);
-int32_t list_read_first(struct list_desc *list_desc, void **data);
-int32_t list_get_first(struct list_desc *list_desc, void **data);
 
-int32_t list_add_last(struct list_desc *list_desc, void *data);
+  list_node_t *
-int32_t list_edit_last(struct list_desc *list_desc, void *new_data);
+  list_at(list_t *self, int index);
-int32_t list_read_last(struct list_desc *list_desc, void **data);
-int32_t list_get_last(struct list_desc *list_desc, void **data);
-/** @}*/
 
-/**
+  list_node_t *
- * @name Operations by index
+  list_rpop(list_t *self);
- * These functions use an index to identify the element in the list.
- * @{
- */
-int32_t list_add_idx(struct list_desc *list_desc, void *data,
-			   uint32_t idx);
-int32_t list_edit_idx(struct list_desc *list_desc, void *new_data,
-			    uint32_t idx);
-int32_t list_read_idx(struct list_desc *list_desc, void **data,
-			    uint32_t idx);
-int32_t list_get_idx(struct list_desc *list_desc, void **data,
-			   uint32_t idx);
-/** @}*/
 
-/**
+  list_node_t *
- * @name Operations by comparation
+  list_lpop(list_t *self);
- * These functions use the specified \ref f_cmp at \ref list_init to identify
- * the element this will operate on.
- * @{
- */
-int32_t list_add_find(struct list_desc *list_desc, void *data);
-int32_t list_edit_find(struct list_desc *list_desc, void *new_data,
-			     void *cmp_data);
-int32_t list_read_find(struct list_desc *list_desc, void **data,
-			     void *cmp_data);
-int32_t list_get_find(struct list_desc *list_desc, void **data,
-			    void *cmp_data);
-/** @}*/
 
-#endif // _LIST_H_
+  void
+  list_remove(list_t *self, list_node_t *node);
+
+  void
+  list_clear(list_t *self);
+
+  void
+  list_destroy(list_t *self);
+
+  // list_t iterator prototypes.
+
+  list_iterator_t *
+  list_iterator_new(list_t *list, list_direction_t direction);
+
+  list_iterator_t *
+  list_iterator_new_from_node(list_node_t *node, list_direction_t direction);
+
+  list_node_t *
+  list_iterator_next(list_iterator_t *self);
+
+  void
+  list_iterator_destroy(list_iterator_t *self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CLIBS_LIST_H__ */

df_datalink/src/include/util.h

@@ -2,7 +2,7 @@
  *   @file   util.h
  *   @brief  Implementation of utility functions.
  *   @author DBogdan ([email protected])
- ********************************************************************************
+********************************************************************************
  * Copyright 2018(c) Analog Devices, Inc.
  *
  * All rights reserved.
@@ -35,9 +35,9 @@
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *******************************************************************************/
+*******************************************************************************/
-#ifndef _UTIL_H_
+#ifndef __UTIL_H_
-#define _UTIL_H_
+#define __UTIL_H_
 
 /******************************************************************************/
 /***************************** Include Files **********************************/
@@ -55,8 +55,6 @@
 #define CRC8_INIT 0x00
 
 #define BIT(x) (1 << (x))
-#define ASSERT_BIT(x, ofst) (x | BIT(ofst))
-#define DEASSERT_BIT(x, ofst) (x & (~BIT(ofst)))
 
 #define ARRAY_SIZE(x) \
 	(sizeof(x) / sizeof((x)[0]))
@@ -194,4 +192,4 @@ int crc16_gen(uint8_t *buffPtr, uint32_t dataLen, uint16_t poly, uint16_t *crcVa
 bool crc16_check(uint8_t *buffPtr, uint32_t dataLen, uint32_t crcOffset, uint16_t poly);
 int crc8_gen(uint8_t *buffPtr, uint32_t dataLen, uint16_t poly, uint8_t *crcVal);
 bool crc8_check(uint8_t *buffPtr, uint32_t dataLen, uint32_t crcOffset, uint16_t poly);
-#endif // UTIL_H_
+#endif // __UTIL_H_

df_datalink/src/util/crc.c

@@ -22,7 +22,8 @@
 #ifdef __CRC_LSB
 // CRC-16-CCITT   G(X)=X16+X12+X5+1
 // Reversed
-static const uint16_t crc16_1021_lsb_lut[256] = {
+static const uint16_t crc16_1021_lsb_lut[256] = 
+{
     0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, 
     0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, 
     0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, 
@@ -54,10 +55,12 @@ static const uint16_t crc16_1021_lsb_lut[256] = {
     0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, 
     0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, 
     0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 
-    0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78};
+    0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
+};
 
 // CRC-16-MAXIM   G(X)=X16+X15+X2+1
-const uint16_t crc16_8005_lsb_lut[256] = {
+const uint16_t crc16_8005_lsb_lut[256] = 
+{
     0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
     0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
     0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
@@ -89,10 +92,12 @@ const uint16_t crc16_8005_lsb_lut[256] = {
     0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
     0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
     0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
-    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040};
+    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
+};
 
 // CRC-8-MAXIM   G(X)=X8+X5+X4+1
-const uint8_t crc8_31_lsb_lut[256] = {
+const uint8_t crc8_31_lsb_lut[256] = 
+{
     0x00, 0x5E, 0xBC, 0xE2, 0x61, 0x3F, 0xDD, 0x83,
     0xC2, 0x9C, 0x7E, 0x20, 0xA3, 0xFD, 0x1F, 0x41,
     0x9D, 0xC3, 0x21, 0x7F, 0xFC, 0xA2, 0x40, 0x1E,
@@ -124,10 +129,12 @@ const uint8_t crc8_31_lsb_lut[256] = {
     0xE9, 0xB7, 0x55, 0x0B, 0x88, 0xD6, 0x34, 0x6A,
     0x2B, 0x75, 0x97, 0xC9, 0x4A, 0x14, 0xF6, 0xA8,
     0x74, 0x2A, 0xC8, 0x96, 0x15, 0x4B, 0xA9, 0xF7,
-    0xB6, 0xE8, 0x0A, 0x54, 0xD7, 0x89, 0x6B, 0x35};
+    0xB6, 0xE8, 0x0A, 0x54, 0xD7, 0x89, 0x6B, 0x35
+};
 #else
 // CRC-16-CCITT   G(X)=X16+X12+X5+1
-static const uint16_t crc16_1021_msb_lut[256] = {
+static const uint16_t crc16_1021_msb_lut[256] = 
+{ 
     0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 
     0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 
     0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 
@@ -159,10 +166,12 @@ static const uint16_t crc16_1021_msb_lut[256] = {
     0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 
     0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 
     0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 
-    0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0};
+    0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
+};
 
 // CRC-16-MAXIM   G(X)=X16+X15+X2+1
-const uint16_t crc16_8005_msb_lut[256] = {
+const uint16_t crc16_8005_msb_lut[256] = 
+{
     0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011,
     0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022,
     0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072,
@@ -194,10 +203,12 @@ const uint16_t crc16_8005_msb_lut[256] = {
     0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252,
     0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261,
     0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231,
-    0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202};
+    0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202
+};
 
 // CRC-8-MAXIM   G(X)=X8+X5+X4+1
-const uint8_t crc8_31_msb_lut[256] = {
+const uint8_t crc8_31_msb_lut[256] = 
+{
     0x00, 0x31, 0x62, 0x53, 0xC4, 0xF5, 0xA6, 0x97,
     0xB9, 0x88, 0xDB, 0xEA, 0x7D, 0x4C, 0x1F, 0x2E,
     0x43, 0x72, 0x21, 0x10, 0x87, 0xB6, 0xE5, 0xD4,
@@ -229,7 +240,8 @@ const uint8_t crc8_31_msb_lut[256] = {
     0xC1, 0xF0, 0xA3, 0x92, 0x05, 0x34, 0x67, 0x56,
     0x78, 0x49, 0x1A, 0x2B, 0xBC, 0x8D, 0xDE, 0xEF,
     0x82, 0xB3, 0xE0, 0xD1, 0x46, 0x77, 0x24, 0x15,
-    0x3B, 0x0A, 0x59, 0x68, 0xFF, 0xCE, 0x9D, 0xAC};
+    0x3B, 0x0A, 0x59, 0x68, 0xFF, 0xCE, 0x9D, 0xAC
+};
 #endif
 
 /* CRC lookup table algorithm  

df_datalink/src/util/util.c

@@ -3,7 +3,7 @@
 /******************************************************************************/
 #include <string.h>
 #include <stdlib.h>
-#include <arm_acle.h>
+// #include <arm_acle.h>
 #include "util.h"
 #include "error.h"
 
@@ -11,7 +11,8 @@
 /************************** Functions Implementation **************************/
 /******************************************************************************/
 #ifdef __BITSWAP_TABLE
-static uint8_t byte_flipLR[256] = {
+static uint8_t byte_flipLR[256] = 
+{ 
 	0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
 	0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
 	0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
@@ -43,7 +44,8 @@ static uint8_t byte_flipLR[256] = {
 	0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
 	0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
 	0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
-	0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF};
+	0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF 
+};
 #endif
 
 inline void IO_Out32(uintptr_t addr, uint32_t value)