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.
-/******************************************************************************/
+   */
 
-/**
+  typedef enum
- * @struct list_desc
+  {
- * @brief Structure storing the list and function wrapper for usual list types
+    LIST_HEAD,
- *
+    LIST_TAIL
- * With this structure the funtionalities of usual list types
+  } list_direction_t;
- * ( \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
+   * list_t node struct.
- * @brief Structure used to iterate through the list using Iterator functions.
+   */
- */
-struct iterator;
 
-/**
+  typedef struct list_node
- * @brief Prototype of the compare function.
+  {
- *
+    struct list_node *prev;
- * The function used to compare the elements of the liste when doing
+    struct list_node *next;
- * operations on an ordered list.
+    void *val;
- * @param data1 - First element to be compared
+  } list_node_t;
- * @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
+   * list_t struct.
- * 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 struct
- * @brief Add an element in the list.
+  {
- *
+    list_node_t *head;
- * The element of the list is created and the data field is stored in it.
+    list_node_t *tail;
- * @param list_desc - Reference to the list. Created by \ref list_init.
+    uint32_t len;
- * @param data - Data to store in a list element
+    void (*free)(void *val);
- * @return
+    int8_t (*compare)(void *a, void *b);
- *  - 0 : On success
+  } list_t;
- *  - -1 : Otherwise
- */
-typedef int32_t (*f_add)(struct list_desc *list_desc, void *data);
 
-/**
+  /*
- * @brief Edit an element in the list. The content is replaced by new_data.
+   * list_t iterator struct.
- * @param list_desc - Reference to the list. Created by \ref list_init.
+   */
- * @param new_data - New data to replace the old one
- * @return
- *  - 0 : On success
- *  - -1 : Otherwise
- */
-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 *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 \n
- *  - 0 : On success
- *  - -1 : Otherwise
- * @note If the content of an element can be 0 then the result must be checked
- * to see if the functions has succeded
- */
-typedef int32_t (*f_read)(struct list_desc *list_desc, void **data);
 
-/**
+  // Node prototypes.
- * @brief Read and remove an element from the list.
- * @param list_desc - Reference to the list. Created by \ref list_init.
- * @param result - If not null, result is filled with:
- * @param data - Content of the list element, NULL if some error occur.
- * @return
- *  - 0 : On success
- *  - -1 : Otherwise
- */
-typedef int32_t (*f_get)(struct list_desc *list_desc, void **data);
 
-/** @} */
+  list_node_t *
+  list_node_new(void *val);
 
-/**
+  // list_t prototypes.
- * @enum adapter_type
- * @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 *
-	/** Refer to \ref adapter_type */
+  list_new(void);
-	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_node_t *
-/************************ Functions Declarations ******************************/
+  list_rpush(list_t *self, list_node_t *node);
-/******************************************************************************/
 
-int32_t list_init(struct list_desc **list_desc,
+  list_node_t *
-			enum adapter_type type,
+  list_lpush(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_find(list_t *self, void *val);
- * 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_at(list_t *self, int index);
- * 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_rpop(list_t *self);
-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_lpop(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);
-/** @}*/
 
-/**
+  void
- * @name Operations by comparation
+  list_remove(list_t *self, list_node_t *node);
- * 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_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,42 +22,45 @@
 #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,
+    0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, 
-    0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E,
+    0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, 
-    0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
+    0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, 
-    0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD,
+    0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876, 
-    0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
+    0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD, 
-    0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C,
+    0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5, 
-    0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
+    0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C, 
-    0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
+    0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974, 
-    0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
+    0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB, 
-    0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A,
+    0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3, 
-    0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
+    0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, 
-    0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9,
+    0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72, 
-    0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
+    0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, 
-    0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738,
+    0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1, 
-    0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
+    0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738, 
-    0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7,
+    0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70, 
-    0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
+    0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7, 
-    0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036,
+    0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF, 
-    0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
+    0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, 
-    0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5,
+    0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E, 
-    0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
+    0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, 
-    0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134,
+    0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD, 
-    0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
+    0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134, 
-    0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3,
+    0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C, 
-    0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
+    0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3, 
-    0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
+    0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB, 
-    0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
+    0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232, 
-    0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1,
+    0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A, 
-    0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
+    0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, 
-    0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330,
+    0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, 
-    0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78};
+    0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, 
+    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,45 +129,49 @@ 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,
+    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 
-    0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+    0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 
-    0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+    0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 
-    0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+    0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 
-    0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+    0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 
-    0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+    0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 
-    0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+    0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 
-    0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+    0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 
-    0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+    0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 
-    0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+    0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 
-    0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+    0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 
-    0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+    0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 
-    0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+    0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 
-    0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+    0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 
-    0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+    0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 
-    0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+    0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 
-    0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+    0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 
-    0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+    0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 
-    0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+    0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 
-    0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+    0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 
-    0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+    0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 
-    0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+    0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 
-    0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+    0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 
-    0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+    0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 
-    0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+    0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 
-    0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+    0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 
-    0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+    0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 
-    0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+    0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 
-    0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+    0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 
-    0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+    0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 
-    0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0};
+    0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 
+    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,10 +240,11 @@ 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
+/* CRC lookup table algorithm  
 #define CRC_BIT_NUM 8u/16u/32u/64u
 #define BITS_IN_BYTE 8u
 uint8_t dataBuff[ARRAY_SIZE] = { 0x32, 0x33, …};

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)