pnna

2024-07-23 18:27:27 +08:00 · 2024-07-23 18:27:27 +08:00 · a5370c8eb9
parent d0cfee8aca
commit a5370c8eb9
98 changed files with 556747 additions and 0 deletions
--- a/pnna/README.md
+++ b/pnna/README.md
@ -0,0 +1,69 @@
+# PNNA
+
+## Release 20240723
+
+> 1. 修改 DSP 下 NBG 和输入数据的定义方法，将原来的宏定义改为全局变量
+> 2. 修改 decode_image() 函数的实现方法，去掉原来的 JPEG 库，改为 image 库，修改后可处理 JPEG、PNG 格式的图片
+> 3. 在 nn_api.h 中增加获取输出大小的函数及实现
+
+
+## Release 20240625
+
+> 1. 增加top5函数，去掉归一化中多重释放
+> 2. 增加部分函数注释
+> 3. 解决不同nbg会段错误的问题
+> 4. 增加了获取classes的函数
+
+
+## Release 20240605
+
+> 1. example 中增加了 DSP 端获取时间函数
+> 2. 增加 DSP 端程序、驱动和文档等内容
+> 3. 调整了目录下的 README.md 内容
+> 4. example 中修改了 yolov4-tiny 后处理 fast 函数的参数
+
+
+## Release 20240528
+
+> 1. 优化目录结构
+> 2. 重构 pnna 核调用接口
+> 3. 修复了 float 类型推理不正确的问题
+> 4. 增加下位机 arm 端部署说明文档
+
+
+本工具箱包含应用程序的示例/接口，您可以使用它们来更轻松地访问设备或系统。
+
+包含如下几个文件和文件夹：
+
+```shell
+pnna
+  ├── example                         /* 应用程序示例/接口 */
+  ├── pnna-armhf                      /* arm 端工具及相关文件。 */
+  │   ├── gcc-arm-8.3                 /* 交叉编译器工具链 */
+  │   ├── pnna-driver                 /* pnna驱动相关的库和头文件 */
+  │   ├── third-party                 /* jpeg 库和头文件 */
+  ├── pnna-c6x                        /* DSP 端工具及相关文件。 */
+  │   ├── c6x_DDR_init                /* DDR 初始化可执行程序 */
+  │   ├── project                     /* CCS 示例工程 */
+  │   ├── pnna-drivers                /* pnna驱动相关的库和头文件 */
+  │   ├── emulation-drivers           /* 芯片相关驱动 */
+  │   ├── USB仿真器设备驱动.rar        /* 仿真器驱动 */
+  └── README.md  
+```
+
+
+应用程序使用方法详见 example 目录下的 **示例程序使用说明.md** 文件
+
+arm 端应用程序部署及说明详见 pnna-armhf 目录下 **arm端部署说明.md** 文件
+
+DSP 端应用程序部署及说明详见 pnna-c6x 目录下 **DSP端部署说明.md** 文件
+
+------
+
+
+
+
+  <div align="center">Please contact us if you have any questions.</div>
+  <div align="center">Author : @xun</div>
+  <div align="center">Copyright (c) 2024 @ccyh</div>
+
--- a/pnna/doc/pnna核高级函数调用接口.md
+++ b/pnna/doc/pnna核高级函数调用接口.md
@ -0,0 +1,757 @@
+# pnna核高级函数调用接口
+
+## 一、概述
+
+本项目旨在为用户提供一个C 应用程序演示和可调用的函数接口，以便用户可以快速了解和利用其功能。
+
+***主要功能：***
+
+- 提供多个示例应用程序演示，涵盖了项目中各种功能的使用示例。
+
+- 提供丰富的函数接口，允许用户根据需要自由组合和调用各种功能。
+
+- 支持用户快速上手和定制化，以满足各种需求和应用场景。
+
+## 二、网络流程相关
+
+### 2.1 打开设备
+
+函数原型:
+
+```C
+int pnna_open();
+```
+
+函数功能: 打开 PNNA 设备
+
+函数参数说明：无
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.2 关闭设备
+
+函数原型:
+
+```C
+int pnna_close();
+```
+
+函数功能: 关闭 PNNA 设备
+
+函数参数说明：无
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.3 初始化网络
+
+函数原型:
+
+```C
+int nn_init(nn_context **context, const char *nbg_name,\
+                unsigned int time_out);
+```
+
+函数功能: 初始化网络，为context上下文结构体中的变量分配空间
+
+函数参数说明：
+
+ - context:  网络推理上下文
+ - nbg_name: NB文件名
+ - time_out: 网络推理超时时间
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.4 网络推理
+
+函数原型:
+
+```C
+int nn_infer(nn_context *context, void **input_buffer, void **output_buffer);
+```
+
+函数功能: 对已经量化后的buffer进行推理
+
+函数参数说明：
+
+ - context:  网络推理上下文
+ - input_buffer: 已量化后的buffer
+ - output_buffer: 存放推理后的结果
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.5 获取网络输入的量化参数
+
+函数原型:
+
+```C
+int get_input_param(nn_context *context, \
+                    int index, quantization_params *params);
+```
+
+函数功能: 获取网络输入的量化参数
+
+函数参数说明：
+
+ - context:  网络推理上下文
+ - index:    网络输入的下标
+ - params:   网络输入端量化参数
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.6 获取网络输出的量化参数
+
+函数原型:
+
+```C
+int get_output_param(nn_context *context, \
+            int index, quantization_params *param);
+```
+
+函数功能: 获取网络输出的量化参数
+
+函数参数说明：
+
+ - context:  网络推理上下文
+ - index:    网络输入的下标
+ - params:   网络输出端量化参数
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.7 获取网络输入和输出的量化参数
+
+函数原型:
+
+```C
+int get_quantize_params(nn_context *context, \
+                        quantization_params *input_param,\
+                        quantization_params *output_param);
+```
+
+函数功能: 获取网络输入和输出的量化参数
+
+函数参数说明：
+
+ - context:      网络推理上下文
+ - input_param:  网络输入端量化参数
+ - output_param: 网络输出端量化参数
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.8 获取网络每个输出的大小
+
+函数原型:
+
+```C
+int get_output_sizes(nn_context *context, uint8_t type, int *size);
+```
+
+函数功能: 获取网络每个输出的大小
+
+函数参数说明：
+
+ - context:  网络推理上下文
+ - type:     输出数据的类型
+ - size:     每个输出的大小
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.9 获取推理时间
+
+函数原型:
+
+```C
+int get_infer_time(nn_context *context, int count);
+```
+
+函数功能: 通过驱动，获取推理时间和周期数
+
+函数参数说明：
+
+ - context:  网络推理上下文，结果存放在context结构体的变量中
+ - count:    固定值：1
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.10 数据量化
+
+函数原型:
+
+```C
+int nn_quantize(nn_context *context, float **input_data, void **output_data);
+```
+
+函数功能: 将数据进行量化操作
+
+函数参数说明：
+
+ - context:     网络推理上下文
+ - input_data:  待量化的数据
+ - output_data: 量化后的数据
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.11 数据反量化
+
+函数原型:
+
+```C
+int nn_dequantize(nn_context *context, void **input_data, float **output_data);
+```
+
+函数功能: 将数据进行反量化操作
+
+函数参数说明：
+
+ - context:     网络推理上下文
+ - input_data:  待反量化的数据
+ - output_data: 反量化后的结果
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 2.12 释放上下文
+
+函数原型:
+
+```C
+int nn_destroy(nn_context *context);
+```
+
+函数功能: 释放初始化上下文时，malloc出的内存空间
+
+函数参数说明：
+
+ - context: 网络推理上下文
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+## 三、工具类
+
+### 3.1 读二进制文件
+
+函数原型:
+
+```C
+unsigned int load_binary(const char *name, void *dst);
+```
+
+函数功能: 将文件以二进制的形式读到内存
+
+函数参数说明：
+
+ - name: 文件名
+ - dst:  读到的文件内容
+
+函数返回值说明：
+
+ - 成功：返回读到的字节数
+ - 失败：返回0或负数
+
+
+### 3.2 读tensor文件
+
+函数原型:
+
+```C
+unsigned int load_text_fp32(const char *name, const uint32_t size, void *dst);
+```
+
+函数功能: 将tensor文件读到内存，tensor文件格式为每一行一个浮点类型的数
+
+函数参数说明：
+
+ - name: 文件名
+ - size: 待读取的个数
+ - dst:  读到的文件内容
+
+函数返回值说明：
+
+ - 成功：返回读到的浮点数个数
+ - 失败：返回0或负数
+
+
+### 3.3 保存二进制数据到文件
+
+函数原型:
+
+```C
+unsigned int save_to_binary(const char *name, void *data, unsigned int size);
+```
+
+函数功能: 将数据以二进制的形式写到文件中
+
+函数参数说明：
+
+ - name: 文件名
+ - data: 待保存的数据
+ - size: 待保存数据的大小
+
+函数返回值说明：
+
+ - 成功：返回实际写到文件中的大小
+ - 失败：返回0
+
+
+### 3.4 将U8类型的数据写到文件中
+
+函数原型:
+
+```C
+unsigned int save_u8_to_text(const char *name, void *data, unsigned int size);
+```
+
+函数功能: 将U8类型的数据写到文件中
+
+函数参数说明：
+
+ - name: 文件名
+ - data: 待保存的数据
+ - size: 待保存数据的大小
+
+函数返回值说明：
+
+ - 成功：实际写到文件中的大小
+ - 失败：返回0
+
+
+### 3.5 将float类型的数据写到文件中
+
+函数原型:
+
+```C
+unsigned int save_fp32_to_text(const char *name, float *data, unsigned int size);
+```
+
+函数功能: 将float类型的数据写到文件中
+
+函数参数说明：
+
+ - name: 文件名
+ - data: 待保存的数据
+ - size: 待保存数据的大小
+
+函数返回值说明：
+
+ - 成功：实际写到文件中的大小
+ - 失败：返回0
+
+
+### 3.6 获取文件大小
+
+函数原型:
+
+```C
+unsigned int get_file_size(const char *name);
+```
+
+函数功能: 利用 ftell 函数获取文件大小
+
+函数参数说明：
+
+ - name: 文件名
+
+函数返回值说明：
+
+ - 成功：返回文件大小
+ - 失败：返回0
+
+
+### 3.7 解码JPEG文件
+
+函数原型:
+
+```C
+int get_jpeg_data(char **input_name, uint32_t w, uint32_t h, uint32_t c, \
+                const uint16_t input_count, void **output_buffer);
+```
+
+函数功能: 解码JPEG文件，得到BMP格式（U8）的结果
+
+函数参数说明：
+
+ - input_name: 输入文件名数组（一个网络可能有多个输入）
+ - w: 输入图片的宽
+ - h: 输入图片的高
+ - c: 输入图片的通道数
+ - input_count: 网络输入个数
+ - output_buffer: 将输入文件解码后，存放得到的结果指针
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 3.8 解码TENSOR文件
+
+函数原型:
+
+```C
+int get_tensor_data(char **input_name, const int input_count,\
+                    const uint32_t input_size, void **output_buffer);
+```
+
+函数功能: 解码TENSOR文件，得到float格式的结果
+
+函数参数说明：
+
+ - input_name: 输入文件名数组（一个网络可能有多个输入）
+ - input_count: 网络输入个数
+ - input_size:  网络输入的大小
+ - output_buffer: 将输入文件解码后，存放得到的结果指针
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 3.9 解码二进制文件
+
+函数原型:
+
+```C
+int get_binary_data(char **input_name, const int input_count,\
+                    const uint32_t input_size, void **output_buffer);
+```
+
+函数功能: 解码二进制文件，得到 U8 格式的结果
+
+函数参数说明：
+
+ - input_name: 输入文件名数组（一个网络可能有多个输入）
+ - input_count: 网络输入个数
+ - input_size:  网络输入的大小
+ - output_buffer: 将输入文件解码后，存放得到的结果指针
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+
+## 四、前处理相关
+
+### 4.1 设置归一化参数
+
+函数原型:
+
+```C
+void set_normalize_params(normalization_params *norm_params, int w, int h, int c,\
+                int *mean, int *std, int *reorder_channel, float scale);
+```
+
+函数功能: 设置归一化参数到结构体
+
+函数参数说明：
+
+ - norm_params: 将参数赋值给该结构体
+ - w:  图片宽
+ - h:  图片高
+ - c:  图片通道数
+ - mean: 数组，每个通道的平均值
+ - std:  数组，每个通道的标准差
+ - reorder_channel: 数组，通道的顺序rgb bgr...
+ - scale: 缩放因子
+
+函数返回值说明：
+  无
+
+
+### 4.2 创建空间
+
+函数原型:
+
+```C
+int create_buffers(void **buffer, const int count, int *size);
+```
+
+函数功能: 利用malloc创建空间
+
+函数参数说明：
+
+ - buffer: 创建好的内存空间地址
+ - count:  需要创建内存空间的个数
+ - size :  需要创建内存空间的大小
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+### 4.3 销毁空间
+
+函数原型:
+
+```C
+void destroy_buffers(void **buffer, const int count);
+```
+
+函数功能: 销毁空间，与create_buffers()函数配套使用
+
+函数参数说明：
+
+ - buffer: 待销毁的内存空间地址
+ - count:  待销毁的内存空间的个数
+
+函数返回值说明：
+  无
+
+
+### 4.4 归一化操作
+
+函数原型:
+
+```C
+int preprocess(void **input_buffer, normalization_params *norm_params, \
+                int input_count, void **output_buffer);
+```
+
+函数功能: 前处理，将每维度输入数据都进行归一化操作
+
+函数参数说明：
+
+ - input_buffer:  待归一化的数据
+ - norm_params:   归一化参数
+ - input_count:   输入数据的维度
+ - output_buffer: 归一化后的结果
+
+函数返回值说明：
+
+ - 成功：返回 PNNA_SUCCESS
+ - 失败：返回其他值
+
+
+
+## 五、量化与反量化
+
+### 5.1 获取输入/输出个数
+
+函数原型:
+
+```C
+unsigned int get_element_num(unsigned int *sizes, unsigned int num_of_dims);
+```
+
+函数功能: 根据维度和每个维度的大小，算出所有数据的个数
+
+函数参数说明：
+
+ - sizes: 每个维度的大小
+ - num_of_dims: 维度
+
+函数返回值说明：
+
+ - 成功：所有数据的个数
+ - 失败：返回0
+
+
+### 5.2 单个数据的反量化
+
+函数原型:
+
+```C
+int dtype_to_float32(unsigned char *src, float *dst, const int data_format,\
+    const int quant_format, const signed char fixed_point_pos, \
+    const float scale, const int zeroPoint);
+```
+
+函数功能: 单个数据的反量化操作
+
+函数参数说明：
+
+ - src: 待反量化的数
+ - dst: 反量化后的数
+ - data_format: 数据类型
+ - quant_format: 量化类型
+ - fixed_point_pos: 固定小数点位置
+ - scale: 缩放因子
+ - zeroPoint: 零点
+
+函数返回值说明：
+
+ - 成功：返回0
+ - 失败：返回其他值
+
+
+### 5.3 单个数据的量化
+
+函数原型:
+
+```C
+int float32_to_dtype(float src, unsigned char *dst, const int data_format,\
+    const int quant_format, const signed char fl, const float scale, const int zerop);
+```
+
+函数功能: 单个数据的量化操作
+
+函数参数说明：
+
+ - src: 待量化的数
+ - dst: 量化后的数
+ - data_format: 数据类型
+ - quant_format: 量化类型
+ - fixed_point_pos: 固定小数点位置
+ - scale: 缩放因子
+ - zeroPoint: 零点
+
+函数返回值说明：
+
+ - 成功：返回0
+ - 失败：返回其他值
+
+
+### 5.4 批量数据的仿射量化
+
+函数原型:
+
+```C
+void asym_affine(float *input, const int size, const int stride, \
+        const float scale, const int zeropoint, int data_type, uint8_t *output);
+```
+
+函数功能: 批量数据的仿射量化操作
+
+函数参数说明：
+
+ - input: 待量化的数据
+ - size: 待量化数据的大小
+ - stride: 数据类型所占的字节数
+ - scale: 缩放因子
+ - zeroPoint: 零点
+ - data_type: 数据类型
+ - output: 量化后的数据
+
+函数返回值说明：
+  无
+
+
+### 5.5 批量数据的定点浮点量化
+
+函数原型:
+
+```C
+void dynamic_fix_point(float *input, const int size, const int stride, \
+        const int fl, int data_type, uint8_t *output);
+```
+
+函数功能: 批量数据的定点浮点量化操作
+
+函数参数说明：
+
+ - input: 待量化的数据
+ - size:  待量化数据的大小
+ - stride: 数据类型所占的字节数
+ - fl: 固定小数点位置
+ - data_type: 数据类型
+ - output: 量化后的数据
+
+函数返回值说明：
+  无
+
+
+### 5.6 批量数据的仿射反量化
+
+函数原型:
+
+```C
+void asym_affine_inverse(void *input, const int size,\
+        const float scale, const int zeropoint, int data_type, float *output);
+```
+
+函数功能: 批量数据的仿射反量化操作
+
+函数参数说明：
+
+ - input: 待反量化的数据
+ - size: 待反量化数据的大小
+ - scale: 缩放因子
+ - zeroPoint: 零点
+ - data_type: 数据类型
+ - output: 反量化后的数据
+
+函数返回值说明：
+  无
+
+
+### 5.7 批量数据的定点浮点反量化
+
+函数原型:
+
+```C
+void dynamic_fix_point_inverse(void *input, const int size,\
+        const int fl, int data_type, float *output);
+```
+
+函数功能: 批量数据的定点浮点反量化操作
+
+函数参数说明：
+
+ - input: 待反量化的数据
+ - size:  待反量化数据的大小
+ - fl: 固定小数点位置
+ - data_type: 数据类型
+ - output: 反量化后的数据
+
+函数返回值说明：
+  无
+
+
+
+
+------
+
+
+  <div align="center">Please contact us if you have any questions.</div>
+  <div align="center">Author : @xun</div>
+  <div align="center">Copyright (c) 2024 @ccyh</div>
+
--- a/pnna/example/Makefile
+++ b/pnna/example/Makefile
@ -0,0 +1,39 @@
+BIN=test
+
+TOOLCHAIN_DIR=/home/xun/gcc-arm/gcc-arm-8.3
+DRIVER_DIR=/home/xun/03n/sdk_dir
+JPEG_DIR=/home/xun/03n/third-party/image
+
+CC=$(TOOLCHAIN_DIR)/bin/arm-linux-gnueabihf-gcc
+
+INCLUDES = -I. -I$(DRIVER_DIR)/include -I$(JPEG_DIR)/include -I./include
+
+CFLAGS=-Wall $(INCLUDES)  -D__linux__ -DLINUX
+
+LIBS=-lm
+LIBS+= $(DRIVER_DIR)/lib/libpnna.a $(JPEG_DIR)/lib/libimage.a
+LIBS+= -L$(DRIVER_DIR)/drivers -lPNNAlite -lPNNAuser
+
+SRCS=$(wildcard *.c) $(wildcard postprocess/*.c))
+OBJS=$(addprefix obj/, $(addsuffix .o, $(basename $(SRCS))))
+
+.SUFFIXES: .c
+.c.o:
+	$(CC) $(CFLAGS) -c $< -o $@
+
+.PHONY: all clean
+
+all: objFolder $(BIN)
+
+objFolder:
+	mkdir -p obj obj/postprocess
+$(BIN): $(OBJS)
+	$(CC) $(CFLAGS) $(LFLAGS) $(EXTRALFLAGS) $^ $(LIBS) -o $@
+
+obj/%.o: %.c | objFolder
+	$(CC) $(CFLAGS) -c $< -o $@
+
+clean:
+	rm -rf obj $(BIN)
+
+
--- a/pnna/example/include/nn_api.h
+++ b/pnna/example/include/nn_api.h
@ -0,0 +1,237 @@
+/*
+ * @Author: xun
+ * @Date: 2024-04-03 16:02:39
+ * @LastEditors: xun
+ * @LastEditTime: 2024-07-09 16:15:08
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+#ifndef _NN_API_H_
+#define _NN_API_H_
+
+#include <stdint.h>
+#include "pnna_lite.h"
+
+
+void TimeBegin(int id);
+void TimeEnd(int id);
+uint64_t TimeGet(int id);
+
+#ifndef LINUX
+
+extern uint64_t t_overhead;
+
+extern uint32_t *network_address;        //NBG
+extern uint32_t *input_dat0_address;     //input_0.dat
+extern uint32_t *input_dat1_address;     //input_1.dat
+extern uint32_t  my_network_size;        //yolov4-tiny NBG
+extern uint32_t  my_input_size;          //yolov4-tiny input_0.dat
+
+void init_timer();
+
+#endif
+
+
+/**
+ * @brief 网络推理上下文，用于存放nbg相关信息
+ * 
+ */
+typedef struct _nn_context {
+    /* nn information. */
+    char           *nbg_name;
+    int             input_count;
+    char          **input_names;
+    int             output_count;
+    char          **output_names;
+    int            *input_size;
+
+    /* PNNA lite buffer objects. */
+    pnna_network     network;
+    pnna_buffer     *input_buffers;
+    pnna_buffer     *output_buffers;
+
+    /* nn 推理时间相关参数 */
+    uint32_t   loop_count;
+    uint32_t   infer_cycle;
+    uint32_t   infer_time;
+    uint64_t   total_infer_cycle;
+    uint64_t   total_infer_time;
+} nn_context;
+
+
+/**
+ * @brief 量化相关参数，输入、输出量化参数不相同，
+ *          有几个输出就有几个不同的输出量化参数
+ * 
+ */
+typedef struct _quantization_params
+{
+    unsigned int   num_of_dims;
+    unsigned int   sizes[6];
+    int       data_format;
+    int       quant_format;
+    union {
+        struct {
+            int fixed_point_pos;
+        } dfp;
+
+        struct {
+            float   scale;
+            int     zeroPoint;
+        } affine;
+     } quant_data;
+
+    int    memory_type;
+} quantization_params;
+
+
+/**
+ * @brief 打开 PNNA 设备
+ * 
+ * @return int 处理后的状态码，0表示成功打开设备
+ */
+int pnna_open();
+
+/**
+ * @brief 关闭 PNNA 设备
+ * 
+ * @return int 处理后的状态码，0表示成功关闭设备
+ */
+int pnna_close();
+
+
+/**
+ * @brief 初始化网络，为context上下文结构体中的变量分配空间
+ * 
+ * @param OUT context 网络推理上下文
+ * @param IN  nbg_name NB文件名
+ * @param IN  time_out 网络推理超时时间
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int nn_init(nn_context **context, const char *nbg_name,\
+                unsigned int time_out);
+
+/**
+ * @brief 对已经量化后的buffer进行推理
+ * 
+ * @param IN context 网络推理上下文
+ * @param IN  input_buffer 已量化后的buffer
+ * @param OUT output_buffer 存放结果
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int nn_infer(nn_context *context, void **input_buffer, void **output_buffer);
+
+/**
+ * @brief 获取网络输入的量化参数
+ * 
+ * @param IN  context 网络推理上下文
+ * @param IN  index   网络输入的下标
+ * @param OUT params  网络输入端量化参数
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_input_param(nn_context *context, \
+                    int index, quantization_params *params);
+
+/**
+ * @brief 获取网络输出的量化参数
+ * 
+ * @param IN  context 网络推理上下文
+ * @param IN  index   网络输出的下标
+ * @param OUT param   网络输出端量化参数
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_output_param(nn_context *context, \
+            int index, quantization_params *param);
+
+
+/**
+ * @brief 获取网络输入和输出的量化参数
+ * 
+ * @param IN  context 网络推理上下文
+ * @param OUT input_param 网络输入端量化参数
+ * @param OUT output_param 网络输出端量化参数
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_quantize_params(nn_context *context, \
+                        quantization_params *input_param,\
+                        quantization_params *output_param);
+
+
+/**
+ * @brief 获取网络每个输出的大小
+ * 
+ * @param IN  context 网络推理上下文
+ * @param IN  type  输出数据的类型
+ * @param OUT size  每个输出的大小
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_output_sizes(nn_context *context, uint8_t type, int *size);
+
+
+/**
+ * @brief 获取网络上下文中每个输出的大小，包含步长
+ * 
+ * @param IN  context 网络推理上下文
+ * @param OUT size  每个输出的大小
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_context_output_buffer_size(nn_context *context, int *size);
+
+
+/**
+ * @brief 通过驱动，获取推理时间和周期数（非应用层函数）
+ * 
+ * @param OUT context 结果存放在context结构体的变量中
+ * @param IN  count 固定值：1
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_infer_time(nn_context *context, int count);
+
+
+/**
+ * @brief 将数据进行量化操作
+ * 
+ * @param IN  context 网络推理上下文
+ * @param IN  input_data 待量化的数据
+ * @param OUT output_data  量化后的结果
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int nn_quantize(nn_context *context, float **input_data, void **output_data);
+
+
+/**
+ * @brief 将数据进行反量化操作
+ * 
+ * @param IN  context 网络推理上下文
+ * @param IN  input_data 待反量化的数据
+ * @param OUT output_data  反量化后的结果
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int nn_dequantize(nn_context *context, void **input_data, float **output_data);
+
+
+/**
+ * @brief 从量化参数集中获取后处理分类个数
+ * 
+ * @param IN  params 量化参数数据集
+ * @return int 返回得到的后处理分类个数
+ */
+int get_yolo_classes_from_params(quantization_params *params);
+
+
+/**
+ * @brief 从网络推理上下文中获取后处理分类个数
+ * 
+ * @param IN  context 网络推理上下文
+ * @return int 返回得到的后处理分类个数
+ */
+int get_yolo_classes_from_context(nn_context *context);
+
+/**
+ * @brief 释放初始化上下文时，malloc出的内存空间
+ * 
+ * @param IN context 网络推理上下文
+ */
+int nn_destroy(nn_context *context);
+
+#endif // !_NN_API_H_
--- a/pnna/example/include/nn_utils.h
+++ b/pnna/example/include/nn_utils.h
@ -0,0 +1,173 @@
+/*
+ * @Author: xun
+ * @Date: 2024-04-03 16:02:39
+ * @LastEditors: xun
+ * @LastEditTime: 2024-07-23 14:48:17
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+#ifndef _NN_UTILS_H_
+#define _NN_UTILS_H_
+
+#include <stdio.h>
+#include <stdint.h>
+
+/**
+ * @brief 错误码补充
+ * 
+ */
+typedef enum _nn_status
+{
+    NN_ERROR_QUANTIZE                 = -21,
+    NN_ERROR_NORMALIZE                = -20,
+    NN_MALLOC_BUFFER                  = -19,
+    NN_MALLOC_OUT_PARAM               = -18,
+    NN_GET_OUTPUT_CNT                 = -17,
+    NN_ERROR_INFER_TIME               = -16,
+    NN_SUCCESS                        =  0
+} nn_status_e;
+
+/**
+ * @brief 将错误码转换成字符串
+ * 
+ * @param IN  i_errno错误码
+ * @return char * 转换后的字符串
+ */
+char *errno2str(int i_errno);
+
+
+/**
+ * @brief 打印字符串
+ * 
+ */
+void print_msg(const char *format, ...) __attribute__ ((format(printf,1,2)));
+
+
+/**
+ * @brief 将文件以二进制的形式读到内存
+ * 
+ * @param IN  name 文件名
+ * @param OUT dst  读到的文件内容
+ * @return unsigned int 读到的文件大小
+ */
+unsigned int load_binary(const char *name, void *dst);
+
+
+/**
+ * @brief 将tensor文件读到内存，tensor文件格式为每一行一个浮点类型的数
+ * 
+ * @param IN  name 文件名
+ * @param IN  size 待读取的个数
+ * @param OUT dst  读到的文件内容
+ * @return unsigned int 读到的个数
+ */
+unsigned int load_text_fp32(const char *name, const uint32_t size, void *dst);
+
+
+/**
+ * @brief 将数据以二进制的形式写到文件中
+ * 
+ * @param IN  name 文件名
+ * @param IN  data 待保存的数据
+ * @param OUT size 待保存数据的大小
+ * @return unsigned int 实际写到文件中的大小
+ */
+unsigned int save_to_binary(const char *name, void *data, unsigned int size);
+
+
+/**
+ * @brief 将U8类型的数据写到文件中
+ * 
+ * @param IN  name 文件名
+ * @param IN  data 待保存的数据
+ * @param OUT size 待保存数据的大小
+ * @return unsigned int 实际写到文件中的大小
+ */
+unsigned int save_u8_to_text(const char *name, void *data, unsigned int size);
+
+
+/**
+ * @brief 将float类型的数据写到文件中
+ * 
+ * @param IN  name 文件名
+ * @param IN  data 待保存的数据
+ * @param OUT size 待保存数据的大小
+ * @return unsigned int 实际写到文件中的大小
+ */
+unsigned int save_fp32_to_text(const char *name, float *data, unsigned int size);
+
+
+/**
+ * @brief 利用 ftell 函数获取文件大小
+ * 
+ * @param IN  name 文件名
+ * @return unsigned int 文件大小
+ */
+unsigned int get_file_size(const char *name);
+
+
+/**
+ * @brief 解码JPEG文件，得到BMP格式（U8）的结果
+ * 
+ * @param IN  input_name 输入文件名数组（一个网络可能有多个输入）
+ * @param IN  w 输入图片的宽
+ * @param IN  h 输入图片的高
+ * @param IN  c 输入图片的通道数
+ * @param IN  input_count 网络输入个数
+ * @param OUT output_buffer 将输入文件解码后，存放得到的结果指针
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_jpeg_data(char **input_name, uint32_t w, uint32_t h, uint32_t c, \
+                const uint16_t input_count, void **output_buffer);
+
+
+/**
+ * @brief 解码TENSOR文件，得到float格式的结果
+ * 
+ * @param IN  input_name 输入文件名数组（一个网络可能有多个输入）
+ * @param IN  input_count 网络输入个数
+ * @param IN  input_size  网络输入的大小
+ * @param OUT output_buffer 将输入文件解码后，存放得到的结果指针
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_tensor_data(char **input_name, const int input_count,\
+                    const uint32_t input_size, void **output_buffer);
+
+/**
+ * @brief 解码二进制文件，得到U8格式的结果
+ * 
+ * @param IN  input_name 输入文件名数组（一个网络可能有多个输入）
+ * @param IN  input_count 网络输入个数
+ * @param IN  input_size  网络输入的大小
+ * @param OUT output_buffer 将输入文件解码后，存放得到的结果指针
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int get_binary_data(char **input_name, const int input_count,\
+                    const uint32_t input_size, void **output_buffer);
+
+
+/**
+ * @brief 在字符串中查找第一次出现的子字符串 orig，并将其替换为字符串 rep，最终结果存储在 output 中
+ * 
+ * @param IN  str  要查找和替换的原始字符串
+ * @param IN  orig 要查找并替换的子字符串
+ * @param IN  rep  替换 orig 的字符串
+ * @param OUT output 存储结果的字符串
+ * @return NULL
+ */
+void find_replace(const char* str, char* orig, char* rep, char* output);
+
+
+/**
+ * @brief 查找和替换文件路径中的文件扩展名，比如将 ".txt" 替换为 ".csv"
+ * 
+ * @param IN  str  要查找和替换的原始字符串
+ * @param IN  orig 要查找并替换的子字符串
+ * @param IN  rep  替换 orig 的字符串
+ * @param OUT output 存储结果的字符串
+ * @return NULL
+ */
+void find_replace_extension(char *str, char *orig, char *rep, char *output);
+
+#endif  // !_NN_UTILS_H_
+
--- a/pnna/example/include/preprocess.h
+++ b/pnna/example/include/preprocess.h
@ -0,0 +1,78 @@
+/*
+ * @Author: xun
+ * @Date: 2024-05-08 09:30:39
+ * @LastEditors: xun
+ * @LastEditTime: 2024-05-11 14:22:42
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+#ifndef _PREPROCESS_H_
+#define _PREPROCESS_H_
+
+/**
+ * @brief 归一化相关参数，输入为图片时用到
+ * 
+ */
+typedef struct _normalization_params
+{
+    int width;
+    int height;
+    int channel;
+    int mean[3];
+    int std[3];
+    int reorder_channel[3];
+    float scale;
+} normalization_params;
+
+
+/**
+ * @brief 设置归一化参数
+ * 
+ * @param OUT norm_params 将参数赋值给该结构体
+ * @param IN  w  图片宽
+ * @param IN  h  图片高
+ * @param IN  c  图片通道数
+ * @param IN  mean 数组，每个通道的平均值
+ * @param IN  std  数组，每个通道的标准差
+ * @param IN  reorder_channel  数组，通道的顺序rgb bgr...
+ * @param IN  scale 缩放因子
+ */
+void set_normalize_params(normalization_params *norm_params, int w, int h, int c,\
+                int *mean, int *std, int *reorder_channel, float scale);
+
+
+/**
+ * @brief 利用malloc创建空间
+ * 
+ * @param OUT buffer 创建好的内存空间地址
+ * @param IN  count  需要创建内存空间的个数
+ * @param IN  size   需要创建内存空间的大小
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int create_buffers(void **buffer, const int count, int *size);
+
+
+/**
+ * @brief 销毁空间，与create_buffers()函数配套使用
+ * 
+ * @param IN buffer 待销毁的内存空间地址
+ * @param IN count  待销毁的内存空间的个数
+ */
+void destroy_buffers(void **buffer, const int count);
+
+
+/**
+ * @brief 前处理，将每维度输入数据都进行归一化操作
+ * 
+ * @param IN  input_buffer  待归一化的数据
+ * @param IN  norm_params   归一化参数
+ * @param IN  input_count   输入数据的维度
+ * @param OUT output_buffer 归一化后的结果
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int preprocess(void **input_buffer, normalization_params *norm_params, \
+                int input_count, void **output_buffer);
+
+
+#endif // !_PREPROCESS_H_
--- a/pnna/example/include/quantize.h
+++ b/pnna/example/include/quantize.h
@ -0,0 +1,185 @@
+/*
+ * @Author: xun
+ * @Date: 2024-05-08 09:48:30
+ * @LastEditors: xun
+ * @LastEditTime: 2024-06-24 11:41:21
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+
+#ifndef _QUANTIZE_H_
+#define _QUANTIZE_H_
+
+#include <stdint.h>
+
+#define BITS_PER_BYTE  8
+
+
+/**
+ * @brief 根据数据类型确定该数据类型所占的字节数，并返回该字节数值
+ * 
+ * @param IN  type 数据类型
+ * @return unsigned int 字节数值
+ */
+unsigned int type_get_bytes(const int type);
+
+
+/**
+ * @brief 根据数据类型确定该数据类型所占的字节数，并返回该字节数值
+ * 
+ * @param IN  data_format 数据类型
+ * @return int 字节数值
+ */
+int get_stride(int data_format);
+
+
+/**
+ * @brief 根据数据类型确定该数据类型所占的bit数，并返回该bits数值
+ * 
+ * @param IN  type 数据类型
+ * @return unsigned int bits数值
+ */
+unsigned int type_get_bits(const int type);
+
+
+/**
+ * @brief 根据维度和每个维度的大小，算出所有数据的个数
+ * 
+ * @param IN  sizes 每个维度的大小
+ * @param IN  num_of_dims 维度
+ * @return unsigned int 所有数据的个数
+ */
+unsigned int get_element_num(unsigned int *sizes, unsigned int num_of_dims);
+
+
+/**
+ * @brief 根据维度和每个维度的大小，算出所有数据的个数
+ * 
+ * @param IN  sizes 每个维度的大小
+ * @param IN  num_of_dims 维度
+ * @return unsigned int 所有数据的个数
+ */
+int compare_values(unsigned char *a,  unsigned char *b, int obj_index, const int data_format);
+
+
+/**
+ * @brief 单个数据的反量化操作
+ * 
+ * @param IN  src 待反量化的数
+ * @param OUT dst 反量化后的数
+ * @param IN  data_format 数据类型
+ * @param IN  quant_format 量化类型
+ * @param IN  fixed_point_pos 固定小数点位置
+ * @param IN  scale 缩放因子
+ * @param IN  zeroPoint 零点
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int dtype_to_float32(unsigned char *src, float *dst, const int data_format,\
+    const int quant_format, const signed char fixed_point_pos, \
+    const float scale, const int zeroPoint);
+
+
+/**
+ * @brief 单个数据的量化操作
+ * 
+ * @param IN  src 待量化的数
+ * @param OUT dst 量化后的数
+ * @param IN  data_format 数据类型
+ * @param IN  quant_format 量化类型
+ * @param IN  fixed_point_pos 固定小数点位置
+ * @param IN  scale 缩放因子
+ * @param IN  zeroPoint 零点
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int float32_to_dtype(float src, unsigned char *dst, const int data_format,\
+    const int quant_format, const signed char fl, const float scale, const int zerop);
+
+
+/**
+ * @brief 批量数据的仿射量化操作
+ * 
+ * @param IN  input 待量化的数据
+ * @param IN  size 待量化数据的大小
+ * @param IN  stride 数据类型所占的字节数
+ * @param IN  scale 缩放因子
+ * @param IN  zeroPoint 零点
+ * @param IN  data_type 数据类型
+ * @param OUT output 量化后的数据
+ * @return 
+ */
+void asym_affine(float *input, const int size, const int stride, \
+        const float scale, const int zeropoint, int data_type, uint8_t *output);
+
+
+/**
+ * @brief 批量数据的定点浮点量化操作
+ * 
+ * @param IN  input 待量化的数据
+ * @param IN  size  待量化数据的大小
+ * @param IN  stride 数据类型所占的字节数
+ * @param IN  fl 固定小数点位置
+ * @param IN  data_type 数据类型
+ * @param OUT output 量化后的数据
+ * @return 
+ */
+void dynamic_fix_point(float *input, const int size, const int stride, \
+        const int fl, int data_type, uint8_t *output);
+
+
+/**
+ * @brief 批量数据的仿射反量化操作
+ * 
+ * @param IN  input 待反量化的数据
+ * @param IN  size 待反量化数据的大小
+ * @param IN  scale 缩放因子
+ * @param IN  zeroPoint 零点
+ * @param IN  data_type 数据类型
+ * @param OUT output 反量化后的数据
+ * @return 
+ */
+void asym_affine_inverse(void *input, const int size,\
+        const float scale, const int zeropoint, int data_type, float *output);
+
+
+/**
+ * @brief 批量数据的定点浮点反量化操作
+ * 
+ * @param IN  input 待反量化的数据
+ * @param IN  size  待反量化数据的大小
+ * @param IN  fl 固定小数点位置
+ * @param IN  data_type 数据类型
+ * @param OUT output 反量化后的数据
+ * @return 
+ */
+void dynamic_fix_point_inverse(void *input, const int size,\
+        const int fl, int data_type, float *output);
+
+
+/**
+ * @brief 批量数据的单精度浮点数到半精度浮点数的量化操作
+ * 
+ * @param IN  input 待反量化的数据
+ * @param IN  size  待反量化数据的大小
+ * @param IN  stride 待反量化数据的步长
+ * @param OUT output 反量化后的数据
+ * @return 
+ */
+void convert_float_to_fp16(float *input, const int size,\
+                        const int stride, uint8_t *output);
+
+
+/**
+ * @brief 批量数据的半精度浮点数到单精度浮点数的反量化操作
+ * 
+ * @param IN  input 待反量化的数据
+ * @param IN  size  待反量化数据的大小
+ * @param OUT output 反量化后的数据
+ * @return 
+ */
+void convert_fp16_to_float(short *input, const int size,\
+                        float *output);
+
+
+#endif // !_QUANTIZE_H_
+
--- a/pnna/example/postprocess/classification_post.c
+++ b/pnna/example/postprocess/classification_post.c
@ -0,0 +1,75 @@
+/*
+ * @Author: xun
+ * @Date: 2024-06-24 11:13:38
+ * @LastEditors: xun
+ * @LastEditTime: 2024-06-24 11:31:14
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+#include "classification_post.h"
+
+int classification_postprocess(float **input_buffer, int counts, int *sizes, CLASSIFICATION_RESULT *result)
+{
+    int ret = 0;
+    int i = 0;
+    int j = 0;
+    int topk = CLASSIFICATION_RESULT_TOP_NUM;
+
+    for(i = 0; i < counts; i++)
+    {
+        printf("sizes[%d] %d\n", i, sizes[i]);
+        ret = get_top(input_buffer[i], result->fMaxProb, result->MaxClass, sizes[i], topk);
+
+        printf("--- Top%d ---\n", topk);
+        for(j = 0; j < topk; j++)
+        {
+            printf("%d: %f\n", result->MaxClass[j], result->fMaxProb[j]);
+        }
+    }
+
+    ret = topk;
+
+    return ret;
+}
+
+
+int get_top(float *pfProb, float* pfMaxProb, uint32_t* pMaxClass, \
+                uint32_t outputCount, uint32_t topNum)
+{
+	uint32_t i, j, k;
+
+    #define MAX_TOP_NUM 20
+    if (topNum > MAX_TOP_NUM) return -1;
+
+    memset(pfMaxProb, 0xfe, sizeof(float) * topNum);
+    memset(pMaxClass, 0xff, sizeof(uint32_t) * topNum);
+
+    for(j = 0; j < topNum; j++)
+    {
+        for(i = 0; i < outputCount; i++)
+        {
+            for(k = 0; k < topNum; k++)
+            {
+                if(i == pMaxClass[k])
+                {
+                    break;
+                }
+            }
+
+            if(k != topNum)
+            {
+                continue;
+            }
+
+            if(pfProb[i] > *(pfMaxProb + j))
+            {
+                *(pfMaxProb + j) = pfProb[i];
+                *(pMaxClass + j) = i;
+            }
+        }
+    }
+
+    return 0;
+}
+
--- a/pnna/example/postprocess/classification_post.h
+++ b/pnna/example/postprocess/classification_post.h
@ -0,0 +1,54 @@
+/*
+ * @Author: xun
+ * @Date: 2024-06-24 11:13:38
+ * @LastEditors: xun
+ * @LastEditTime: 2024-06-24 11:32:47
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+#ifndef _CLASSIFICATION_POST_H_
+#define _CLASSIFICATION_POST_H_
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdint.h>
+
+#define CLASSIFICATION_RESULT_TOP_NUM 2
+
+typedef struct classification_result_t
+{
+    uint32_t MaxClass[CLASSIFICATION_RESULT_TOP_NUM];
+    float fMaxProb[CLASSIFICATION_RESULT_TOP_NUM];
+}CLASSIFICATION_RESULT;
+
+
+/**
+ * @brief 分类后处理函数
+ * 
+ * @param IN  input_buffer 需要进行分类处理的数据地址
+ * @param IN  counts 需要进行分类处理的个数
+ * @param IN  sizes  需要进行分类处理的大小
+ * @param OUT result 最终结果
+ * @return int 返回处理后的 top 值
+ */
+int classification_postprocess(float **input_buffer, int counts, \
+                    int *sizes, CLASSIFICATION_RESULT *result);
+
+
+/**
+ * @brief 打印yolov4-tiny后处理结果
+ * 
+ * @param IN  pfProb 输入数据地址
+ * @param OUT pfMaxProb 用于存储最高概率值
+ * @param OUT pMaxClass 用于存储对应最高概率值的类别
+ * @param IN  outputCount 输出的总数
+ * @param OUT topNum 需要获取的最高概率值的个数，即top N个
+ * @return int 返回处理后的状态码，0表示成功，其他表示失败
+ */
+int get_top(float *pfProb, float* pfMaxProb, uint32_t* pMaxClass,\
+                 uint32_t outputCount, uint32_t topNum);
+
+#endif
--- a/pnna/example/postprocess/yolov4_tiny_post.c
+++ b/pnna/example/postprocess/yolov4_tiny_post.c
@ -0,0 +1,411 @@
+/*
+ * @Author: xun
+ * @Date: 2024-04-11 09:51:01
+ * @LastEditors: xun
+ * @LastEditTime: 2024-07-22 18:03:38
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdint.h>
+
+#include "yolov4_tiny_post.h"
+
+#define F_MAX(a,b)               (((a) > (b)) ? (a) : (b))
+#define F_MIN(a,b)               (((a) < (b)) ? (a) : (b))
+
+// box.h
+typedef struct boxabs {
+    float left, right, top, bot;
+} boxabs;
+
+float layer_anchors[2][6] = {{ 81, 82, 135, 169, 344, 319 }, { 10, 14, 23, 27, 37, 58 }};
+int layer_mask[2][3] = {{3, 4, 5}, {1, 2, 3}};
+float layer_scales[2] = {32, 16};
+float layer_biases[12] = {10.0f, 14.0f, 23.0f, 27.0f, 37.0f, 58.0f, 81.0f, 82.0f, 135.0f, 169.0f, 344.0f, 319.0f};
+int output_dims[2][3] = {{13, 13, 255}, {26, 26, 255}};
+
+static inline float dtype_to_fp32(int val, int zeroPoint, float scale)
+{
+    float result = 0.0f;
+    result = ((float)val - zeroPoint) * scale;
+    return result;
+}
+
+float logistic_activate(float x)
+{
+    return 1.f/(1.f + expf(-x));
+}
+
+float scal_add_cpu(float ALPHA, float BETA, float X)
+{
+    float X_final;
+    X_final = X * ALPHA + BETA;
+    return X_final;
+}
+
+float r_sigmoid(float y)
+{
+    float value;
+    float ln_value;
+
+    ln_value = (1 - y) / y;
+    value = -log(ln_value);
+
+    return value;
+}
+
+static int entry_index_float(flayer l, int batch, int location, int entry)
+{
+    int n =   location / (l.w*l.h);
+    int loc = location % (l.w*l.h);
+    return batch*l.outputs + n*l.w*l.h*(4+l.classes+1) + entry*l.w*l.h + loc;
+}
+
+int entry_index(layer l, int batch, int location, int entry)
+{
+    int n = location / (l.w * l.h);
+    int loc = location % (l.w * l.h);
+    return batch * l.outputs + n * l.w * l.h * (4 + l.classes + 1) + entry * l.w * l.h + loc;
+}
+
+static box get_yolo_box_float(float* x, float* biases, int n, int index, int i, int j, int lw, int lh, int w, int h, int stride)
+{
+    box b;
+
+    // printf("index: %d, lw: %d, lh: %d, stride: %d, n: %d, biases: %f %f\n", index, lw, lh, stride, n, biases[2 * n], biases[2 * n + 1]);
+    b.x = (i + x[index + 0 * stride]) / lw;
+    b.y = (j + x[index + 1 * stride]) / lh;
+    b.w = exp(x[index + 2 * stride]) * biases[2 * n] / w;
+    b.h = exp(x[index + 3 * stride]) * biases[2 * n + 1] / h;
+
+    // printf("[%f %f %f %f]\n", b.x, b.y, b.w, b.h);
+    return b;
+}
+
+void get_yolo_detections_float(flayer* l, int netw, int neth, float threshold, detection* dets)
+{
+    int i, j, k, n;
+    dets[0].size = 0;
+    int count = 0;
+    for (k = 0; k < OUTPUT_NUM; ++k)
+    {
+        float *predictions = l[k].output;
+        for (i = 0; i < l[k].w * l[k].h; ++i) {
+            int row = i / l[k].w;
+            int col = i % l[k].w;
+            for (n = 0; n < l[k].box; ++n) {
+                int obj_index = entry_index_float(l[k], 0, n * l[k].w * l[k].h + i, 4);
+                float objectness = predictions[obj_index];
+                if (objectness > threshold) {
+                    int box_index = entry_index_float(l[k], 0, n * l[k].w * l[k].h + i, 0);
+                    dets[count].bbox = get_yolo_box_float(predictions, l[k].biases, l[k].mask[n], box_index, col, row, l[k].w, l[k].h, netw, neth, l[k].w * l[k].h);
+
+                    dets[count].objectness = objectness;
+                    dets[count].classes = l[k].classes;
+                    // dets[count].prob = (float*)calloc(dets[count].classes, sizeof(float));
+                    for (j = 0; j < l[k].classes; ++j) {
+                        int class_index = entry_index_float(l[k], 0, n * l[k].w * l[k].h + i, 4 + 1 + j);
+                        float prob = objectness * predictions[class_index];
+                        dets[count].prob[j] = (prob > threshold) ? prob : 0;
+                    }
+                    ++count;
+                    if (count > MAX_DET_NUM - 1) {
+                        dets[0].size = count;
+                        return;
+                    }
+                }
+            }
+        }
+    }
+    dets[0].size = count;
+}
+
+static inline float overlap(float x1, float w1, float x2, float w2)
+{
+    float l1 = x1 - w1 / 2;
+    float l2 = x2 - w2 / 2;
+    float left = l1 > l2 ? l1 : l2;
+    float r1 = x1 + w1 / 2;
+    float r2 = x2 + w2 / 2;
+    float right = r1 < r2 ? r1 : r2;
+    return right - left;
+}
+
+static float box_intersection(box a, box b)
+{
+    float w = overlap(a.x, a.w, b.x, b.w);
+    float h = overlap(a.y, a.h, b.y, b.h);
+    if (w < 0 || h < 0) return 0;
+    float area = w * h;
+    return area;
+}
+
+static float box_union(box a, box b)
+{
+    float i = box_intersection(a, b);
+    float u = a.w * a.h + b.w * b.h - i;
+    return u;
+}
+
+boxabs box_c(box a, box b) 
+{
+    boxabs ba = { 0 };
+    
+    ba.top = F_MIN(a.y - a.h / 2, b.y - b.h / 2);
+    ba.bot = F_MAX(a.y + a.h / 2, b.y + b.h / 2);
+    ba.left = F_MIN(a.x - a.w / 2, b.x - b.w / 2);
+    ba.right = F_MAX(a.x + a.w / 2, b.x + b.w / 2);
+
+    return ba;
+}
+
+static float box_iou(box a, box b)
+{
+    float I = box_intersection(a, b);
+    float U = box_union(a, b);
+    if (I == 0 || U == 0) {
+        return 0;
+    }
+    return I / U;
+}
+
+static float box_diou(box a, box b)
+{
+    boxabs ba = box_c(a, b);
+    float w = ba.right - ba.left;
+    float h = ba.bot - ba.top;
+    float c = w * w + h * h;
+    float iou = box_iou(a, b);
+    if (c == 0) {
+        return iou;
+    }
+    float d = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
+    float u = pow(d / c, 0.6);
+    float diou_term = u;
+
+    return iou - diou_term;
+}
+
+static inline int nms_comparator_v3(const void *pa, const void *pb)
+{
+    detection a = *(detection *)pa;
+    detection b = *(detection *)pb;
+    float diff = 0;
+    if (b.sort_class >= 0) {
+        diff = a.prob[b.sort_class] - b.prob[b.sort_class];
+    }
+    else {
+        diff = a.objectness - b.objectness;
+    }
+    if (diff < 0) return 1;
+    else if (diff > 0) return -1;
+    return 0;
+}
+
+void do_nms_sort(detection *dets, int total, int classes, float thresh)
+{
+    int i, j, k;
+    k = total - 1;
+
+    for (i = 0; i <= k; ++i) {
+        if (dets[i].objectness == 0) {
+            detection swap = dets[i];
+            dets[i] = dets[k];
+            dets[k] = swap;
+            --k;
+            --i;
+        }
+    }
+    total = k + 1;
+    for (k = 0; k < classes; ++k) {
+        for (i = 0; i < total; ++i) {
+            dets[i].sort_class = k;
+        }
+        qsort(dets, total, sizeof(detection), nms_comparator_v3);
+        for (i = 0; i < total; ++i) {
+            if (dets[i].prob[k] == 0) continue;
+            box a = dets[i].bbox;
+            for (j = i + 1; j < total; ++j) {
+                box b = dets[j].bbox;
+                if (box_diou(a, b) > thresh) {
+                    dets[j].prob[k] = 0;
+                }
+            }
+        }
+    }
+}
+
+void get_detections(detection *dets, int dets_num, float thresh, int *selected_detections_num)
+{
+    int selected_num = 0;
+    int i, j;
+
+    for (i = 0; i < dets_num; ++i) 
+    {
+        int best_class = -1;
+        float best_class_prob = thresh;
+        for (j = 0; j < dets[i].classes; ++j) 
+        {
+            if (dets[i].prob[j] > best_class_prob) 
+            {
+                best_class = j;
+                best_class_prob = dets[i].prob[j];
+            }
+        }
+        if (best_class >= 0) 
+        {
+            dets[i].sort_class = best_class;
+            dets[i].score = best_class_prob;
+            ++selected_num;
+        }
+    }
+    *selected_detections_num = selected_num;
+}
+
+void get_layers(layer *l, void **buff, int output_num, int yolo_classes)
+{
+	int i = 0;
+
+	for (i = 0; i < output_num; i++) {
+        l[i].w = output_dims[i][0];
+		l[i].h = output_dims[i][1];
+        l[i].c = output_dims[i][2];
+		l[i].output = (uint8_t *)buff[i];
+		l[i].box = YOLO_NUM_BOXES;
+		l[i].classes = yolo_classes;
+		l[i].anchors = (float*)layer_anchors[i];
+		l[i].outputs = l[i].w * l[i].h * l[i].c;
+        l[i].mask = (int *)layer_mask[i];
+        l[i].biases = layer_biases;
+        l[i].scale_xy = (float)SCALE_XY;
+	}
+}
+
+static void get_layers_float(flayer *l, void **buff, int output_num, int yolo_classes)
+{
+	int i = 0;
+
+	for (i = 0; i < output_num; i++) {
+        l[i].w = output_dims[i][0];
+		l[i].h = output_dims[i][1];
+        l[i].c = output_dims[i][2];
+		l[i].output = (float *)buff[i];
+		l[i].box = YOLO_NUM_BOXES;
+		l[i].classes = yolo_classes;
+		l[i].anchors = (float*)layer_anchors[i];
+		l[i].outputs = l[i].w * l[i].h * l[i].c;
+        l[i].mask = (int *)layer_mask[i];
+        l[i].biases = layer_biases;
+        l[i].scale_xy = (float)SCALE_XY;
+	}
+}
+
+void save_yolov4_tiny_result(detection *dets_final, int det_boxes, char *filename)
+{
+	int i = 0;
+	FILE *fp = NULL;
+
+    char output_name[128] = {0};
+    sprintf(output_name, "%s.txt", filename);
+    fp = fopen(output_name, "w");
+    printf("output_name: %s\n", output_name);fflush(stdout);
+	for (i = 0; i < det_boxes; i++) {
+        if (dets_final[i].score != 0)
+        {
+		    fprintf(fp, "%d %f %f %f %f %f\n", \
+				dets_final[i].sort_class, dets_final[i].score, \
+				dets_final[i].bbox.x,     dets_final[i].bbox.y,\
+				dets_final[i].bbox.w,     dets_final[i].bbox.h);
+        }
+	}
+	if (det_boxes == 0) {
+		fprintf(fp, " ");
+	}
+	fclose(fp);
+}
+
+static inline void activate_array(float *x, const int n)
+{
+    int i;
+    for (i = 0; i < n; ++i) {
+        x[i] = logistic_activate(x[i]);
+    }
+}
+
+static inline void scal_add_cpu_float(int N, float ALPHA, float BETA, float *X)
+{
+    int i;
+    for (i = 0; i < N; ++i) X[i] = X[i] * ALPHA + BETA;
+}
+
+void forward_yolo_layer(const flayer *l, int output_num)
+{
+    int n = 0;
+    int b = 0;
+    int k = 0;
+    float scale_x_y = (float)SCALE_XY;
+
+    for (k = 0; k < output_num; k++) {
+        for (n = 0; n < l[k].box; ++n) {
+            int bbox_index = entry_index_float(l[k], b, n*l[k].w*l[k].h, 0);
+            activate_array(l[k].output + bbox_index, 2 * l[k].w*l[k].h);
+            int obj_index = entry_index_float(l[k], b, n*l[k].w*l[k].h, 4);
+            activate_array(l[k].output + obj_index, (1 + l[k].classes)*l[k].w*l[k].h);
+            scal_add_cpu_float(2 * l[k].w*l[k].h, scale_x_y, -0.5*(scale_x_y - 1), l[k].output + bbox_index);
+        }
+    }
+}
+
+int yolo_postprocess(void **input_buffer, int counts, int yolo_classes, detection *dets)
+{
+    int k = 0;
+    int nboxes = 0;
+    int output_num = counts;
+    flayer l[output_num];
+    int selected_detections_num = 0;
+
+    get_layers_float(l, input_buffer, output_num, yolo_classes);
+    if (NULL == dets) {
+        printf("Result is null.\n");
+        return -1;
+    }
+    for (k = 0; k < MAX_DET_NUM; k++) {
+        memset(&dets[k], 0, sizeof(detection));
+        // memset(dets[k].prob, 0, sizeof(float));
+    }
+    forward_yolo_layer(l, output_num);
+    get_yolo_detections_float(l, INPUT_SIZE_W, INPUT_SIZE_H, THRESHOLD, dets);
+    nboxes = dets[0].size;
+    do_nms_sort(dets, nboxes, yolo_classes, NMS);
+    get_detections(dets, nboxes, THRESHOLD, &selected_detections_num);
+
+    return nboxes;
+}
+
+int print_yolov4_tiny_result(void *results, uint16_t nboxes)
+{
+    int k = 0;
+    int status = 0;
+
+    detection *dets = (detection *)results;
+    if (NULL == dets) {
+        printf("yolov4_tiny results is null.\n");
+        return -1;
+    }
+    printf("boxes number: %d\n", nboxes);
+    for (k = 0; k < nboxes; k++) {
+        if (dets[k].score != 0) {
+            printf("%d %f %f %f %f %f\n", dets[k].sort_class, dets[k].score, \
+                    dets[k].bbox.x, dets[k].bbox.y, \
+                    dets[k].bbox.w, dets[k].bbox.h);
+        }
+    }
+
+    return status;
+}
+
--- a/pnna/example/postprocess/yolov4_tiny_post.h
+++ b/pnna/example/postprocess/yolov4_tiny_post.h
@ -0,0 +1,125 @@
+/*
+ * @Author: xun
+ * @Date: 2024-04-11 09:51:01
+ * @LastEditors: xun
+ * @LastEditTime: 2024-07-02 10:46:42
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+#ifndef _YOLOV4_TINY_POST_H_
+#define _YOLOV4_TINY_POST_H_
+
+#define INPUT_SIZE_W 416
+#define INPUT_SIZE_H 416
+#define INPUT_SIZE_C 3
+#define NMS 0.45
+#define THRESHOLD 0.25
+#define SCALE_XY 1.05
+#define OUTPUT_NUM 2
+#define YOLO_NUM_BOXES 3
+#define YOLO_TOTAL_ANCHOR 6
+#define CLASSES_COCO 80
+#define MAX_DET_NUM 100
+
+#define INPUT_SIZE    (INPUT_SIZE_W * INPUT_SIZE_H * INPUT_SIZE_C)
+#define MAX_SIZE      INPUT_SIZE * 4
+#define MAX_DIMS      4
+
+extern float layer_anchors[2][6];
+extern int layer_mask[2][3];
+extern float layer_scales[2];
+extern float layer_biases[12];
+extern int output_dims[2][3];
+
+typedef struct box {
+    float x, y, w, h;
+} box;
+
+typedef struct layer
+{
+    int box, c, h, w;
+    int classes;
+    int outputs;
+    int *mask;
+    float scale_xy;
+    float *anchors;
+    float *biases;
+    uint8_t *output;
+} layer;
+
+typedef struct layer_float
+{
+    int box, c, h, w;
+    int classes;
+    int outputs;
+    int *mask;
+    float scale_xy;
+    float *anchors;
+    float *biases;
+    float *output;
+} flayer;
+
+typedef struct detection {
+    box bbox;
+    int size;
+    int classes;
+    int sort_class;
+    float prob[CLASSES_COCO];
+    float objectness;
+    float score;
+} detection;
+
+
+float r_sigmoid(float y);
+
+float logistic_activate(float x);
+
+float scal_add_cpu(float ALPHA, float BETA, float X);
+
+int entry_index(layer l, int batch, int location, int entry);
+
+void do_nms_sort(detection *dets, int total, int classes, float thresh);
+
+void get_detections(detection *dets, int dets_num, float thresh,\
+                         int *selected_detections_num);
+
+void get_layers(layer *l, void **buff, int output_num, int yolo_classes);
+
+
+/**
+ * @brief 进行YOLO后处理的函数，先将输出tensor全部转为float类型的数据，再进行后处理
+ * 
+ * @param IN  input_buffer 输入缓冲区的地址
+ * @param IN  counts 网络模型输出个数
+ * @param IN  yolo_classes yolo层分类个数
+ * @param OUT dets 检测结果数组
+ * @return int 返回处理后的状态码，0表示成功，-1表示失败
+ */
+int yolo_postprocess(void **input_buffer, int counts, int yolo_classes, detection *dets);
+
+
+/**
+ * @brief 保存 yolov4-tiny 处理后的结果
+ * 
+ * @param IN  dets_final 检查目标
+ * @param IN  det_boxes 目标个数
+ * @param OUT filename 保存文件名
+ * @return 无
+ */
+void save_yolov4_tiny_result(detection *dets_final, int det_boxes, char *filename);
+
+/**
+ * @brief 打印yolov4-tiny后处理结果
+ * 
+ * @param IN  results 结果地址
+ * @param IN  nboxes 目标个数
+ * @return int 返回处理后的状态码，0表示成功，-1表示失败
+ */
+int print_yolov4_tiny_result(void *results, uint16_t nboxes);
+
+    
+#endif // !_YOLOV4_TINY_POST_H_
+
+
+
--- a/pnna/example/resource/dog.jpg
+++ b/pnna/example/resource/dog.jpg
--- a/pnna/example/resource/input_0.dat
+++ b/pnna/example/resource/input_0.dat
--- a/pnna/example/resource/iter_0_input_0_out0_1_3_416_416.tensor
+++ b/pnna/example/resource/iter_0_input_0_out0_1_3_416_416.tensor
--- a/pnna/example/resource/network_binary.nb
+++ b/pnna/example/resource/network_binary.nb
--- a/pnna/example/yolov4_tiny_demo.c
+++ b/pnna/example/yolov4_tiny_demo.c
@ -0,0 +1,460 @@
+/*
+ * @Author: xun
+ * @Date: 2024-04-03 16:02:39
+ * @LastEditors: xun
+ * @LastEditTime: 2024-07-23 14:37:34
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+/*-------------------------------------------
+                Includes
+-------------------------------------------*/
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+
+#include "nn_api.h"
+#include "nn_utils.h"
+#include "quantize.h"
+#include "preprocess.h"
+#include "postprocess/yolov4_tiny_post.h"
+
+/*-------------------------------------------
+        Macros and Variables
+-------------------------------------------*/
+#ifdef LINUX
+
+#define NETWORK_INPUT_TYPE_JPEG       1
+// #define NETWORK_INPUT_TYPE_TENSOR     1
+// #define NETWORK_INPUT_TYPE_BINARY     1
+
+#else
+
+#include <c6x.h>
+#include "M6678V4_PLL.h"
+#include "M6678V4_PSC.h"
+
+#endif
+
+// #define POSTPROCESS_FAST              1
+
+const char *usage =
+    "-n network.nb:     network binary graph (NBG) data file resource.\n"
+    "-i input nunber input_0.dat input_1.dat ...:      nunber: input file number.\n"
+    "                   input file name 1, input file name 2 ... \n"
+    "-l loop_run_count: the number of loop run network.\n"
+    "-t time_out:       specify time out of network.\n"
+    "-h : help   \n"
+    "example: ./test -n network_binary.nb -i 1 416.jpg     \n";
+
+int yolo_postprocess_fast(nn_context *context, void **input_buffer, detection *dets);
+
+/*-------------------------------------------
+                  Main Functions
+-------------------------------------------*/
+int main(int argc, char **argv)
+{
+    int ret = 0;
+    int i = 0, k = 0;
+
+    // 初始化参数
+    char *input_name[4] = { 0 };
+    int input_count = 0;
+    uint32_t loop_count = 1;
+    uint32_t count = 0;
+    uint32_t time_out = 0;
+    nn_context *context = NULL;
+    int yolo_classes = 0;
+
+    //前处理参数
+    void *input_data[MAX_DIMS] = { 0 };
+
+    // 后处理参数
+    int nboxes = 0;
+    void *output_data[MAX_DIMS] = { 0 };
+    detection results[MAX_DET_NUM] = { 0 };
+
+#ifdef LINUX
+    char *nbg_name = NULL;
+    if (argc < 2) {
+        printf("%s\n", usage);
+        return -1;
+    }
+
+    for (i = 0; i < argc; i++) {
+        if (!strcmp(argv[i], "-l")) {
+            loop_count = atoi(argv[++i]);
+        }
+        else if (!strcmp(argv[i], "-n")) {
+            nbg_name = argv[++i];
+        }
+        else if (!strcmp(argv[i], "-t")) {
+            time_out = atoi(argv[++i]);
+        }
+        else if (!strcmp(argv[i], "-i")) {
+            input_count = atoi(argv[++i]);
+            for (k = 0; k < input_count; k++) {
+                input_name[k] = argv[++i];
+            }
+        }
+        else if (!strcmp(argv[i], "-h")) {
+            printf("%s\n", usage);
+            return 0;
+        }
+    }
+    if (NULL == nbg_name) {
+        printf("%s\n", usage);
+        return -1;
+    }
+    for (k = 0; k < input_count; k++) {
+        if (NULL == input_name[k]) {
+            printf("%s\n", usage);
+            return -1;
+        }
+    }
+    printf("test started.\n");
+    printf("loop_count=%d, nbg_name=%s, input_name:%s\n", \
+            loop_count, nbg_name, input_name[0]);
+
+#else
+
+    char *nbg_name = "network_binary.nb";
+    PSC_Open_Clk("VIP", 1);
+    ACC_PLL_Init(80, 1, 0, 0);
+    ACC_VIP_PLL(0);
+    init_timer();
+
+    network_address    = (uint32_t *)0xE0000000;
+    input_dat0_address = (uint32_t *)0xE1000000;
+    input_dat1_address = (uint32_t *)0xE2000000;
+    my_network_size    = 3816092;               
+    my_input_size      = 519168;                
+
+#endif
+
+    // 打开设备
+    ret = pnna_open();
+    if (ret != NN_SUCCESS) {
+        print_msg(errno2str(ret));
+        goto exit;
+    }
+
+    // 初始化网络
+    ret = nn_init(&context, nbg_name, time_out);
+    if (ret != NN_SUCCESS) {
+        print_msg(errno2str(ret));
+        goto exit;
+    }
+
+#ifdef NETWORK_INPUT_TYPE_JPEG
+    void *input_tmp_data[MAX_DIMS] = { 0 };
+    void *input_data_float[MAX_DIMS] = { 0 };
+    normalization_params norm_params;
+    int mean[3] = { 0 };
+    int std[3]  = {255, 255, 255};
+    int reorder_channel[3] = {0, 1, 2};
+    float scale = 1.0f / 255.0f;
+    int width = 416;
+    int height = 416;
+    int channel = 3;
+    int pic_size = width * height * channel;
+    int norm_size = pic_size * sizeof(float);
+    int jpg_temp_size = pic_size * sizeof(uint8_t);
+
+    // 设置输入图片的归一化参数
+    set_normalize_params(&norm_params, width, height, channel, \
+                            mean, std, reorder_channel, scale);
+    ret = create_buffers(input_tmp_data, input_count, &jpg_temp_size);
+    if (ret != NN_SUCCESS) {
+        print_msg(errno2str(ret));
+        goto exit;
+    }
+    ret = create_buffers(input_data_float, input_count, &norm_size);
+    if (ret != NN_SUCCESS) {
+        print_msg(errno2str(ret));
+        goto exit;
+    }
+#elif NETWORK_INPUT_TYPE_TENSOR
+    void *input_data_float[MAX_DIMS] = { 0 };
+    int quant_size = INPUT_SIZE * sizeof(float);
+    ret = create_buffers(input_data_float, input_count, &quant_size);
+    if (ret != NN_SUCCESS) {
+        print_msg(errno2str(ret));
+        goto exit;
+    }
+#endif
+
+#ifdef LINUX
+    // 为进入网络的 buffer 申请空间
+    ret = create_buffers(input_data, input_count, context->input_size);
+    if (ret != NN_SUCCESS) {
+        print_msg(errno2str(ret));
+        goto exit;
+    }
+#endif
+
+#ifndef POSTPROCESS_FAST
+    // yolov4-tiny 快速后处理方法
+    int output_sizes[MAX_DIMS] = { 0 };
+    void *output_data_float[MAX_DIMS] = { 0 };
+    get_output_sizes(context, sizeof(float), output_sizes);
+    ret = create_buffers(output_data_float, context->output_count, output_sizes);
+    if (ret != NN_SUCCESS) {
+        print_msg(errno2str(ret));
+        goto exit;
+    }
+#endif
+
+    // 循环推理
+    while(count < loop_count) {
+        count++;
+        // 准备数据
+    #ifdef NETWORK_INPUT_TYPE_JPEG
+        // 将JPEG图片解码为bmp图片
+        ret = get_jpeg_data(input_name, width, height, channel, input_count, input_tmp_data);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+            goto exit;
+        }
+        // save_u8_to_text("dog_sized-bmp.txt", input_tmp_data[0], INPUT_SIZE);
+        // 归一化处理
+        ret = preprocess(input_tmp_data, &norm_params, input_count, input_data_float);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+            goto exit;
+        }
+        // 量化处理
+        ret = nn_quantize(context, (float **)input_data_float, input_data);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+            goto exit;
+        }
+    #elif NETWORK_INPUT_TYPE_TENSOR
+        ret = get_tensor_data(input_name, input_count, INPUT_SIZE, input_data_float);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+            goto exit;
+        }
+        // 量化处理
+        ret = nn_quantize(context, (float **)input_data_float, input_data);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+            goto exit;
+        }
+    #elif NETWORK_INPUT_TYPE_BINARY
+        ret = get_binary_data(input_name, input_count, INPUT_SIZE, input_data);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+            goto exit;
+        }
+    #endif
+
+    #ifndef LINUX
+        input_data[0] = input_dat0_address;
+    #endif
+
+        // 开始推理
+        printf("start to run network=%s, times=%d\n", context->nbg_name, count);
+        ret = nn_infer(context, (void **)input_data, output_data);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+            goto exit;
+        }
+        printf("run network done...\n");
+
+        // 获取推理时间
+        ret = get_infer_time(context, 1);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+        }
+        float time = (float)context->infer_time / 1000.0f;
+        printf("profile inference time=%fms, cycle=%d\n", time, context->infer_cycle);
+
+        // 后处理
+    #ifdef POSTPROCESS_FAST
+        nboxes = yolo_postprocess_fast(context, output_data, results);
+    #else
+        ret = nn_dequantize(context, output_data, (float **)output_data_float);
+        if (ret != NN_SUCCESS) {
+            print_msg(errno2str(ret));
+        }
+        yolo_classes = get_yolo_classes_from_context(context);
+        nboxes = yolo_postprocess(output_data_float, context->output_count, yolo_classes, results);
+    #endif
+        print_yolov4_tiny_result(results, nboxes);
+    }
+        
+exit:
+#ifndef POSTPROCESS_FAST
+    destroy_buffers(output_data_float, context->output_count);
+#endif
+
+#ifdef LINUX
+    // 释放用户自定义资源
+    destroy_buffers(input_data, input_count);
+#ifdef NETWORK_INPUT_TYPE_JPEG
+    destroy_buffers(input_tmp_data, input_count);
+    destroy_buffers(input_data_float, input_count);
+#elif NETWORK_INPUT_TYPE_TENSOR
+    destroy_buffers(input_data_float, input_count);
+#endif
+#endif
+
+    // 释放网络资源
+    nn_destroy(context);
+    // 关闭设备
+    pnna_close();
+    return 0;
+}
+
+static box get_yolo_box(uint8_t* x, float* biases, uint32_t src_sz, int n, int index, int i, int j, \
+            int lw, int lh, int w, int h, int stride, quantization_params buf_param, float scale_x_y)
+{
+    box b;
+    uint32_t x_index = 0;
+    float xx, yy, ww, hh;
+    int data_format = 0;
+    int quant_format = 0;
+    signed char fixed_point_pos = 0;
+    int zeroPoint = 0;
+    float scale = 0.0f;
+
+    data_format = buf_param.data_format;
+    quant_format = buf_param.quant_format;
+    fixed_point_pos = buf_param.quant_data.dfp.fixed_point_pos;
+    zeroPoint = buf_param.quant_data.affine.zeroPoint;
+    scale = buf_param.quant_data.affine.scale;
+
+    x_index = (index + 0 * stride) * src_sz;
+    dtype_to_float32(&x[x_index], &xx, data_format, quant_format, fixed_point_pos, scale, zeroPoint);
+
+    x_index = (index + 1 * stride) * src_sz;
+    dtype_to_float32(&x[x_index], &yy, data_format, quant_format, fixed_point_pos, scale, zeroPoint);
+
+    x_index = (index + 2 * stride) * src_sz;
+    dtype_to_float32(&x[x_index], &ww, data_format, quant_format, fixed_point_pos, scale, zeroPoint);
+
+    x_index = (index + 3 * stride) * src_sz;
+    dtype_to_float32(&x[x_index], &hh, data_format, quant_format, fixed_point_pos, scale, zeroPoint);
+
+    xx = logistic_activate(xx);
+    yy = logistic_activate(yy);
+    xx = scal_add_cpu(scale_x_y, -0.5*(scale_x_y - 1), xx);
+    yy = scal_add_cpu(scale_x_y, -0.5*(scale_x_y - 1), yy);
+
+    b.x = (i + xx) / lw;
+    b.y = (j + yy) / lh;
+    b.w = exp(ww) * biases[2 * n] / w;
+    b.h = exp(hh) * biases[2 * n + 1] / h;
+
+    return b;
+}
+
+void get_yolo_detections(layer* l, int netw, int neth, float threshold, \
+                            detection *dets, quantization_params *buf_param)
+{
+
+    float x;
+    int i, j, k, n;
+    int count = 0;
+    uint32_t src_sz = 0;
+    x = r_sigmoid(threshold);
+
+    for (k = 0; k < OUTPUT_NUM; ++k)
+    {
+        int data_format = 0;
+        int quant_format = 0;
+        signed char fixed_point_pos = 0;
+        int zeroPoint = 0;
+        float scale = 0.0f;
+        uint8_t thresh_q[4] = { 0 };
+
+        data_format = buf_param[k].data_format;
+        quant_format = buf_param[k].quant_format;
+        fixed_point_pos = buf_param[k].quant_data.dfp.fixed_point_pos;
+        zeroPoint = buf_param[k].quant_data.affine.zeroPoint;
+        scale = buf_param[k].quant_data.affine.scale;
+        
+        float32_to_dtype(x, thresh_q, data_format, quant_format, fixed_point_pos, scale, zeroPoint);
+        uint8_t *predictions = l[k].output;
+        src_sz = get_stride(buf_param[k].data_format);
+        
+        for (i = 0; i < l[k].w * l[k].h; ++i) {
+            int row = i / l[k].w;
+            int col = i % l[k].w;
+            for (n = 0; n < l[k].box; ++n) {
+                int obj_index = entry_index(l[k], 0, n * l[k].w * l[k].h + i, 4);
+                if (compare_values(predictions, thresh_q, obj_index, buf_param[k].data_format)) {
+                    int box_index = entry_index(l[k], 0, n * l[k].w * l[k].h + i, 0);
+                    dets[count].bbox = get_yolo_box(predictions, l[k].biases, src_sz, l[k].mask[n], \
+                                        box_index, col, row, l[k].w, l[k].h, netw, neth,\
+                                        l[k].w * l[k].h, buf_param[k], l[k].scale_xy);
+                    float objectness_fp = 0.0f;
+                    obj_index *= src_sz;
+                    dtype_to_float32(&predictions[obj_index], &objectness_fp, data_format,\
+                                            quant_format, fixed_point_pos, scale, zeroPoint);
+                    dets[count].objectness = logistic_activate(objectness_fp);
+                    dets[count].classes = l[k].classes;
+                    for (j = 0; j < l[k].classes; ++j) {
+                        int class_index = entry_index(l[k], 0, n * l[k].w * l[k].h + i, 4 + 1 + j);
+                        class_index *= src_sz;
+                        float prob_fp = 0.0f;
+                        dtype_to_float32(&predictions[class_index], &prob_fp, data_format, \
+                                            quant_format, fixed_point_pos, scale, zeroPoint);
+                        float prob = 0.0f;
+                        prob = dets[count].objectness * (logistic_activate(prob_fp));
+                        dets[count].prob[j] = (prob > threshold) ? prob : 0;
+                    }
+                    ++count;
+                    if (count > MAX_DET_NUM - 1) {
+                        printf("Out of the max detection number.\n");
+                        dets[0].size = count;
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    dets[0].size = count;
+}
+
+int yolo_postprocess_fast(nn_context *context, void **input_buffer, detection *dets)
+{
+    int i = 0;
+    int nboxes = 0;
+    int counts = 0;
+    int yolo_classes = 0;
+
+    layer l[OUTPUT_NUM];
+    int selected_detections_num = 0;
+    quantization_params param[MAX_DIMS];
+
+    if (NULL == dets) {
+        printf("Result is null.\n");
+        return -1;
+    }
+    for (i = 0; i < MAX_DET_NUM; i++) {
+        memset(&dets[i], 0, sizeof(detection));
+    }
+
+    counts = context->output_count;
+    for (i = 0; i < counts; i++) {
+        get_output_param(context, i, &param[i]);
+    }
+
+    yolo_classes = get_yolo_classes_from_params(&param[0]);
+    get_layers(l, input_buffer, counts, yolo_classes);
+    get_yolo_detections(l, INPUT_SIZE_W, INPUT_SIZE_H, THRESHOLD, dets, param);
+
+    nboxes = dets[0].size;
+
+    do_nms_sort(dets, nboxes, yolo_classes, NMS);
+    get_detections(dets, nboxes, THRESHOLD, &selected_detections_num);
+
+    return nboxes;
+}
--- a/pnna/example/示例程序使用说明.md
+++ b/pnna/example/示例程序使用说明.md
@ -0,0 +1,192 @@
+# 示例程序使用说明
+
+
+## 一、概述
+
+本项目旨在为用户提供一个C 应用程序演示和可调用的函数接口，以便用户可以快速了解和利用其功能。
+
+**主要功能：**
+
+- 提供多个示例应用程序演示，涵盖了项目中各种功能的使用示例。
+- 提供丰富的函数接口，允许用户根据需要自由组合和调用各种功能。
+- 支持用户快速上手和定制化，以满足各种需求和应用场景。
+
+------
+
+
+
+## 二、文件简介
+
+	**example** 目录结构及其主要功能如下所示：
+
+```shell
+example
+    ├── Makefile  /* 用于构建项目的 Makefile 文件，需根据实际情况修改路径 */
+    |
+    ├── include
+    │   ├── nn_api.h      /* 网络推理流程相关函数 */
+    │   ├── nn_utils.h    /* 文件读写和工具相关函数 */
+    │   ├── preprocess.h  /* 前处理相关函数，如归一化操作 */
+    │   └── quantize.h    /* 量化相关函数 */
+    │
+    ├── postprocess
+    │   ├── classification_post.c
+    │   ├── classification_post.h   /* 分类网络相关后处理函数 */
+    │   ├── yolov4_tiny_post.c
+    │   └── yolov4_tiny_post.h   /* yolov4-tiny 相关后处理函数 */
+    |
+    ├── resource
+    │   ├── dog.jpg   /* 待推理 JPEG 格式的数据 */
+    │   ├── input_0.dat    /* 待推理二进制格式的数据 */
+    │   ├── iter_0_input_0_out0_1_3_416_416.tensor    /* 待推理 tensor 格式的数据 */
+    │   └── network_binary.nb    /* 待推理网络模型 */
+    |
+    └── yolov4_tiny_demo.c  /* 网络推理流程示例代码 */
+```
+
+------
+
+
+## 三、推理流程
+
+网络推理流程示例代码如文件：**yolov4_tiny_demo.c**中所示
+
+### 3.1 打开设备
+
+  上电PNNA硬件，初始PNNA硬件和软件环境，达到就绪状态以接受作业。
+
+```C
+/**
+ * @brief 打开 PNNA 设备
+ * 
+ * @return int 处理后的状态码，0表示成功打开设备
+ */
+int pnna_open();
+```
+
+### 3.2 初始化网络
+
+  - 初始化网络模型上下文context
+  - 根据给定的二进制数据（NBG）创建一个网络对象。
+  - 为此网络分配内部内存资源，将所有操作的资源部署到内部内存池
+  - 为该网络分配/生成命令缓冲区，为内部内存分配中的资源修补命令缓冲区。
+  - 配置网络参数，如超时时间。
+  - 如果该功能成功执行，则该网络已准备就绪。
+
+
+```C
+/**
+ * @brief 初始化网络，为context上下文结构体中的变量分配空间
+ * 
+ * @param OUT context 网络推理上下文
+ * @param IN  nbg_name NB文件名
+ * @param IN  time_out 网络推理超时时间
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int nn_init(nn_context **context, const char *nbg_name,\
+                unsigned int time_out);
+```
+
+### 3.3 网络推理
+
+  - 将输入、输出缓冲区附加到网络的指定索引。在运行网络之前，网络的所有输入、输出都需要连接到有效的输入缓冲区。
+  - 启动网络执行，并将该网络的命令缓冲区发送到PNNA硬件。
+  - 此函数可以调用多次。每次调用它时，它都会使用当前附加的输入缓冲区和输出缓冲区进行推理。
+  - 推理完成后，通过映射缓冲区以获取CPU可访问的读写地址。
+
+```C
+/**
+ * @brief 对已经量化后的buffer进行推理
+ * 
+ * @param IN context 网络推理上下文
+ * @param IN  input_buffer 已量化后的buffer
+ * @param OUT output_buffer 存放结果
+ * @return int 处理后的状态码，0表示成功，其他表示失败
+ */
+int nn_infer(nn_context *context, void **input_buffer, void **output_buffer);
+```
+
+### 3.4 释放空间
+
+  释放在网络准备就绪时分配的所有内部内存分配
+
+```C
+/**
+ * @brief 释放初始化上下文时，malloc出的内存空间
+ * 
+ * @param IN context 网络推理上下文
+ */
+int nn_destroy(nn_context *context);
+```
+
+### 3.5 关闭设备
+
+  - 终止PNNA lite驱动程序并关闭PNNA硬件。
+  - pnna_close应在与pnna_open相同的线程中调用。
+  - 此函数应该是应用程序调用的最后一个函数。
+  - pnna_close应与调用的pnna_open配对。
+
+```C
+/**
+ * @brief 关闭 PNNA 设备
+ * 
+ * @return int 处理后的状态码，0表示成功关闭设备
+ */
+int pnna_close();
+```
+
+### 3.6 前、后处理说明
+
+  1. 输入到网络中的数据需要与网络需求相匹配，比如图片的大小、是否需要量化等，如果需求与示例程序不相符，请自行适配。
+  2. 输出的结果为未反量化的数据，示例程序提供了反量化函数接口，请根据不同的网络自行实现不同的后处理，如 TOP5、yolov5、yolov7等。
+
+
+------
+
+
+## 四、编译与运行
+
+### 4.1 arm端工程编译与运行
+
+  详见：" **arm端部署说明.md** "文档
+
+
+### 4.2 DSP端工程编译与运行
+
+  详见：" **DSP端部署说明.md** "文档
+
+
+------
+
+
+## 五、流程解释
+
+### 5.1 应用程序推理流程
+
+1. 应用程序读取待处理数据，根据数据类型进行预处理操作，选择是否需要归一化和量化。
+
+2. 预处理操作完成后将待推理数据和NBG文件交给PNNA核进行推理。
+
+3. 推理完成后将数据进行反量化操作，并根据模型类型进行相应的分类或检测等处理。
+
+4. 最后输出结果。
+
+
+### 5.2 编译、运行流程
+
+1. 在 Ubuntu 操作系统下，通过交叉编译工具链编译推理工程
+
+2. 将 NBG 文件、可执行程序和待推理数据传输至板卡
+
+3. 板卡上主控制器（CPU / DSP）根据可执行程序内容，将 NBG 文件和待处理数据通过驱动加载至 PNNA 核上运行，处理完成后通知主控制器到固定地址取回结果
+
+
+------
+
+
+
+  <div align="center">Please contact us if you have any questions.</div>
+  <div align="center">Author : @xun</div>
+  <div align="center">Copyright (c) 2024 @ccyh</div>
+
+
--- a/pnna/pnna-armhf/arm端部署说明.md
+++ b/pnna/pnna-armhf/arm端部署说明.md
@ -0,0 +1,433 @@
+# arm端PNNA应用部署
+
+
+
+## 一、概述
+
+本项目旨在为用户提供一个C 应用程序演示和可调用的函数接口，以便用户可以快速了解和利用其功能。
+
+**主要功能：**
+
+- 提供多个示例应用程序演示，涵盖了项目中各种功能的使用示例。
+- 提供丰富的函数接口，允许用户根据需要自由组合和调用各种功能。
+- 支持用户快速上手和定制化，以满足各种需求和应用场景。
+
+------
+
+
+
+## 二、环境搭建
+
+### 2.1 准备内容
+
+1. 板卡和操作系统准备：
+   - 已安装操作系统和pnna驱动的板卡
+
+2. 交叉编译环境准备：
+   - 用于交叉编译的虚拟机
+   - 交叉编译器工具链：gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.xz
+
+3. 库文件和头文件准备：
+   - PNNA头文件和库文件： **pnna-driver** 文件夹中内容
+   - 第三方库jpeg头文件和库文件：**third-party** 文件夹中内容
+
+4. 连接与通信准备（自备）：
+   - RS232转USB连接线（驱动自备）
+   - 网线
+   - 串口软件
+   - SSH登录软件
+
+以下内容均以目标板：**FT78E_DSKC_202311V0** 为例
+
+### 2.2 串口连接
+
+1. 将 **RS232转USB连接线** 一端与板卡网口旁边的 **UART_DSP** 接口相连。如果 **RS232转USB连接线** 的一端与板卡的 **UART_DSP** 接口同为9针公口，只需要将 **RS232转USB连接线** 的第2、3脚分别与 **RS232转USB连接线** 的第2、3脚直连即可。
+2. 接上电源适配器，将电源适配器12V输出一端连接至目标板 **VCC12_IN** 。
+3. 将 **RS232转USB连接线** USB一端连接至调试机USB口，查看电脑设备中，该串口设备的通信端口号 **COMx**。打开串口软件，选择通信端口号 **COMx** ，以及波特率：115200，连接至串口。
+4. 打开板卡电源开关 **SW_PWR**，若看到以下内容，请检查板卡是否已经插入NVME硬盘。
+
+    ```shell
+    U-Boot 2019.01-g705e9bff61-dirty (Apr 24 2024 - 11:35:37 +0800)
+
+    SOC: 78E
+        CPU(ARMV7): 2000 MHz
+        ACC: 2000 MHz
+        DSP: 1250 MHz
+    Model: 78E DSK V0
+    DRAM:  /2 Bank Groups/4 Banks/10 Column/17 Row/X16/1 Ranks/ECC/Standard
+    Systemp DRAM Capacity = 8GB, DDR freq = 1600MHZ
+
+    PCIe0: pcie@4500000 Root Complex
+    PCI target speed GEN3
+        Link Not target speed, Retraining!
+        Waiting LinkUp...
+    PCIE-0: Link down
+    Flash: 8 MiB
+    NAND:  512 MiB
+    Net:   eth0: ethernet@4200000
+    Hit any key to stop autoboot:  0
+    Scanning PCI Devices...
+    BusDevFun  VendorId   DeviceId   Device Class       Sub-Class
+    _____________________________________________________________
+    00.00.00   0x7084     0xabcd     Build before PCI Rev2.0 0x00
+    Wrong Image Format for bootm command
+    ERROR: can't get kernel image!
+    78e =>
+    ```
+
+5. 正常启动后能顺利进入文件系统。如下所示：
+
+    ```shell
+    If you do not wish to distribute GPLv3 components please remove
+    the above packages prior to distribution.  This can be done using
+    the opkg remove command.  i.e.:
+        opkg remove <package>
+    Where <package> is the name printed in the list above
+
+    NOTE: If the package is a dependency of another package you
+        will be notified of the dependent packages.  You should
+        use the --force-removal-of-dependent-packages option to
+        also remove the dependent packages as well
+    ***************************************************************
+    ***************************************************************
+    [  OK  ] Started Print notice about GPLv3 packages.
+
+    _____                    _____           _         _
+    |  _  |___ ___ ___ ___   |  _  |___ ___  |_|___ ___| |_
+    |     |  _| .'| . | . |  |   __|  _| . | | | -_|  _|  _|
+    |__|__|_| |__,|_  |___|  |__|  |_| |___|_| |___|___|_|
+                |___|                    |___|
+
+    Arago Project http://arago-project.org 78e-dsk ttyAMA0
+
+    Arago 2019.05 78e-dsk ttyAMA0
+
+    78e-dsk login: root (automatic login)
+
+    root@78e-dsk:~#
+    ```
+
+6. 输入命令：**ifconfig**，查看板卡是否设置了静态IP地址
+
+    ```shell
+    root@78e-dsk:~# ifconfig
+    eth0      Link encap:Ethernet  HWaddr 6C:B3:11:3F:4F:2E
+            inet addr:192.168.23.88  Bcast:192.168.23.255  Mask:255.255.255.0
+            inet6 addr: fe80::6eb3:11ff:fe3f:4f2e/64 Scope:Link
+            UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
+            RX packets:0 errors:0 dropped:0 overruns:0 frame:0
+            TX packets:118 errors:0 dropped:0 overruns:0 carrier:0
+            collisions:0 txqueuelen:1000
+            RX bytes:0 (0.0 B)  TX bytes:5738 (5.6 KiB)
+            Interrupt:31
+
+    lo        Link encap:Local Loopback
+            inet addr:127.0.0.1  Mask:255.0.0.0
+            inet6 addr: ::1/128 Scope:Host
+            UP LOOPBACK RUNNING  MTU:65536  Metric:1
+            RX packets:128 errors:0 dropped:0 overruns:0 frame:0
+            TX packets:128 errors:0 dropped:0 overruns:0 carrier:0
+            collisions:0 txqueuelen:1000
+            RX bytes:11480 (11.2 KiB)  TX bytes:11480 (11.2 KiB)
+
+    root@78e-dsk:~#
+    ```
+
+    如果 eth0 显示没有设置IP地址，需自行设置IP地址，如：
+
+    ```shell
+    root@78e-dsk:~# ifconfig eth0 192.168.23.88 up
+    ```
+
+### 2.3 网口连接
+
+1. 用网线连接板卡和调试机，使板卡和调试机处于同一局域网内。
+2. 打开SSH登录软件
+    - IP地址：通过 **ifconfig** 命令获取，如上一小节内容所示。
+    - 用户名：**root**
+    - 密码：无
+3. 在板卡文件系统上创建工作目录： **~workspace**
+
+
+### 2.4 文件传输
+
+1. 设置虚拟机和板卡的IP地址，确保虚拟机IP地址与板卡IP地址处于同一网段，如：
+  
+  - 虚拟机IP地址：192.168.23.100
+  - 板卡IP地址：  192.168.23.88
+
+2. 利用 **SCP** 命令相互传输文件，假设需要将虚拟机中 **test** 文件传输至板卡的以下所示目录：
+
+    ```shell
+    /home/root/workspace
+    ```
+
+    在虚拟机上的 scp 传输命令如下所示：
+
+    ```shell
+    scp test root@192.168.23.88:/home/root/workspace
+    ```
+
+    如果需要将板卡上的文件传输至虚拟机，则只需要在板卡上运行 scp 命令即可。
+
+    ```shell
+    scp test virtual_machine@192.168.23.133:~/workspace
+    ```
+
+
+### 2.5 板卡设置
+
+1. 输入命令：**lsmod**，查看系统是否已经安装驱动 **pnnacore.ko** 或 **ccyh_pnna_module.ko**
+
+    ```shell
+    root@78e-dsk:~# lsmod
+    Module                  Size  Used by
+    ccyh_pnna_module      192512  0
+    root@78e-dsk:~#
+    ```
+
+    若不存在，需要安装 **pnnacore.ko** ，该文件在安装包中的位置如下：
+
+    ```shell
+    ~/pnna-armhf/pnna-driver/drivers/pnnacore.ko
+    ```
+
+    将 **pnnacore.ko** 传输至板卡，并利用 **insmod** 命令安装：
+
+    ```shell
+    insmod pnnacore.ko
+    ```
+
+2. 查看 **pnna** 库文件是否存在
+
+    ```shell
+    root@78e-dsk:~# ls -l /lib/libPNNA*
+    -rw-r--r--    1 root     root        145124 Apr 26  2024 /lib/libPNNAlite.so
+    -rw-r--r--    1 root     root         39384 Apr 26  2024 /lib/libPNNAuser.so
+    ```
+
+    若不存在，需要将安装包中 **libPNNAlite.so** 和 **libPNNAuser.so** 放至文件系统 **/lib** 文件夹中。
+
+    ```shell
+    ~/pnna-armhf/pnna-driver/drivers/libPNNAlite.so
+    ~/pnna-armhf/pnna-driver/drivers/libPNNAuser.so
+    ```
+
+3. 查看 **pnna** 头文件是否存在
+
+    ```shell
+    root@78e-dsk:~# ls -l /include/pnna_lite*
+    -rw-r--r--    1 root     root         41693 Apr 26  2024 /include/pnna_lite.h
+    -rw-r--r--    1 root     root          8160 Apr 26  2024 /include/pnna_lite_common.h
+    ```
+
+    若不存在，需要将安装包中 **pnna_lite.h** 和 **pnna_lite_common.h** 放至文件系统 **/include** 文件夹中。
+
+    ```shell
+    ~/pnna-armhf/pnna-driver/include/pnna_lite.h
+    ~/pnna-armhf/pnna-driver/include/pnna_lite_common.h
+    ```
+
+
+### 2.6 虚拟机设置
+
+1. 设置IP地址，与板卡处于同一网段下
+
+2. 创建交叉编译器目录，并解压交叉编译器至该目录
+
+    ```shell
+    tar xvf gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.xz
+    ```
+
+    为了方便后续 **Makefile** 调用，笔者此处将解压后的文件夹重命名为 **gcc-arm-8.3**，请酌情修改
+    
+    ```shell
+    mv gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf gcc-arm-8.3
+    ```
+    
+3. 创建驱动文件夹，存放驱动的库文件和头文件，为交叉编译工程做准备
+
+    ```shell
+    mkdir ~/pnna-driver
+    ```
+
+    将安装包中内容拷贝至虚拟机中的 **~/pnna-driver** 文件夹下
+
+    ```shell
+    ~/pnna-armhf/pnna-driver/
+    ```
+
+4. 创建 **JPEG** 文件夹，存放第三方库和头文件，为交叉编译工程做准备
+
+    ```shell
+    mkdir ~/third-party/jpeg-9b
+    ```
+
+    将安装包中内容拷贝至虚拟机中的 **~/third-party/jpeg-9b** 文件夹下
+
+    ```shell
+    ~/pnna-armhf/third-party/
+    ```
+
+
+------
+
+
+
+## 三、文件简介
+
+	**example** 目录结构及其主要功能，详见 example 下 ***.md** 文件
+
+
+------
+
+
+
+## 四、编译工程
+
+1. 设置 **Makefile** 编译器工具链路径：**TOOLCHAIN_DIR**
+
+2. 设置 **Makefile** 文件中 **pnna** 驱动和 **JPEG** 的路径：**DRIVER_DIR**、**JPEG_DIR**
+
+    ```makefile
+    BIN=test
+
+    TOOLCHAIN_DIR=~/gcc-arm-8.3  #交叉编译器路径
+    DRIVER_DIR=~/pnna-driver     # pnna 头文件和库文件路径
+    JPEG_DIR=~/third-party/jpeg-9b  #第三方库 jpeg 头文件和库文件路径
+
+    CC=$(TOOLCHAIN_DIR)/bin/arm-linux-gnueabihf-gcc
+
+    INCLUDES = -I. -I$(DRIVER_DIR)/include -I$(JPEG_DIR)/include -I./inc
+
+    CFLAGS=-Wall $(INCLUDES)  -D__linux__ -DLINUX
+
+    LIBS=-lm
+    LIBS+= $(DRIVER_DIR)/lib/libpnna.a $(JPEG_DIR)/lib/libjpeg.a
+    LIBS+= -L$(DRIVER_DIR)/drivers -lPNNAlite -lPNNAuser
+
+    ...
+    ```
+
+
+3. 执行 make 命令生成可执行程序 test
+
+    ```shell
+    xun@xun-virtual-machine:~/tftp/03N/rootfs/home/root/project/example$ make
+    mkdir -p obj obj/postprocess obj/preprocess
+    /home/xun/gcc-arm/gcc-arm-8.3/bin/arm-linux-gnueabihf-gcc -Wall -I. -I/home/xun/03n/sdk_dir/include -I/home/xun/03n/third-party/jpeg-9b/include -I./inc  -D__linux__ -DLINUX   obj/yolov4_tiny_demo.o obj/postprocess/yolov4_tiny_post.o obj/postprocess/classification_post.o -lm /home/xun/03n/sdk_dir/lib/libpnna.a /home/xun/03n/third-party/jpeg-9b/lib/libjpeg.a -L/home/xun/03n/sdk_dir/drivers -lPNNAlite -lPNNAuser -o test
+    xun@xun-virtual-machine:~/tftp/03N/rootfs/home/root/project/example$ 
+    ```
+
+    无报错信息且成功生成可执行程序 **test**，则表示编译成功。
+
+------
+
+
+
+## 五、程序运行
+
+1. 将上一步上次的可执行程序 test 放到目标板上。
+2. 运行可执行程序 test，其中 test 需要带的参数信息如下所示：
+
+    ```c
+    const char *usage =
+        "vpm_run_dma_test -s sample.txt -l loop_run_count \n"
+        "-n network.nb:     network binary graph (NBG) data file resource.\n"
+        "-i input nunber input_0.dat input_1.dat ...:      nunber: input file number.\n"
+        "                   input file name 1, input file name 2 ... \n"
+        "-l loop_run_count: the number of loop run network.\n"
+        "-t time_out:       specify time out of network.\n"
+        "-h : help\n"
+        "example: ./test -n network.nb -i 1 416.jpg        \n";
+    ```
+
+3. 执行命令及结果如下所示
+
+    ```shell
+    [root@busybox example]# ./test -n ./resource/yolov4-tiny-u8.nb -i 1 ./resource/416.jpg
+    test started.
+    loop_count=1, nbg_name=./resource/yolov4-tiny-u8.nb, input_name:./resource/416.jpg
+    init pnna lite, driver version=0x00010b00...
+    cid=0xb1, device_count=1
+    device[0] core_count=1
+    input 0 dim 416 416 3 1, data_format=2, quant_format=2, name=input[0], scale=0.003922, zero_point=0
+    ouput 0 dim 13 13 255 1, data_format=2, name=uid_64_out_0, scale=0.104158, zero_point=196
+    ouput 1 dim 26 26 255 1, data_format=2, name=uid_75_out_0, scale=0.100667, zero_point=202
+    memory pool size=2796800byte
+    network core count=1
+    start to run network=./resource/yolov4-tiny-u8.nb, times=1
+    run network done...
+    profile inference time=6.179000ms, cycle=6035099
+    boxes number: 11
+    16 0.775027 0.295617 0.662139 0.263494 0.500338
+    7 0.837144 0.754579 0.211624 0.327769 0.160048
+    2 0.421982 0.755919 0.215550 0.291252 0.178238
+    1 0.343852 0.429336 0.506259 0.745126 0.766827
+    Destroy resource network items.
+    [root@busybox example]#
+    ```
+
+      其中：
+
+   - “-n” 后面接的参数为 NBG 文件
+  
+   - “-i” 后面接的参数为输入文件，可以是 JPG、二进制或者是 tensor 中的一种
+   
+   - “-l” 后面接的参数为循环推理次数，同一个 NBG文 件和输入文件循环推理。默认为1次。
+   
+   - “-t” 后面接的参数为超时时间，可不设置。
+
+
+
+4. 推理结果分别表示：目标类别、分数、中心点坐标x、中心点坐标y、框的宽、框的高
+
+    ```shell
+    16 0.775027 0.295617 0.662139 0.263494 0.500338
+    7 0.837144 0.754579 0.211624 0.327769 0.160048
+    2 0.421982 0.755919 0.215550 0.291252 0.178238
+    1 0.343852 0.429336 0.506259 0.745126 0.766827
+    ```
+
+    ***请注意：程序中定义了只能推理 JPG、二进制或者是 tensor 中的一种。默认为推理 JPG 图片。如需推理其他类型数据，如二进制或者是 tensor ，请修改主函数中的宏定义后，重新编译工程。***
+
+    ```c
+    #define NETWORK_INPUT_TYPE_JPEG       1
+    // #define NETWORK_INPUT_TYPE_BINARY     1
+    // #define NETWORK_INPUT_TYPE_TENSOR     1
+    ```
+
+------
+
+
+## 六、流程解释
+
+### 6.1 应用程序推理流程
+
+1. 应用程序读取待处理数据，根据数据类型进行预处理操作，选择是否需要归一化和量化。
+
+2. 预处理操作完成后将待推理数据和NBG文件交给PNNA核进行推理。
+
+3. 推理完成后将数据进行反量化操作，并根据模型类型进行相应的分类或检测等处理。
+
+4. 最后输出结果。
+
+
+### 6.2 编译、运行流程
+
+1. 在 Ubuntu 操作系统下，通过交叉编译工具链编译推理工程
+
+2. 将 NBG 文件、可执行程序和待推理数据传输至板卡
+
+3. 板卡上主控制器（CPU / DSP）根据可执行程序内容，将 NBG 文件和待处理数据通过驱动加载至 PNNA 核上运行，处理完成后通知主控制器到固定地址取回结果
+
+
+------
+
+
+
+  <div align="center">Please contact us if you have any questions.</div>
+  <div align="center">Author : @xun</div>
+  <div align="center">Copyright (c) 2024 @ccyh</div>
+
+
--- a/pnna/pnna-armhf/gcc-arm-8.3/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.xz
+++ b/pnna/pnna-armhf/gcc-arm-8.3/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.xz
--- a/pnna/pnna-armhf/pnna-driver/drivers/libPNNAlite.so
+++ b/pnna/pnna-armhf/pnna-driver/drivers/libPNNAlite.so
--- a/pnna/pnna-armhf/pnna-driver/drivers/libPNNAuser.so
+++ b/pnna/pnna-armhf/pnna-driver/drivers/libPNNAuser.so
--- a/pnna/pnna-armhf/pnna-driver/drivers/pnnacore.ko
+++ b/pnna/pnna-armhf/pnna-driver/drivers/pnnacore.ko
--- a/pnna/pnna-armhf/pnna-driver/include/pnna_lite.h
+++ b/pnna/pnna-armhf/pnna-driver/include/pnna_lite.h
--- a/pnna/pnna-armhf/pnna-driver/include/pnna_lite_common.h
+++ b/pnna/pnna-armhf/pnna-driver/include/pnna_lite_common.h
@ -0,0 +1,240 @@
+/****************************************************************************
+*
+*    The MIT License (MIT)
+*
+*    Copyright (c) 2017 - 2023 GWG Corporation
+*
+*    Permission is hereby granted, free of charge, to any person obtaining a
+*    copy of this software and associated documentation files (the "Software"),
+*    to deal in the Software without restriction, including without limitation
+*    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+*    and/or sell copies of the Software, and to permit persons to whom the
+*    Software is furnished to do so, subject to the following conditions:
+*
+*    The above copyright notice and this permission notice shall be included in
+*    all copies or substantial portions of the Software.
+*
+*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+*    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+*    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+*    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+*    DEALINGS IN THE SOFTWARE.
+*
+*****************************************************************************
+*
+*    The GPL License (GPL)
+*
+*    Copyright (C) 2017 - 2023 GWG Corporation
+*
+*    This program is free software; you can redistribute it and/or
+*    modify it under the terms of the GNU General Public License
+*    as published by the Free Software Foundation; either version 2
+*    of the License, or (at your option) any later version.
+*
+*    This program is distributed in the hope that it will be useful,
+*    but WITHOUT ANY WARRANTY; without even the implied warranty of
+*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*    GNU General Public License for more details.
+*
+*    You should have received a copy of the GNU General Public License
+*    along with this program; if not, write to the Free Software Foundation,
+*    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*
+*****************************************************************************
+*
+*    Note: This software is released under dual MIT and GPL licenses. A
+*    recipient may use this file under the terms of either the MIT license or
+*    GPL License. If you wish to use only one license not the other, you can
+*    indicate your decision by deleting one of the above license notices in your
+*    version of this file.
+*
+*****************************************************************************/
+
+#ifndef _PNNA_LITE_COMMON_H
+#define _PNNA_LITE_COMMON_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*!
+ *\brief The PNNA lite API for Convolution Neural Network application on CPU/MCU/DSP type of embedded environment.
+ *\details This PNNA lite APIs is not thread-safe if vpmdENABLE_MULTIPLE_TASK is set to 0,
+           user must guarantee to call these APIs in a proper way.
+           But defines vpmdENABLE_MULTIPLE_TASK 1, PNNALite can support multiple task(multiple thread/process).
+           and it's thread-safe.
+ *Memory allocation and file io functions used inside driver internal would depend on working enviroment.
+ *\defgroup group_global Data Type Definitions and Global APIs
+ *\brief Data type definition and global APIs that are used in the PNNA lite
+ *\defgroup group_buffer Buffer API
+ *\brief The API to manage input/output buffers
+ *\defgroup group_network  Network API
+ *\brief The API to manage networks
+ */
+
+/*! \brief An 8-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned char       pnna_uint8_t;
+
+/*! \brief An 16-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned short      pnna_uint16_t;
+
+/*! \brief An 32-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned int        pnna_uint32_t;
+
+/*! \brief An 64-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned long long  pnna_uint64_t;
+
+/*! \brief An 8-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed char         pnna_int8_t;
+
+/*! \brief An 16-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed short        pnna_int16_t;
+
+/*! \brief An 32-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed int          pnna_int32_t;
+
+/*! \brief An 64-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed long long    pnna_int64_t;
+
+/*! \brief An 8 bit ASCII character.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef char                pnna_char_t;
+
+/*! \brief An 32 bit float value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef float               pnna_float_t;
+
+/*! \brief Sets the standard enumeration type size to be a fixed quantity.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef pnna_int32_t         pnna_enum;
+
+/*! \brief a void pointer.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef void*               pnna_ptr;
+
+/*! \brief A 64-bit float value (aka double).
+ * \ingroup group_basic_features
+ */
+typedef double              pnna_float64_t;
+
+/*! \brief address type.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned long long  pnna_address_t;
+
+/*! \brief A zero value for pointer
+ *\ingroup group_global
+ *\version 1.0
+ */
+#ifndef PNNA_NULL
+#define PNNA_NULL 0
+#endif
+
+/***** Helper Macros. *****/
+#define PNNA_API
+
+#define IN
+#define OUT
+
+/*! \brief A invalid value if a property is not avaialbe for the query.
+ *\ingroup group_global
+ *\version 1.0
+ */
+#define PNNA_INVALID_VALUE       ~0UL
+
+/*! \brief  A Boolean value.
+ *\details  This allows 0 to be FALSE, as it is in C, and any non-zero to be TRUE.
+ *\ingroup group_global
+ *\version 1.0
+ */
+typedef enum _pnna_bool_e {
+    /*! \brief The "false" value. */
+    pnna_false_e = 0,
+    /*! \brief The "true" value. */
+    pnna_true_e,
+} pnna_bool_e;
+
+/*! \brief The enumeration of all status codes.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef enum _pnna_status
+{
+    /*!< \brief Indicates a FUSA error occurs */
+    PNNA_ERROR_FUSA                  = -17,
+    /*!< \brief Indicates the network hit Not A Number or Infinite error */
+    PNNA_ERROR_NAN_INF               = -16,
+    /*!< \brief Indicates the network is canceld */
+    PNNA_ERROR_CANCELED              = -15,
+    /*!< \brief Indicates the hardware is recovery done after hang */
+    PNNA_ERROR_RECOVERY              = -14,
+    /*!< \brief Indicates the hardware is stoed */
+    PNNA_ERROR_POWER_STOP            = -13,
+    /*!< \brief Indicates the hardware is in power off status */
+    PNNA_ERROR_POWER_OFF             = -12,
+    /*!< \brief Indicates the failure */
+    PNNA_ERROR_FAILURE               = -11,
+    /*!< \brief Indicates the binary is not compatible with the current runtime hardware */
+    PNNA_ERROR_NETWORK_INCOMPATIBLE  = -10,
+    /*!< \brief Indicates the network is not prepared so current function call can't go through */
+    PNNA_ERROR_NETWORK_NOT_PREPARED  = -9,
+    /*!< \brief Indicates the network misses either input or output when running the network */
+    PNNA_ERROR_MISSING_INPUT_OUTPUT  = -8,
+    /*!< \brief Indicates the network binary is invalid */
+    PNNA_ERROR_INVALID_NETWORK       = -7,
+    /*!< \brief Indicates driver is running out of memory of video memory */
+    PNNA_ERROR_OUT_OF_MEMORY         = -6,
+    /*!< \brief Indicates there is no enough resource */
+    PNNA_ERROR_OUT_OF_RESOURCE       = -5,
+    /*!< \brief Indicates it's supported by driver implementation */
+    PNNA_ERROR_NOT_SUPPORTED         = -4,
+    /*!< \brief Indicates some arguments are not valid */
+    PNNA_ERROR_INVALID_ARGUMENTS     = -3,
+    /*!< \brief Indicates there are some IO related error */
+    PNNA_ERROR_IO                    = -2,
+    /*!< \brief Indicates PNNA timeout, could be PNNA stuck somewhere */
+    PNNA_ERROR_TIMEOUT               = -1,
+    /*!< \brief Indicates the execution is successfuly */
+    PNNA_SUCCESS                     =  0,
+} pnna_status_e;
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
--- a/pnna/pnna-armhf/pnna-driver/lib/libpnna.a
+++ b/pnna/pnna-armhf/pnna-driver/lib/libpnna.a
--- a/pnna/pnna-armhf/third-party/image/include/image.h
+++ b/pnna/pnna-armhf/third-party/image/include/image.h
@ -0,0 +1,32 @@
+/*
+ * @Author: xun
+ * @Date: 2024-07-22 15:54:49
+ * @LastEditors: xun
+ * @LastEditTime: 2024-07-22 15:59:45
+ * @Description: 
+ * Copyright (c) 2024 by CCYH, All Rights Reserved. 
+ */
+
+#ifndef _IMAGE_H_
+#define _IMAGE_H_
+
+#include <stdio.h>
+
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+stbi_uc *stbi_load_from_memory   (stbi_uc const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+const char *stbi_failure_reason(void);
+
+#ifndef STBI_NO_GIF
+stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#endif // !_IMAGE_H_
--- a/pnna/pnna-armhf/third-party/image/lib/libimage.a
+++ b/pnna/pnna-armhf/third-party/image/lib/libimage.a
--- a/pnna/pnna-armhf/third-party/jpeg/include/cderror.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/cderror.h
@ -0,0 +1,134 @@
+/*
+ * cderror.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 2009 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the cjpeg/djpeg
+ * applications.  These strings are not needed as part of the JPEG library
+ * proper.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE.  To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef CDERROR_H
+#define CDERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* CDERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string)    code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_FIRSTADDONCODE=1000, NULL) /* Must be first entry! */
+
+#ifdef BMP_SUPPORTED
+JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format")
+JMESSAGE(JERR_BMP_BADDEPTH, "Only 8- and 24-bit BMP files are supported")
+JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length")
+JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1")
+JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB")
+JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported")
+JMESSAGE(JERR_BMP_EMPTY, "Empty BMP image")
+JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM")
+JMESSAGE(JTRC_BMP, "%ux%u 24-bit BMP image")
+JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image")
+JMESSAGE(JTRC_BMP_OS2, "%ux%u 24-bit OS2 BMP image")
+JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image")
+#endif /* BMP_SUPPORTED */
+
+#ifdef GIF_SUPPORTED
+JMESSAGE(JERR_GIF_BUG, "GIF output got confused")
+JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d")
+JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB")
+JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file")
+JMESSAGE(JERR_GIF_NOT, "Not a GIF file")
+JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image")
+JMESSAGE(JTRC_GIF_BADVERSION,
+     "Warning: unexpected GIF version number '%c%c%c'")
+JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x")
+JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input")
+JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file")
+JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring")
+JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image")
+JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits")
+#endif /* GIF_SUPPORTED */
+
+#ifdef PPM_SUPPORTED
+JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB")
+JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file")
+JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file")
+JMESSAGE(JTRC_PGM, "%ux%u PGM image")
+JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image")
+JMESSAGE(JTRC_PPM, "%ux%u PPM image")
+JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image")
+#endif /* PPM_SUPPORTED */
+
+#ifdef RLE_SUPPORTED
+JMESSAGE(JERR_RLE_BADERROR, "Bogus error code from RLE library")
+JMESSAGE(JERR_RLE_COLORSPACE, "RLE output must be grayscale or RGB")
+JMESSAGE(JERR_RLE_DIMENSIONS, "Image dimensions (%ux%u) too large for RLE")
+JMESSAGE(JERR_RLE_EMPTY, "Empty RLE file")
+JMESSAGE(JERR_RLE_EOF, "Premature EOF in RLE header")
+JMESSAGE(JERR_RLE_MEM, "Insufficient memory for RLE header")
+JMESSAGE(JERR_RLE_NOT, "Not an RLE file")
+JMESSAGE(JERR_RLE_TOOMANYCHANNELS, "Cannot handle %d output channels for RLE")
+JMESSAGE(JERR_RLE_UNSUPPORTED, "Cannot handle this RLE setup")
+JMESSAGE(JTRC_RLE, "%ux%u full-color RLE file")
+JMESSAGE(JTRC_RLE_FULLMAP, "%ux%u full-color RLE file with map of length %d")
+JMESSAGE(JTRC_RLE_GRAY, "%ux%u grayscale RLE file")
+JMESSAGE(JTRC_RLE_MAPGRAY, "%ux%u grayscale RLE file with map of length %d")
+JMESSAGE(JTRC_RLE_MAPPED, "%ux%u colormapped RLE file with map of length %d")
+#endif /* RLE_SUPPORTED */
+
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format")
+JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file")
+JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB")
+JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image")
+JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image")
+JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image")
+#else
+JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled")
+#endif /* TARGA_SUPPORTED */
+
+JMESSAGE(JERR_BAD_CMAP_FILE,
+     "Color map file is invalid or of unsupported format")
+JMESSAGE(JERR_TOO_MANY_COLORS,
+     "Output file format cannot handle %d colormap entries")
+JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed")
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_UNKNOWN_FORMAT,
+     "Unrecognized input file format --- perhaps you need -targa")
+#else
+JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format")
+#endif
+JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format")
+
+#ifdef JMAKE_ENUM_LIST
+
+  JMSG_LASTADDONCODE
+} ADDON_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
--- a/pnna/pnna-armhf/third-party/jpeg/include/cdjpeg.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/cdjpeg.h
@ -0,0 +1,187 @@
+/*
+ * cdjpeg.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains common declarations for the sample applications
+ * cjpeg and djpeg.  It is NOT used by the core JPEG library.
+ */
+
+#define JPEG_CJPEG_DJPEG    /* define proper options in jconfig.h */
+#define JPEG_INTERNAL_OPTIONS    /* cjpeg.c,djpeg.c need to see xxx_SUPPORTED */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"        /* get library error codes too */
+#include "cderror.h"        /* get application-specific error codes */
+
+
+/*
+ * Object interface for cjpeg's source file decoding modules
+ */
+
+typedef struct cjpeg_source_struct * cjpeg_source_ptr;
+
+struct cjpeg_source_struct {
+  JMETHOD(void, start_input, (j_compress_ptr cinfo,
+                  cjpeg_source_ptr sinfo));
+  JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo,
+                       cjpeg_source_ptr sinfo));
+  JMETHOD(void, finish_input, (j_compress_ptr cinfo,
+                   cjpeg_source_ptr sinfo));
+
+  FILE *input_file;
+
+  JSAMPARRAY buffer;
+  JDIMENSION buffer_height;
+};
+
+
+/*
+ * Object interface for djpeg's output file encoding modules
+ */
+
+typedef struct djpeg_dest_struct * djpeg_dest_ptr;
+
+struct djpeg_dest_struct {
+  /* start_output is called after jpeg_start_decompress finishes.
+   * The color map will be ready at this time, if one is needed.
+   */
+  JMETHOD(void, start_output, (j_decompress_ptr cinfo,
+                   djpeg_dest_ptr dinfo));
+  /* Emit the specified number of pixel rows from the buffer. */
+  JMETHOD(void, put_pixel_rows, (j_decompress_ptr cinfo,
+                 djpeg_dest_ptr dinfo,
+                 JDIMENSION rows_supplied));
+  /* Finish up at the end of the image. */
+  JMETHOD(void, finish_output, (j_decompress_ptr cinfo,
+                djpeg_dest_ptr dinfo));
+
+  /* Target file spec; filled in by djpeg.c after object is created. */
+  FILE * output_file;
+
+  /* Output pixel-row buffer.  Created by module init or start_output.
+   * Width is cinfo->output_width * cinfo->output_components;
+   * height is buffer_height.
+   */
+  JSAMPARRAY buffer;
+  JDIMENSION buffer_height;
+};
+
+
+/*
+ * cjpeg/djpeg may need to perform extra passes to convert to or from
+ * the source/destination file format.  The JPEG library does not know
+ * about these passes, but we'd like them to be counted by the progress
+ * monitor.  We use an expanded progress monitor object to hold the
+ * additional pass count.
+ */
+
+struct cdjpeg_progress_mgr {
+  struct jpeg_progress_mgr pub;    /* fields known to JPEG library */
+  int completed_extra_passes;    /* extra passes completed */
+  int total_extra_passes;    /* total extra */
+  /* last printed percentage stored here to avoid multiple printouts */
+  int percent_done;
+};
+
+typedef struct cdjpeg_progress_mgr * cd_progress_ptr;
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jinit_read_bmp        jIRdBMP
+#define jinit_write_bmp        jIWrBMP
+#define jinit_read_gif        jIRdGIF
+#define jinit_write_gif        jIWrGIF
+#define jinit_read_ppm        jIRdPPM
+#define jinit_write_ppm        jIWrPPM
+#define jinit_read_rle        jIRdRLE
+#define jinit_write_rle        jIWrRLE
+#define jinit_read_targa    jIRdTarga
+#define jinit_write_targa    jIWrTarga
+#define read_quant_tables    RdQTables
+#define read_scan_script    RdScnScript
+#define set_quality_ratings     SetQRates
+#define set_quant_slots        SetQSlots
+#define set_sample_factors    SetSFacts
+#define read_color_map        RdCMap
+#define enable_signal_catcher    EnSigCatcher
+#define start_progress_monitor    StProgMon
+#define end_progress_monitor    EnProgMon
+#define read_stdin        RdStdin
+#define write_stdout        WrStdout
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Module selection routines for I/O modules. */
+
+EXTERN(cjpeg_source_ptr) jinit_read_bmp JPP((j_compress_ptr cinfo));
+EXTERN(djpeg_dest_ptr) jinit_write_bmp JPP((j_decompress_ptr cinfo,
+                        boolean is_os2));
+EXTERN(cjpeg_source_ptr) jinit_read_gif JPP((j_compress_ptr cinfo));
+EXTERN(djpeg_dest_ptr) jinit_write_gif JPP((j_decompress_ptr cinfo));
+EXTERN(cjpeg_source_ptr) jinit_read_ppm JPP((j_compress_ptr cinfo));
+EXTERN(djpeg_dest_ptr) jinit_write_ppm JPP((j_decompress_ptr cinfo));
+EXTERN(cjpeg_source_ptr) jinit_read_rle JPP((j_compress_ptr cinfo));
+EXTERN(djpeg_dest_ptr) jinit_write_rle JPP((j_decompress_ptr cinfo));
+EXTERN(cjpeg_source_ptr) jinit_read_targa JPP((j_compress_ptr cinfo));
+EXTERN(djpeg_dest_ptr) jinit_write_targa JPP((j_decompress_ptr cinfo));
+
+/* cjpeg support routines (in rdswitch.c) */
+
+EXTERN(boolean) read_quant_tables JPP((j_compress_ptr cinfo, char * filename,
+                       boolean force_baseline));
+EXTERN(boolean) read_scan_script JPP((j_compress_ptr cinfo, char * filename));
+EXTERN(boolean) set_quality_ratings JPP((j_compress_ptr cinfo, char *arg,
+                     boolean force_baseline));
+EXTERN(boolean) set_quant_slots JPP((j_compress_ptr cinfo, char *arg));
+EXTERN(boolean) set_sample_factors JPP((j_compress_ptr cinfo, char *arg));
+
+/* djpeg support routines (in rdcolmap.c) */
+
+EXTERN(void) read_color_map JPP((j_decompress_ptr cinfo, FILE * infile));
+
+/* common support routines (in cdjpeg.c) */
+
+EXTERN(void) enable_signal_catcher JPP((j_common_ptr cinfo));
+EXTERN(void) start_progress_monitor JPP((j_common_ptr cinfo,
+                     cd_progress_ptr progress));
+EXTERN(void) end_progress_monitor JPP((j_common_ptr cinfo));
+EXTERN(boolean) keymatch JPP((char * arg, const char * keyword, int minchars));
+EXTERN(FILE *) read_stdin JPP((void));
+EXTERN(FILE *) write_stdout JPP((void));
+
+/* miscellaneous useful macros */
+
+#ifdef DONT_USE_B_MODE        /* define mode parameters for fopen() */
+#define READ_BINARY    "r"
+#define WRITE_BINARY    "w"
+#else
+#ifdef VMS            /* VMS is very nonstandard */
+#define READ_BINARY    "rb", "ctx=stm"
+#define WRITE_BINARY    "wb", "ctx=stm"
+#else                /* standard ANSI-compliant case */
+#define READ_BINARY    "rb"
+#define WRITE_BINARY    "wb"
+#endif
+#endif
+
+#ifndef EXIT_FAILURE        /* define exit() codes if not provided */
+#define EXIT_FAILURE  1
+#endif
+#ifndef EXIT_SUCCESS
+#ifdef VMS
+#define EXIT_SUCCESS  1        /* VMS is very nonstandard */
+#else
+#define EXIT_SUCCESS  0
+#endif
+#endif
+#ifndef EXIT_WARNING
+#ifdef VMS
+#define EXIT_WARNING  1        /* VMS is very nonstandard */
+#else
+#define EXIT_WARNING  2
+#endif
+#endif
--- a/pnna/pnna-armhf/third-party/jpeg/include/jconfig.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jconfig.h
@ -0,0 +1,137 @@
+#define HAVE_PROTOTYPES
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+
+/* Define this if an ordinary "char" type is unsigned.
+ * If you're not sure, leaving it undefined will work at some cost in speed.
+ * If you defined HAVE_UNSIGNED_CHAR then the speed difference is minimal.
+ */
+#undef CHAR_IS_UNSIGNED
+
+#if defined __MINGW__ || defined __MINGW32__ || (!defined WIN32 && !defined _WIN32)
+/* Define this if your system has an ANSI-conforming <stddef.h> file.
+ */
+#define HAVE_STDDEF_H
+
+/* Define this if your system has an ANSI-conforming <stdlib.h> file.
+ */
+#define HAVE_STDLIB_H
+#endif
+
+/* Define this if your system does not have an ANSI/SysV <string.h>,
+ * but does have a BSD-style <strings.h>.
+ */
+#undef NEED_BSD_STRINGS
+
+/* Define this if your system does not provide typedef size_t in any of the
+ * ANSI-standard places (stddef.h, stdlib.h, or stdio.h), but places it in
+ * <sys/types.h> instead.
+ */
+#undef NEED_SYS_TYPES_H
+
+/* For 80x86 machines, you need to define NEED_FAR_POINTERS,
+ * unless you are using a large-data memory model or 80386 flat-memory mode.
+ * On less brain-damaged CPUs this symbol must not be defined.
+ * (Defining this symbol causes large data structures to be referenced through
+ * "far" pointers and to be allocated with a special version of malloc.)
+ */
+#undef NEED_FAR_POINTERS
+
+/* Define this if your linker needs global names to be unique in less
+ * than the first 15 characters.
+ */
+#undef NEED_SHORT_EXTERNAL_NAMES
+
+/* Although a real ANSI C compiler can deal perfectly well with pointers to
+ * unspecified structures (see "incomplete types" in the spec), a few pre-ANSI
+ * and pseudo-ANSI compilers get confused.  To keep one of these bozos happy,
+ * define INCOMPLETE_TYPES_BROKEN.  This is not recommended unless you
+ * actually get "missing structure definition" warnings or errors while
+ * compiling the JPEG code.
+ */
+#undef INCOMPLETE_TYPES_BROKEN
+
+/* Define "boolean" as unsigned char, not int, on Windows systems.
+ */
+#ifdef _WIN32
+#ifndef __RPCNDR_H__        /* don't conflict if rpcndr.h already read */
+typedef unsigned char boolean;
+#endif
+#define HAVE_BOOLEAN        /* prevent jmorecfg.h from redefining it */
+#endif
+
+
+/*
+ * The following options affect code selection within the JPEG library,
+ * but they don't need to be visible to applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+
+/* Define this if your compiler implements ">>" on signed values as a logical
+ * (unsigned) shift; leave it undefined if ">>" is a signed (arithmetic) shift,
+ * which is the normal and rational definition.
+ */
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+/* These are for configuring the JPEG memory manager. */
+#define DEFAULT_MAX_MEM 1073741824 /*1Gb*/
+
+#if !defined WIN32 && !defined _WIN32
+#define INLINE __inline__
+#undef NO_MKTEMP
+#endif
+
+#endif /* JPEG_INTERNALS */
+
+#define JDCT_DEFAULT  JDCT_FLOAT
+
+/*
+ * The remaining options do not affect the JPEG library proper,
+ * but only the sample applications cjpeg/djpeg (see cjpeg.c, djpeg.c).
+ * Other applications can ignore these.
+ */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+/* These defines indicate which image (non-JPEG) file formats are allowed. */
+
+#define BMP_SUPPORTED        /* BMP image file format */
+#define GIF_SUPPORTED        /* GIF image file format */
+#define PPM_SUPPORTED        /* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED        /* Utah RLE image file format */
+#define TARGA_SUPPORTED        /* Targa image file format */
+
+/* Define this if you want to name both input and output files on the command
+ * line, rather than using stdout and optionally stdin.  You MUST do this if
+ * your system can't cope with binary I/O to stdin/stdout.  See comments at
+ * head of cjpeg.c or djpeg.c.
+ */
+#if defined WIN32 || defined _WIN32
+#define TWO_FILE_COMMANDLINE    /* optional */
+#define USE_SETMODE        /* Microsoft has setmode() */
+#else
+#undef TWO_FILE_COMMANDLINE
+#endif
+
+/* Define this if your system needs explicit cleanup of temporary files.
+ * This is crucial under MS-DOS, where the temporary "files" may be areas
+ * of extended memory; on most other systems it's not as important.
+ */
+#undef NEED_SIGNAL_CATCHER
+
+/* By default, we open image files with fopen(...,"rb") or fopen(...,"wb").
+ * This is necessary on systems that distinguish text files from binary files,
+ * and is harmless on most systems that don't.  If you have one of the rare
+ * systems that complains about the "b" spec, define this symbol.
+ */
+#undef DONT_USE_B_MODE
+
+/* Define this if you want percent-done progress reports from cjpeg/djpeg.
+ */
+#undef PROGRESS_REPORT
+
+
+#endif /* JPEG_CJPEG_DJPEG */
--- a/pnna/pnna-armhf/third-party/jpeg/include/jdct.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jdct.h
@ -0,0 +1,417 @@
+/*
+ * jdct.h
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * Modified 2002-2015 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules.  These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease 
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+
+/*
+ * A forward DCT routine is given a pointer to an input sample array and
+ * a pointer to a work area of type DCTELEM[]; the DCT is to be performed
+ * in-place in that buffer.  Type DCTELEM is int for 8-bit samples, INT32
+ * for 12-bit samples.  (NOTE: Floating-point DCT implementations use an
+ * array of type FAST_FLOAT, instead.)
+ * The input data is to be fetched from the sample array starting at a
+ * specified column.  (Any row offset needed will be applied to the array
+ * pointer before it is passed to the FDCT code.)
+ * Note that the number of samples fetched by the FDCT routine is
+ * DCT_h_scaled_size * DCT_v_scaled_size.
+ * The DCT outputs are returned scaled up by a factor of 8; they therefore
+ * have a range of +-8K for 8-bit data, +-128K for 12-bit data.  This
+ * convention improves accuracy in integer implementations and saves some
+ * work in floating-point ones.
+ * Quantization of the output coefficients is done by jcdctmgr.c.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef int DCTELEM;        /* 16 or 32 bits is fine */
+#else
+typedef INT32 DCTELEM;        /* must have 32 bits */
+#endif
+
+typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data,
+                           JSAMPARRAY sample_data,
+                           JDIMENSION start_col));
+typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data,
+                         JSAMPARRAY sample_data,
+                         JDIMENSION start_col));
+
+
+/*
+ * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
+ * to an output sample array.  The routine must dequantize the input data as
+ * well as perform the IDCT; for dequantization, it uses the multiplier table
+ * pointed to by compptr->dct_table.  The output data is to be placed into the
+ * sample array starting at a specified column.  (Any row offset needed will
+ * be applied to the array pointer before it is passed to the IDCT code.)
+ * Note that the number of samples emitted by the IDCT routine is
+ * DCT_h_scaled_size * DCT_v_scaled_size.
+ */
+
+/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
+
+/*
+ * Each IDCT routine has its own ideas about the best dct_table element type.
+ */
+
+typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
+#if BITS_IN_JSAMPLE == 8
+typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS  2    /* fractional bits in scale factors */
+#else
+typedef INT32 IFAST_MULT_TYPE;    /* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS  13    /* fractional bits in scale factors */
+#endif
+typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
+
+
+/*
+ * Each IDCT routine is responsible for range-limiting its results and
+ * converting them to unsigned form (0..MAXJSAMPLE).  The raw outputs could
+ * be quite far out of range if the input data is corrupt, so a bulletproof
+ * range-limiting step is required.  We use a mask-and-table-lookup method
+ * to do the combined operations quickly, assuming that MAXJSAMPLE+1
+ * is a power of 2.  See the comments with prepare_range_limit_table
+ * (in jdmaster.c) for more info.
+ */
+
+#define RANGE_MASK  (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
+#define RANGE_CENTER  (MAXJSAMPLE * 2 + 2)
+#define RANGE_SUBSET  (RANGE_CENTER - CENTERJSAMPLE)
+
+#define IDCT_range_limit(cinfo)  ((cinfo)->sample_range_limit - RANGE_SUBSET)
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_fdct_islow        jFDislow
+#define jpeg_fdct_ifast        jFDifast
+#define jpeg_fdct_float        jFDfloat
+#define jpeg_fdct_7x7        jFD7x7
+#define jpeg_fdct_6x6        jFD6x6
+#define jpeg_fdct_5x5        jFD5x5
+#define jpeg_fdct_4x4        jFD4x4
+#define jpeg_fdct_3x3        jFD3x3
+#define jpeg_fdct_2x2        jFD2x2
+#define jpeg_fdct_1x1        jFD1x1
+#define jpeg_fdct_9x9        jFD9x9
+#define jpeg_fdct_10x10        jFD10x10
+#define jpeg_fdct_11x11        jFD11x11
+#define jpeg_fdct_12x12        jFD12x12
+#define jpeg_fdct_13x13        jFD13x13
+#define jpeg_fdct_14x14        jFD14x14
+#define jpeg_fdct_15x15        jFD15x15
+#define jpeg_fdct_16x16        jFD16x16
+#define jpeg_fdct_16x8        jFD16x8
+#define jpeg_fdct_14x7        jFD14x7
+#define jpeg_fdct_12x6        jFD12x6
+#define jpeg_fdct_10x5        jFD10x5
+#define jpeg_fdct_8x4        jFD8x4
+#define jpeg_fdct_6x3        jFD6x3
+#define jpeg_fdct_4x2        jFD4x2
+#define jpeg_fdct_2x1        jFD2x1
+#define jpeg_fdct_8x16        jFD8x16
+#define jpeg_fdct_7x14        jFD7x14
+#define jpeg_fdct_6x12        jFD6x12
+#define jpeg_fdct_5x10        jFD5x10
+#define jpeg_fdct_4x8        jFD4x8
+#define jpeg_fdct_3x6        jFD3x6
+#define jpeg_fdct_2x4        jFD2x4
+#define jpeg_fdct_1x2        jFD1x2
+#define jpeg_idct_islow        jRDislow
+#define jpeg_idct_ifast        jRDifast
+#define jpeg_idct_float        jRDfloat
+#define jpeg_idct_7x7        jRD7x7
+#define jpeg_idct_6x6        jRD6x6
+#define jpeg_idct_5x5        jRD5x5
+#define jpeg_idct_4x4        jRD4x4
+#define jpeg_idct_3x3        jRD3x3
+#define jpeg_idct_2x2        jRD2x2
+#define jpeg_idct_1x1        jRD1x1
+#define jpeg_idct_9x9        jRD9x9
+#define jpeg_idct_10x10        jRD10x10
+#define jpeg_idct_11x11        jRD11x11
+#define jpeg_idct_12x12        jRD12x12
+#define jpeg_idct_13x13        jRD13x13
+#define jpeg_idct_14x14        jRD14x14
+#define jpeg_idct_15x15        jRD15x15
+#define jpeg_idct_16x16        jRD16x16
+#define jpeg_idct_16x8        jRD16x8
+#define jpeg_idct_14x7        jRD14x7
+#define jpeg_idct_12x6        jRD12x6
+#define jpeg_idct_10x5        jRD10x5
+#define jpeg_idct_8x4        jRD8x4
+#define jpeg_idct_6x3        jRD6x3
+#define jpeg_idct_4x2        jRD4x2
+#define jpeg_idct_2x1        jRD2x1
+#define jpeg_idct_8x16        jRD8x16
+#define jpeg_idct_7x14        jRD7x14
+#define jpeg_idct_6x12        jRD6x12
+#define jpeg_idct_5x10        jRD5x10
+#define jpeg_idct_4x8        jRD4x8
+#define jpeg_idct_3x6        jRD3x8
+#define jpeg_idct_2x4        jRD2x4
+#define jpeg_idct_1x2        jRD1x2
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Extern declarations for the forward and inverse DCT routines. */
+
+EXTERN(void) jpeg_fdct_islow
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_ifast
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_float
+    JPP((FAST_FLOAT * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_7x7
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_6x6
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_5x5
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_4x4
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_3x3
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_2x2
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_1x1
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_9x9
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_10x10
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_11x11
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_12x12
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_13x13
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_14x14
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_15x15
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_16x16
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_16x8
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_14x7
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_12x6
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_10x5
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_8x4
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_6x3
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_4x2
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_2x1
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_8x16
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_7x14
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_6x12
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_5x10
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_4x8
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_3x6
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_2x4
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+EXTERN(void) jpeg_fdct_1x2
+    JPP((DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col));
+
+EXTERN(void) jpeg_idct_islow
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_ifast
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_float
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_7x7
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_6x6
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_5x5
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_4x4
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_3x3
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_2x2
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_1x1
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_9x9
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_10x10
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_11x11
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_12x12
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_13x13
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_14x14
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_15x15
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_16x16
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_16x8
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_14x7
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_12x6
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_10x5
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_8x4
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_6x3
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_4x2
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_2x1
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_8x16
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_7x14
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_6x12
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_5x10
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_4x8
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_3x6
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_2x4
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_1x2
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+     JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+
+
+/*
+ * Macros for handling fixed-point arithmetic; these are used by many
+ * but not all of the DCT/IDCT modules.
+ *
+ * All values are expected to be of type INT32.
+ * Fractional constants are scaled left by CONST_BITS bits.
+ * CONST_BITS is defined within each module using these macros,
+ * and may differ from one module to the next.
+ */
+
+#define ONE    ((INT32) 1)
+#define CONST_SCALE (ONE << CONST_BITS)
+
+/* Convert a positive real constant to an integer scaled by CONST_SCALE.
+ * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
+ * thus causing a lot of useless floating-point operations at run time.
+ */
+
+#define FIX(x)    ((INT32) ((x) * CONST_SCALE + 0.5))
+
+/* Descale and correctly round an INT32 value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * This macro is used only when the two inputs will actually be no more than
+ * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
+ * full 32x32 multiply.  This provides a useful speedup on many machines.
+ * Unfortunately there is no way to specify a 16x16->32 multiply portably
+ * in C, but some C compilers will do the right thing if you provide the
+ * correct combination of casts.
+ */
+
+#ifdef SHORTxSHORT_32        /* may work if 'int' is 32 bits */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT16) (const)))
+#endif
+#ifdef SHORTxLCONST_32        /* known to work with Microsoft C 6.0 */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT32) (const)))
+#endif
+
+#ifndef MULTIPLY16C16        /* default definition */
+#define MULTIPLY16C16(var,const)  ((var) * (const))
+#endif
+
+/* Same except both inputs are variables. */
+
+#ifdef SHORTxSHORT_32        /* may work if 'int' is 32 bits */
+#define MULTIPLY16V16(var1,var2)  (((INT16) (var1)) * ((INT16) (var2)))
+#endif
+
+#ifndef MULTIPLY16V16        /* default definition */
+#define MULTIPLY16V16(var1,var2)  ((var1) * (var2))
+#endif
+
+/* Like RIGHT_SHIFT, but applies to a DCTELEM.
+ * We assume that int right shift is unsigned if INT32 right shift is.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS    DCTELEM ishift_temp;
+#if BITS_IN_JSAMPLE == 8
+#define DCTELEMBITS  16        /* DCTELEM may be 16 or 32 bits */
+#else
+#define DCTELEMBITS  32        /* DCTELEM must be 32 bits */
+#endif
+#define IRIGHT_SHIFT(x,shft)  \
+    ((ishift_temp = (x)) < 0 ? \
+     (ishift_temp >> (shft)) | ((~((DCTELEM) 0)) << (DCTELEMBITS-(shft))) : \
+     (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft)    ((x) >> (shft))
+#endif
--- a/pnna/pnna-armhf/third-party/jpeg/include/jerror.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jerror.h
@ -0,0 +1,304 @@
+/*
+ * jerror.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * Modified 1997-2012 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the JPEG library.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ * A set of error-reporting macros are defined too.  Some applications using
+ * the JPEG library may wish to include this file to get the error codes
+ * and/or the macros.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE.  To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef JERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* JERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string)    code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */
+
+/* For maintenance convenience, list is alphabetical by message code name */
+JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
+JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
+JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode")
+JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS")
+JMESSAGE(JERR_BAD_CROP_SPEC, "Invalid crop request")
+JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range")
+JMESSAGE(JERR_BAD_DCTSIZE, "DCT scaled block size %dx%d not supported")
+JMESSAGE(JERR_BAD_DROP_SAMPLING,
+     "Component index %d: mismatching sampling ratio %d:%d, %d:%d, %c")
+JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition")
+JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace")
+JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace")
+JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length")
+JMESSAGE(JERR_BAD_LIB_VERSION,
+     "Wrong JPEG library version: library is %d, caller expects %d")
+JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan")
+JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d")
+JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d")
+JMESSAGE(JERR_BAD_PROGRESSION,
+     "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d")
+JMESSAGE(JERR_BAD_PROG_SCRIPT,
+     "Invalid progressive parameters at scan script entry %d")
+JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors")
+JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d")
+JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d")
+JMESSAGE(JERR_BAD_STRUCT_SIZE,
+     "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u")
+JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access")
+JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small")
+JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here")
+JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet")
+JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d")
+JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request")
+JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d")
+JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x")
+JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d")
+JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d")
+JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)")
+JMESSAGE(JERR_EMS_READ, "Read from EMS failed")
+JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed")
+JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
+JMESSAGE(JERR_FILE_READ, "Input file read error")
+JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
+JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
+JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
+JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
+JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
+JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
+JMESSAGE(JERR_INPUT_EOF, "Premature end of input file")
+JMESSAGE(JERR_MISMATCHED_QUANT_TABLE,
+     "Cannot transcode due to multiple use of quantization table %d")
+JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
+JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
+JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
+JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
+JMESSAGE(JERR_NO_ARITH_TABLE, "Arithmetic table 0x%02x was not defined")
+JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
+JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
+JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
+JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined")
+JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x")
+JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)")
+JMESSAGE(JERR_QUANT_COMPONENTS,
+     "Cannot quantize more than %d color components")
+JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors")
+JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors")
+JMESSAGE(JERR_SOF_BEFORE, "Invalid JPEG file structure: %s before SOF")
+JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers")
+JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker")
+JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x")
+JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers")
+JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s")
+JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file")
+JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file")
+JMESSAGE(JERR_TFILE_WRITE,
+     "Write failed on temporary file --- out of disk space?")
+JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines")
+JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x")
+JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up")
+JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation")
+JMESSAGE(JERR_XMS_READ, "Read from XMS failed")
+JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed")
+JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT)
+JMESSAGE(JMSG_VERSION, JVERSION)
+JMESSAGE(JTRC_16BIT_TABLES,
+     "Caution: quantization tables are too coarse for baseline JPEG")
+JMESSAGE(JTRC_ADOBE,
+     "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d")
+JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u")
+JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u")
+JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x")
+JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x")
+JMESSAGE(JTRC_DQT, "Define Quantization Table %d  precision %d")
+JMESSAGE(JTRC_DRI, "Define Restart Interval %u")
+JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u")
+JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
+JMESSAGE(JTRC_EOI, "End Of Image")
+JMESSAGE(JTRC_HUFFBITS, "        %3d %3d %3d %3d %3d %3d %3d %3d")
+JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d  %d")
+JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,
+     "Warning: thumbnail image size does not match data length %u")
+JMESSAGE(JTRC_JFIF_EXTENSION,
+     "JFIF extension marker: type 0x%02x, length %u")
+JMESSAGE(JTRC_JFIF_THUMBNAIL, "    with %d x %d thumbnail image")
+JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u")
+JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
+JMESSAGE(JTRC_QUANTVALS, "        %4u %4u %4u %4u %4u %4u %4u %4u")
+JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors")
+JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors")
+JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization")
+JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d")
+JMESSAGE(JTRC_RST, "RST%d")
+JMESSAGE(JTRC_SMOOTH_NOTIMPL,
+     "Smoothing not supported with nonstandard sampling ratios")
+JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d")
+JMESSAGE(JTRC_SOF_COMPONENT, "    Component %d: %dhx%dv q=%d")
+JMESSAGE(JTRC_SOI, "Start of Image")
+JMESSAGE(JTRC_SOS, "Start Of Scan: %d components")
+JMESSAGE(JTRC_SOS_COMPONENT, "    Component %d: dc=%d ac=%d")
+JMESSAGE(JTRC_SOS_PARAMS, "  Ss=%d, Se=%d, Ah=%d, Al=%d")
+JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s")
+JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
+JMESSAGE(JTRC_THUMB_JPEG,
+     "JFIF extension marker: JPEG-compressed thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_PALETTE,
+     "JFIF extension marker: palette thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_RGB,
+     "JFIF extension marker: RGB thumbnail image, length %u")
+JMESSAGE(JTRC_UNKNOWN_IDS,
+     "Unrecognized component IDs %d %d %d, assuming YCbCr")
+JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
+JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
+JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
+JMESSAGE(JWRN_ARITH_BAD_CODE, "Corrupt JPEG data: bad arithmetic code")
+JMESSAGE(JWRN_BOGUS_PROGRESSION,
+     "Inconsistent progression sequence for component %d coefficient %d")
+JMESSAGE(JWRN_EXTRANEOUS_DATA,
+     "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x")
+JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment")
+JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code")
+JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d")
+JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file")
+JMESSAGE(JWRN_MUST_RESYNC,
+     "Corrupt JPEG data: found marker 0x%02x instead of RST%d")
+JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG")
+JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines")
+
+#ifdef JMAKE_ENUM_LIST
+
+  JMSG_LASTMSGCODE
+} J_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
+
+
+#ifndef JERROR_H
+#define JERROR_H
+
+/* Macros to simplify using the error and trace message stuff */
+/* The first parameter is either type of cinfo pointer */
+
+/* Fatal errors (print message and exit) */
+#define ERREXIT(cinfo,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT1(cinfo,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT2(cinfo,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT3(cinfo,code,p1,p2,p3)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT4(cinfo,code,p1,p2,p3,p4)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (cinfo)->err->msg_parm.i[3] = (p4), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT6(cinfo,code,p1,p2,p3,p4,p5,p6)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (cinfo)->err->msg_parm.i[3] = (p4), \
+   (cinfo)->err->msg_parm.i[4] = (p5), \
+   (cinfo)->err->msg_parm.i[5] = (p6), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXITS(cinfo,code,str)  \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+
+#define MAKESTMT(stuff)        do { stuff } while (0)
+
+/* Nonfatal errors (we can keep going, but the data is probably corrupt) */
+#define WARNMS(cinfo,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS1(cinfo,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS2(cinfo,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+
+/* Informational/debugging messages */
+#define TRACEMS(cinfo,lvl,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS1(cinfo,lvl,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS2(cinfo,lvl,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS3(cinfo,lvl,code,p1,p2,p3)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+       _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \
+       (cinfo)->err->msg_code = (code); \
+       (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+       _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+       (cinfo)->err->msg_code = (code); \
+       (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+       _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+       _mp[4] = (p5); \
+       (cinfo)->err->msg_code = (code); \
+       (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+       _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+       _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \
+       (cinfo)->err->msg_code = (code); \
+       (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMSS(cinfo,lvl,code,str)  \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+
+#endif /* JERROR_H */
--- a/pnna/pnna-armhf/third-party/jpeg/include/jinclude.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jinclude.h
@ -0,0 +1,91 @@
+/*
+ * jinclude.h
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file exists to provide a single place to fix any problems with
+ * including the wrong system include files.  (Common problems are taken
+ * care of by the standard jconfig symbols, but on really weird systems
+ * you may have to edit this file.)
+ *
+ * NOTE: this file is NOT intended to be included by applications using the
+ * JPEG library.  Most applications need only include jpeglib.h.
+ */
+
+
+/* Include auto-config file to find out which system include files we need. */
+
+#include "jconfig.h"        /* auto configuration options */
+#define JCONFIG_INCLUDED    /* so that jpeglib.h doesn't do it again */
+
+/*
+ * We need the NULL macro and size_t typedef.
+ * On an ANSI-conforming system it is sufficient to include <stddef.h>.
+ * Otherwise, we get them from <stdlib.h> or <stdio.h>; we may have to
+ * pull in <sys/types.h> as well.
+ * Note that the core JPEG library does not require <stdio.h>;
+ * only the default error handler and data source/destination modules do.
+ * But we must pull it in because of the references to FILE in jpeglib.h.
+ * You can remove those references if you want to compile without <stdio.h>.
+ */
+
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef NEED_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#include <stdio.h>
+
+/*
+ * We need memory copying and zeroing functions, plus strncpy().
+ * ANSI and System V implementations declare these in <string.h>.
+ * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
+ * Some systems may declare memset and memcpy in <memory.h>.
+ *
+ * NOTE: we assume the size parameters to these functions are of type size_t.
+ * Change the casts in these macros if not!
+ */
+
+#ifdef NEED_BSD_STRINGS
+
+#include <strings.h>
+#define MEMZERO(target,size)    bzero((void *)(target), (size_t)(size))
+#define MEMCOPY(dest,src,size)    bcopy((const void *)(src), (void *)(dest), (size_t)(size))
+
+#else /* not BSD, assume ANSI/SysV string lib */
+
+#include <string.h>
+#define MEMZERO(target,size)    memset((void *)(target), 0, (size_t)(size))
+#define MEMCOPY(dest,src,size)    memcpy((void *)(dest), (const void *)(src), (size_t)(size))
+
+#endif
+
+/*
+ * In ANSI C, and indeed any rational implementation, size_t is also the
+ * type returned by sizeof().  However, it seems there are some irrational
+ * implementations out there, in which sizeof() returns an int even though
+ * size_t is defined as long or unsigned long.  To ensure consistent results
+ * we always use this SIZEOF() macro in place of using sizeof() directly.
+ */
+
+#define SIZEOF(object)    ((size_t) sizeof(object))
+
+/*
+ * The modules that use fread() and fwrite() always invoke them through
+ * these macros.  On some systems you may need to twiddle the argument casts.
+ * CAUTION: argument order is different from underlying functions!
+ */
+
+#define JFREAD(file,buf,sizeofbuf)  \
+  ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+#define JFWRITE(file,buf,sizeofbuf)  \
+  ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
--- a/pnna/pnna-armhf/third-party/jpeg/include/jmemsys.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jmemsys.h
@ -0,0 +1,198 @@
+/*
+ * jmemsys.h
+ *
+ * Copyright (C) 1992-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file defines the interface between the system-independent
+ * and system-dependent portions of the JPEG memory manager.  No other
+ * modules need include it.  (The system-independent portion is jmemmgr.c;
+ * there are several different versions of the system-dependent portion.)
+ *
+ * This file works as-is for the system-dependent memory managers supplied
+ * in the IJG distribution.  You may need to modify it if you write a
+ * custom memory manager.  If system-dependent changes are needed in
+ * this file, the best method is to #ifdef them based on a configuration
+ * symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR
+ * and USE_MAC_MEMMGR.
+ */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_get_small        jGetSmall
+#define jpeg_free_small        jFreeSmall
+#define jpeg_get_large        jGetLarge
+#define jpeg_free_large        jFreeLarge
+#define jpeg_mem_available    jMemAvail
+#define jpeg_open_backing_store    jOpenBackStore
+#define jpeg_mem_init        jMemInit
+#define jpeg_mem_term        jMemTerm
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/*
+ * These two functions are used to allocate and release small chunks of
+ * memory.  (Typically the total amount requested through jpeg_get_small is
+ * no more than 20K or so; this will be requested in chunks of a few K each.)
+ * Behavior should be the same as for the standard library functions malloc
+ * and free; in particular, jpeg_get_small must return NULL on failure.
+ * On most systems, these ARE malloc and free.  jpeg_free_small is passed the
+ * size of the object being freed, just in case it's needed.
+ * On an 80x86 machine using small-data memory model, these manage near heap.
+ */
+
+EXTERN(void *) jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject));
+EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object,
+                  size_t sizeofobject));
+
+/*
+ * These two functions are used to allocate and release large chunks of
+ * memory (up to the total free space designated by jpeg_mem_available).
+ * The interface is the same as above, except that on an 80x86 machine,
+ * far pointers are used.  On most other machines these are identical to
+ * the jpeg_get/free_small routines; but we keep them separate anyway,
+ * in case a different allocation strategy is desirable for large chunks.
+ */
+
+EXTERN(void FAR *) jpeg_get_large JPP((j_common_ptr cinfo,
+                       size_t sizeofobject));
+EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object,
+                  size_t sizeofobject));
+
+/*
+ * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
+ * be requested in a single call to jpeg_get_large (and jpeg_get_small for that
+ * matter, but that case should never come into play).  This macro is needed
+ * to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
+ * On those machines, we expect that jconfig.h will provide a proper value.
+ * On machines with 32-bit flat address spaces, any large constant may be used.
+ *
+ * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type
+ * size_t and will be a multiple of sizeof(align_type).
+ */
+
+#ifndef MAX_ALLOC_CHUNK        /* may be overridden in jconfig.h */
+#define MAX_ALLOC_CHUNK  1000000000L
+#endif
+
+/*
+ * This routine computes the total space still available for allocation by
+ * jpeg_get_large.  If more space than this is needed, backing store will be
+ * used.  NOTE: any memory already allocated must not be counted.
+ *
+ * There is a minimum space requirement, corresponding to the minimum
+ * feasible buffer sizes; jmemmgr.c will request that much space even if
+ * jpeg_mem_available returns zero.  The maximum space needed, enough to hold
+ * all working storage in memory, is also passed in case it is useful.
+ * Finally, the total space already allocated is passed.  If no better
+ * method is available, cinfo->mem->max_memory_to_use - already_allocated
+ * is often a suitable calculation.
+ *
+ * It is OK for jpeg_mem_available to underestimate the space available
+ * (that'll just lead to more backing-store access than is really necessary).
+ * However, an overestimate will lead to failure.  Hence it's wise to subtract
+ * a slop factor from the true available space.  5% should be enough.
+ *
+ * On machines with lots of virtual memory, any large constant may be returned.
+ * Conversely, zero may be returned to always use the minimum amount of memory.
+ */
+
+EXTERN(long) jpeg_mem_available JPP((j_common_ptr cinfo,
+                     long min_bytes_needed,
+                     long max_bytes_needed,
+                     long already_allocated));
+
+
+/*
+ * This structure holds whatever state is needed to access a single
+ * backing-store object.  The read/write/close method pointers are called
+ * by jmemmgr.c to manipulate the backing-store object; all other fields
+ * are private to the system-dependent backing store routines.
+ */
+
+#define TEMP_NAME_LENGTH   64    /* max length of a temporary file's name */
+
+
+#ifdef USE_MSDOS_MEMMGR        /* DOS-specific junk */
+
+typedef unsigned short XMSH;    /* type of extended-memory handles */
+typedef unsigned short EMSH;    /* type of expanded-memory handles */
+
+typedef union {
+  short file_handle;        /* DOS file handle if it's a temp file */
+  XMSH xms_handle;        /* handle if it's a chunk of XMS */
+  EMSH ems_handle;        /* handle if it's a chunk of EMS */
+} handle_union;
+
+#endif /* USE_MSDOS_MEMMGR */
+
+#ifdef USE_MAC_MEMMGR        /* Mac-specific junk */
+#include <Files.h>
+#endif /* USE_MAC_MEMMGR */
+
+
+typedef struct backing_store_struct * backing_store_ptr;
+
+typedef struct backing_store_struct {
+  /* Methods for reading/writing/closing this backing-store object */
+  JMETHOD(void, read_backing_store, (j_common_ptr cinfo,
+                     backing_store_ptr info,
+                     void FAR * buffer_address,
+                     long file_offset, long byte_count));
+  JMETHOD(void, write_backing_store, (j_common_ptr cinfo,
+                      backing_store_ptr info,
+                      void FAR * buffer_address,
+                      long file_offset, long byte_count));
+  JMETHOD(void, close_backing_store, (j_common_ptr cinfo,
+                      backing_store_ptr info));
+
+  /* Private fields for system-dependent backing-store management */
+#ifdef USE_MSDOS_MEMMGR
+  /* For the MS-DOS manager (jmemdos.c), we need: */
+  handle_union handle;        /* reference to backing-store storage object */
+  char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+#ifdef USE_MAC_MEMMGR
+  /* For the Mac manager (jmemmac.c), we need: */
+  short temp_file;        /* file reference number to temp file */
+  FSSpec tempSpec;        /* the FSSpec for the temp file */
+  char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+  /* For a typical implementation with temp files, we need: */
+  FILE * temp_file;        /* stdio reference to temp file */
+  char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */
+#endif
+#endif
+} backing_store_info;
+
+
+/*
+ * Initial opening of a backing-store object.  This must fill in the
+ * read/write/close pointers in the object.  The read/write routines
+ * may take an error exit if the specified maximum file size is exceeded.
+ * (If jpeg_mem_available always returns a large value, this routine can
+ * just take an error exit.)
+ */
+
+EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo,
+                      backing_store_ptr info,
+                      long total_bytes_needed));
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required.  jpeg_mem_init will be called before anything is
+ * allocated (and, therefore, nothing in cinfo is of use except the error
+ * manager pointer).  It should return a suitable default value for
+ * max_memory_to_use; this may subsequently be overridden by the surrounding
+ * application.  (Note that max_memory_to_use is only important if
+ * jpeg_mem_available chooses to consult it ... no one else will.)
+ * jpeg_mem_term may assume that all requested memory has been freed and that
+ * all opened backing-store objects have been closed.
+ */
+
+EXTERN(long) jpeg_mem_init JPP((j_common_ptr cinfo));
+EXTERN(void) jpeg_mem_term JPP((j_common_ptr cinfo));
--- a/pnna/pnna-armhf/third-party/jpeg/include/jmorecfg.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jmorecfg.h
@ -0,0 +1,453 @@
+/*
+ * jmorecfg.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 1997-2013 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations.  Most users will not need to touch this file.
+ */
+
+
+/*
+ * Define BITS_IN_JSAMPLE as either
+ *   8   for 8-bit sample values (the usual setting)
+ *   9   for 9-bit sample values
+ *   10  for 10-bit sample values
+ *   11  for 11-bit sample values
+ *   12  for 12-bit sample values
+ * Only 8, 9, 10, 11, and 12 bits sample data precision are supported for
+ * full-feature DCT processing.  Further depths up to 16-bit may be added
+ * later for the lossless modes of operation.
+ * Run-time selection and conversion of data precision will be added later
+ * and are currently not supported, sorry.
+ * Exception:  The transcoding part (jpegtran) supports all settings in a
+ * single instance, since it operates on the level of DCT coefficients and
+ * not sample values.  The DCT coefficients are of the same type (16 bits)
+ * in all cases (see below).
+ */
+
+#define BITS_IN_JSAMPLE  8    /* use 8, 9, 10, 11, or 12 */
+
+
+/*
+ * Maximum number of components (color channels) allowed in JPEG image.
+ * To meet the letter of the JPEG spec, set this to 255.  However, darn
+ * few applications need more than 4 channels (maybe 5 for CMYK + alpha
+ * mask).  We recommend 10 as a reasonable compromise; use 4 if you are
+ * really short on memory.  (Each allowed component costs a hundred or so
+ * bytes of storage, whether actually used in an image or not.)
+ */
+
+#define MAX_COMPONENTS  10    /* maximum number of image components */
+
+
+/*
+ * Basic data types.
+ * You may need to change these if you have a machine with unusual data
+ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* Representation of a single sample (pixel element value).
+ * We frequently allocate large arrays of these, so it's important to keep
+ * them small.  But if you have memory to burn and access to char or short
+ * arrays is very slow on your hardware, you might want to change these.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JSAMPLE;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJSAMPLE(value)  ((int) (value))
+#else
+#define GETJSAMPLE(value)  ((int) (value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+#define MAXJSAMPLE    255
+#define CENTERJSAMPLE    128
+
+#endif /* BITS_IN_JSAMPLE == 8 */
+
+
+#if BITS_IN_JSAMPLE == 9
+/* JSAMPLE should be the smallest type that will hold the values 0..511.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#define MAXJSAMPLE    511
+#define CENTERJSAMPLE    256
+
+#endif /* BITS_IN_JSAMPLE == 9 */
+
+
+#if BITS_IN_JSAMPLE == 10
+/* JSAMPLE should be the smallest type that will hold the values 0..1023.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#define MAXJSAMPLE    1023
+#define CENTERJSAMPLE    512
+
+#endif /* BITS_IN_JSAMPLE == 10 */
+
+
+#if BITS_IN_JSAMPLE == 11
+/* JSAMPLE should be the smallest type that will hold the values 0..2047.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#define MAXJSAMPLE    2047
+#define CENTERJSAMPLE    1024
+
+#endif /* BITS_IN_JSAMPLE == 11 */
+
+
+#if BITS_IN_JSAMPLE == 12
+/* JSAMPLE should be the smallest type that will hold the values 0..4095.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#define MAXJSAMPLE    4095
+#define CENTERJSAMPLE    2048
+
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+
+/* Representation of a DCT frequency coefficient.
+ * This should be a signed value of at least 16 bits; "short" is usually OK.
+ * Again, we allocate large arrays of these, but you can change to int
+ * if you have memory to burn and "short" is really slow.
+ */
+
+typedef short JCOEF;
+
+
+/* Compressed datastreams are represented as arrays of JOCTET.
+ * These must be EXACTLY 8 bits wide, at least once they are written to
+ * external storage.  Note that when using the stdio data source/destination
+ * managers, this is also the data type passed to fread/fwrite.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JOCTET;
+#define GETJOCTET(value)  (value)
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JOCTET;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJOCTET(value)  (value)
+#else
+#define GETJOCTET(value)  ((value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+
+/* These typedefs are used for various table entries and so forth.
+ * They must be at least as wide as specified; but making them too big
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE.  (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+#ifdef HAVE_UNSIGNED_CHAR
+typedef unsigned char UINT8;
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+typedef char UINT8;
+#else /* not CHAR_IS_UNSIGNED */
+typedef short UINT8;
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+/* INT16 must hold at least the values -32768..32767. */
+
+#ifndef XMD_H            /* X11/xmd.h correctly defines INT16 */
+typedef short INT16;
+#endif
+
+/* INT32 must hold at least signed 32-bit values. */
+
+#ifndef XMD_H            /* X11/xmd.h correctly defines INT32 */
+#ifndef _BASETSD_H_        /* Microsoft defines it in basetsd.h */
+#ifndef _BASETSD_H        /* MinGW is slightly different */
+#ifndef QGLOBAL_H        /* Qt defines it in qglobal.h */
+typedef long INT32;
+#endif
+#endif
+#endif
+#endif
+
+/* Datatype used for image dimensions.  The JPEG standard only supports
+ * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
+ * "unsigned int" is sufficient on all machines.  However, if you need to
+ * handle larger images and you don't mind deviating from the spec, you
+ * can change this datatype.
+ */
+
+typedef unsigned int JDIMENSION;
+
+#define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */
+
+
+/* These macros are used in all function definitions and extern declarations.
+ * You could modify them if you need to change function linkage conventions;
+ * in particular, you'll need to do that to make the library a Windows DLL.
+ * Another application is to make all functions global for use with debuggers
+ * or code profilers that require it.
+ */
+
+/* a function called through method pointers: */
+#define METHODDEF(type)        static type
+/* a function used only in its module: */
+#define LOCAL(type)        static type
+/* a function referenced thru EXTERNs: */
+#define GLOBAL(type)        type
+/* a reference to a GLOBAL function: */
+#define EXTERN(type)        extern type
+
+
+/* This macro is used to declare a "method", that is, a function pointer.
+ * We want to supply prototype parameters if the compiler can cope.
+ * Note that the arglist parameter must be parenthesized!
+ * Again, you can customize this if you need special linkage keywords.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
+#else
+#define JMETHOD(type,methodname,arglist)  type (*methodname) ()
+#endif
+
+
+/* The noreturn type identifier is used to declare functions
+ * which cannot return.
+ * Compilers can thus create more optimized code and perform
+ * better checks for warnings and errors.
+ * Static analyzer tools can make improved inferences about
+ * execution paths and are prevented from giving false alerts.
+ *
+ * Unfortunately, the proposed specifications of corresponding
+ * extensions in the Dec 2011 ISO C standard revision (C11),
+ * GCC, MSVC, etc. are not viable.
+ * Thus we introduce a user defined type to declare noreturn
+ * functions at least for clarity.  A proper compiler would
+ * have a suitable noreturn type to match in place of void.
+ */
+
+#ifndef HAVE_NORETURN_T
+typedef void noreturn_t;
+#endif
+
+
+/* Here is the pseudo-keyword for declaring pointers that must be "far"
+ * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
+ * by just saying "FAR *" where such a pointer is needed.  In a few places
+ * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
+ */
+
+#ifndef FAR
+#ifdef NEED_FAR_POINTERS
+#define FAR  far
+#else
+#define FAR
+#endif
+#endif
+
+
+/*
+ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
+ * in standard header files.  Or you may have conflicts with application-
+ * specific header files that you want to include together with these files.
+ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
+ */
+
+#ifndef HAVE_BOOLEAN
+#if defined FALSE || defined TRUE || defined QGLOBAL_H
+/* Qt3 defines FALSE and TRUE as "const" variables in qglobal.h */
+typedef int boolean;
+#ifndef FALSE            /* in case these macros already exist */
+#define FALSE    0        /* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE    1
+#endif
+#else
+typedef enum { FALSE = 0, TRUE = 1 } boolean;
+#endif
+#else
+#ifndef FALSE            /* in case these macros already exist */
+#define FALSE    0        /* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE    1
+#endif
+#endif
+
+
+/*
+ * The remaining options affect code selection within the JPEG library,
+ * but they don't need to be visible to most applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+
+#ifdef JPEG_INTERNAL_OPTIONS
+
+
+/*
+ * These defines indicate whether to include various optional functions.
+ * Undefining some of these symbols will produce a smaller but less capable
+ * library.  Note that you can leave certain source files out of the
+ * compilation/linking process if you've #undef'd the corresponding symbols.
+ * (You may HAVE to do that if your compiler doesn't like null source files.)
+ */
+
+/* Capability options common to encoder and decoder: */
+
+#define DCT_ISLOW_SUPPORTED    /* slow but accurate integer algorithm */
+#define DCT_IFAST_SUPPORTED    /* faster, less accurate integer method */
+#define DCT_FLOAT_SUPPORTED    /* floating-point: accurate, fast on fast HW */
+
+/* Encoder capability options: */
+
+#define C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define C_PROGRESSIVE_SUPPORTED        /* Progressive JPEG? (Requires MULTISCAN)*/
+#define DCT_SCALING_SUPPORTED        /* Input rescaling via DCT? (Requires DCT_ISLOW)*/
+#define ENTROPY_OPT_SUPPORTED        /* Optimization of entropy coding parms? */
+/* Note: if you selected more than 8-bit data precision, it is dangerous to
+ * turn off ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only
+ * good for 8-bit precision, so arithmetic coding is recommended for higher
+ * precision.  The Huffman encoder normally uses entropy optimization to
+ * compute usable tables for higher precision.  Otherwise, you'll have to
+ * supply different default Huffman tables.
+ * The exact same statements apply for progressive JPEG: the default tables
+ * don't work for progressive mode.  (This may get fixed, however.)
+ */
+#define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
+
+/* Decoder capability options: */
+
+#define D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define D_PROGRESSIVE_SUPPORTED        /* Progressive JPEG? (Requires MULTISCAN)*/
+#define IDCT_SCALING_SUPPORTED        /* Output rescaling via IDCT? (Requires DCT_ISLOW)*/
+#define SAVE_MARKERS_SUPPORTED        /* jpeg_save_markers() needed? */
+#define BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
+#undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
+#define UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
+#define QUANT_1PASS_SUPPORTED        /* 1-pass color quantization? */
+#define QUANT_2PASS_SUPPORTED        /* 2-pass color quantization? */
+
+/* more capability options later, no doubt */
+
+
+/*
+ * Ordering of RGB data in scanlines passed to or from the application.
+ * If your application wants to deal with data in the order B,G,R, just
+ * change these macros.  You can also deal with formats such as R,G,B,X
+ * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
+ * the offsets will also change the order in which colormap data is organized.
+ * RESTRICTIONS:
+ * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
+ * 2. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
+ *    is not 3 (they don't understand about dummy color components!).  So you
+ *    can't use color quantization if you change that value.
+ */
+
+#define RGB_RED        0    /* Offset of Red in an RGB scanline element */
+#define RGB_GREEN    1    /* Offset of Green */
+#define RGB_BLUE    2    /* Offset of Blue */
+#define RGB_PIXELSIZE    3    /* JSAMPLEs per RGB scanline element */
+
+
+/* Definitions for speed-related optimizations. */
+
+
+/* If your compiler supports inline functions, define INLINE
+ * as the inline keyword; otherwise define it as empty.
+ */
+
+#ifndef INLINE
+#ifdef __GNUC__            /* for instance, GNU C knows about inline */
+#define INLINE __inline__
+#endif
+#ifndef INLINE
+#define INLINE            /* default is to define it as empty */
+#endif
+#endif
+
+
+/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
+ * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
+ * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
+ */
+
+#ifndef MULTIPLIER
+#define MULTIPLIER  int        /* type for fastest integer multiply */
+#endif
+
+
+/* FAST_FLOAT should be either float or double, whichever is done faster
+ * by your compiler.  (Note that this type is only used in the floating point
+ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
+ * Typically, float is faster in ANSI C compilers, while double is faster in
+ * pre-ANSI compilers (because they insist on converting to double anyway).
+ * The code below therefore chooses float if we have ANSI-style prototypes.
+ */
+
+#ifndef FAST_FLOAT
+#ifdef HAVE_PROTOTYPES
+#define FAST_FLOAT  float
+#else
+#define FAST_FLOAT  double
+#endif
+#endif
+
+#endif /* JPEG_INTERNAL_OPTIONS */
--- a/pnna/pnna-armhf/third-party/jpeg/include/jpegint.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jpegint.h
@ -0,0 +1,426 @@
+/*
+ * jpegint.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * Modified 1997-2013 by Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides common declarations for the various JPEG modules.
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+
+/* Declarations for both compression & decompression */
+
+typedef enum {            /* Operating modes for buffer controllers */
+    JBUF_PASS_THRU,        /* Plain stripwise operation */
+    /* Remaining modes require a full-image buffer to have been created */
+    JBUF_SAVE_SOURCE,    /* Run source subobject only, save output */
+    JBUF_CRANK_DEST,    /* Run dest subobject only, using saved data */
+    JBUF_SAVE_AND_PASS    /* Run both subobjects, save output */
+} J_BUF_MODE;
+
+/* Values of global_state field (jdapi.c has some dependencies on ordering!) */
+#define CSTATE_START    100    /* after create_compress */
+#define CSTATE_SCANNING    101    /* start_compress done, write_scanlines OK */
+#define CSTATE_RAW_OK    102    /* start_compress done, write_raw_data OK */
+#define CSTATE_WRCOEFS    103    /* jpeg_write_coefficients done */
+#define DSTATE_START    200    /* after create_decompress */
+#define DSTATE_INHEADER    201    /* reading header markers, no SOS yet */
+#define DSTATE_READY    202    /* found SOS, ready for start_decompress */
+#define DSTATE_PRELOAD    203    /* reading multiscan file in start_decompress*/
+#define DSTATE_PRESCAN    204    /* performing dummy pass for 2-pass quant */
+#define DSTATE_SCANNING    205    /* start_decompress done, read_scanlines OK */
+#define DSTATE_RAW_OK    206    /* start_decompress done, read_raw_data OK */
+#define DSTATE_BUFIMAGE    207    /* expecting jpeg_start_output */
+#define DSTATE_BUFPOST    208    /* looking for SOS/EOI in jpeg_finish_output */
+#define DSTATE_RDCOEFS    209    /* reading file in jpeg_read_coefficients */
+#define DSTATE_STOPPING    210    /* looking for EOI in jpeg_finish_decompress */
+
+
+/* Declarations for compression modules */
+
+/* Master control module */
+struct jpeg_comp_master {
+  JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
+  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean call_pass_startup;    /* True if pass_startup must be called */
+  boolean is_last_pass;        /* True during last pass */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_c_main_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, process_data, (j_compress_ptr cinfo,
+                   JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+                   JDIMENSION in_rows_avail));
+};
+
+/* Compression preprocessing (downsampling input buffer control) */
+struct jpeg_c_prep_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
+                   JSAMPARRAY input_buf,
+                   JDIMENSION *in_row_ctr,
+                   JDIMENSION in_rows_avail,
+                   JSAMPIMAGE output_buf,
+                   JDIMENSION *out_row_group_ctr,
+                   JDIMENSION out_row_groups_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_c_coef_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
+                   JSAMPIMAGE input_buf));
+};
+
+/* Colorspace conversion */
+struct jpeg_color_converter {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, color_convert, (j_compress_ptr cinfo,
+                JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+                JDIMENSION output_row, int num_rows));
+};
+
+/* Downsampling */
+struct jpeg_downsampler {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, downsample, (j_compress_ptr cinfo,
+                 JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+                 JSAMPIMAGE output_buf,
+                 JDIMENSION out_row_group_index));
+
+  boolean need_context_rows;    /* TRUE if need rows above & below */
+};
+
+/* Forward DCT (also controls coefficient quantization) */
+typedef JMETHOD(void, forward_DCT_ptr,
+        (j_compress_ptr cinfo, jpeg_component_info * compptr,
+         JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+         JDIMENSION start_row, JDIMENSION start_col,
+         JDIMENSION num_blocks));
+
+struct jpeg_forward_dct {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  /* It is useful to allow each component to have a separate FDCT method. */
+  forward_DCT_ptr forward_DCT[MAX_COMPONENTS];
+};
+
+/* Entropy encoding */
+struct jpeg_entropy_encoder {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
+  JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
+  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+};
+
+/* Marker writing */
+struct jpeg_marker_writer {
+  JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
+  JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
+  /* These routines are exported to allow insertion of extra markers */
+  /* Probably only COM and APPn markers should be written this way */
+  JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
+                      unsigned int datalen));
+  JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
+};
+
+
+/* Declarations for decompression modules */
+
+/* Master control module */
+struct jpeg_decomp_master {
+  JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean is_dummy_pass;    /* True during 1st pass for 2-pass quant */
+};
+
+/* Input control module */
+struct jpeg_input_controller {
+  JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
+  JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
+  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean has_multiple_scans;    /* True if file has multiple scans */
+  boolean eoi_reached;        /* True when EOI has been consumed */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_d_main_controller {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, process_data, (j_decompress_ptr cinfo,
+                   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+                   JDIMENSION out_rows_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_d_coef_controller {
+  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
+  JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
+  JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
+                 JSAMPIMAGE output_buf));
+  /* Pointer to array of coefficient virtual arrays, or NULL if none */
+  jvirt_barray_ptr *coef_arrays;
+};
+
+/* Decompression postprocessing (color quantization buffer control) */
+struct jpeg_d_post_controller {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
+                    JSAMPIMAGE input_buf,
+                    JDIMENSION *in_row_group_ctr,
+                    JDIMENSION in_row_groups_avail,
+                    JSAMPARRAY output_buf,
+                    JDIMENSION *out_row_ctr,
+                    JDIMENSION out_rows_avail));
+};
+
+/* Marker reading & parsing */
+struct jpeg_marker_reader {
+  JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
+  /* Read markers until SOS or EOI.
+   * Returns same codes as are defined for jpeg_consume_input:
+   * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+   */
+  JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
+  /* Read a restart marker --- exported for use by entropy decoder only */
+  jpeg_marker_parser_method read_restart_marker;
+
+  /* State of marker reader --- nominally internal, but applications
+   * supplying COM or APPn handlers might like to know the state.
+   */
+  boolean saw_SOI;        /* found SOI? */
+  boolean saw_SOF;        /* found SOF? */
+  int next_restart_num;        /* next restart number expected (0-7) */
+  unsigned int discarded_bytes;    /* # of bytes skipped looking for a marker */
+};
+
+/* Entropy decoding */
+struct jpeg_entropy_decoder {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, JBLOCKROW *MCU_data));
+  JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
+};
+
+/* Inverse DCT (also performs dequantization) */
+typedef JMETHOD(void, inverse_DCT_method_ptr,
+        (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+         JCOEFPTR coef_block,
+         JSAMPARRAY output_buf, JDIMENSION output_col));
+
+struct jpeg_inverse_dct {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  /* It is useful to allow each component to have a separate IDCT method. */
+  inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
+};
+
+/* Upsampling (note that upsampler must also call color converter) */
+struct jpeg_upsampler {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, upsample, (j_decompress_ptr cinfo,
+               JSAMPIMAGE input_buf,
+               JDIMENSION *in_row_group_ctr,
+               JDIMENSION in_row_groups_avail,
+               JSAMPARRAY output_buf,
+               JDIMENSION *out_row_ctr,
+               JDIMENSION out_rows_avail));
+
+  boolean need_context_rows;    /* TRUE if need rows above & below */
+};
+
+/* Colorspace conversion */
+struct jpeg_color_deconverter {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
+                JSAMPIMAGE input_buf, JDIMENSION input_row,
+                JSAMPARRAY output_buf, int num_rows));
+};
+
+/* Color quantization or color precision reduction */
+struct jpeg_color_quantizer {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
+  JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
+                 JSAMPARRAY input_buf, JSAMPARRAY output_buf,
+                 int num_rows));
+  JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
+};
+
+
+/* Miscellaneous useful macros */
+
+#undef MAX
+#define MAX(a,b)    ((a) > (b) ? (a) : (b))
+#undef MIN
+#define MIN(a,b)    ((a) < (b) ? (a) : (b))
+
+
+/* We assume that right shift corresponds to signed division by 2 with
+ * rounding towards minus infinity.  This is correct for typical "arithmetic
+ * shift" instructions that shift in copies of the sign bit.  But some
+ * C compilers implement >> with an unsigned shift.  For these machines you
+ * must define RIGHT_SHIFT_IS_UNSIGNED.
+ * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
+ * It is only applied with constant shift counts.  SHIFT_TEMPS must be
+ * included in the variables of any routine using RIGHT_SHIFT.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define SHIFT_TEMPS    INT32 shift_temp;
+#define RIGHT_SHIFT(x,shft)  \
+    ((shift_temp = (x)) < 0 ? \
+     (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
+     (shift_temp >> (shft)))
+#else
+#define SHIFT_TEMPS
+#define RIGHT_SHIFT(x,shft)    ((x) >> (shft))
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jinit_compress_master    jICompress
+#define jinit_c_master_control    jICMaster
+#define jinit_c_main_controller    jICMainC
+#define jinit_c_prep_controller    jICPrepC
+#define jinit_c_coef_controller    jICCoefC
+#define jinit_color_converter    jICColor
+#define jinit_downsampler    jIDownsampler
+#define jinit_forward_dct    jIFDCT
+#define jinit_huff_encoder    jIHEncoder
+#define jinit_arith_encoder    jIAEncoder
+#define jinit_marker_writer    jIMWriter
+#define jinit_master_decompress    jIDMaster
+#define jinit_d_main_controller    jIDMainC
+#define jinit_d_coef_controller    jIDCoefC
+#define jinit_d_post_controller    jIDPostC
+#define jinit_input_controller    jIInCtlr
+#define jinit_marker_reader    jIMReader
+#define jinit_huff_decoder    jIHDecoder
+#define jinit_arith_decoder    jIADecoder
+#define jinit_inverse_dct    jIIDCT
+#define jinit_upsampler        jIUpsampler
+#define jinit_color_deconverter    jIDColor
+#define jinit_1pass_quantizer    jI1Quant
+#define jinit_2pass_quantizer    jI2Quant
+#define jinit_merged_upsampler    jIMUpsampler
+#define jinit_memory_mgr    jIMemMgr
+#define jdiv_round_up        jDivRound
+#define jround_up        jRound
+#define jzero_far        jZeroFar
+#define jcopy_sample_rows    jCopySamples
+#define jcopy_block_row        jCopyBlocks
+#define jpeg_zigzag_order    jZIGTable
+#define jpeg_natural_order    jZAGTable
+#define jpeg_natural_order7    jZAG7Table
+#define jpeg_natural_order6    jZAG6Table
+#define jpeg_natural_order5    jZAG5Table
+#define jpeg_natural_order4    jZAG4Table
+#define jpeg_natural_order3    jZAG3Table
+#define jpeg_natural_order2    jZAG2Table
+#define jpeg_aritab        jAriTab
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
+ * and coefficient-block arrays.  This won't work on 80x86 because the arrays
+ * are FAR and we're assuming a small-pointer memory model.  However, some
+ * DOS compilers provide far-pointer versions of memcpy() and memset() even
+ * in the small-model libraries.  These will be used if USE_FMEM is defined.
+ * Otherwise, the routines in jutils.c do it the hard way.
+ */
+
+#ifndef NEED_FAR_POINTERS    /* normal case, same as regular macro */
+#define FMEMZERO(target,size)    MEMZERO(target,size)
+#else                /* 80x86 case */
+#ifdef USE_FMEM
+#define FMEMZERO(target,size)    _fmemset((void FAR *)(target), 0, (size_t)(size))
+#else
+EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));
+#define FMEMZERO(target,size)    jzero_far(target, size)
+#endif
+#endif
+
+
+/* Compression module initialization routines */
+EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,
+                     boolean transcode_only));
+EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,
+                      boolean need_full_buffer));
+EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,
+                      boolean need_full_buffer));
+EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,
+                      boolean need_full_buffer));
+EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_arith_encoder JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
+/* Decompression module initialization routines */
+EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,
+                      boolean need_full_buffer));
+EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
+                      boolean need_full_buffer));
+EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,
+                      boolean need_full_buffer));
+EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_arith_decoder JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
+/* Memory manager initialization */
+EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
+
+/* Utility routines in jutils.c */
+EXTERN(long) jdiv_round_up JPP((long a, long b));
+EXTERN(long) jround_up JPP((long a, long b));
+EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
+                    JSAMPARRAY output_array, int dest_row,
+                    int num_rows, JDIMENSION num_cols));
+EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
+                  JDIMENSION num_blocks));
+/* Constant tables in jutils.c */
+#if 0                /* This table is not actually needed in v6a */
+extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
+#endif
+extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
+extern const int jpeg_natural_order7[]; /* zz to natural order for 7x7 block */
+extern const int jpeg_natural_order6[]; /* zz to natural order for 6x6 block */
+extern const int jpeg_natural_order5[]; /* zz to natural order for 5x5 block */
+extern const int jpeg_natural_order4[]; /* zz to natural order for 4x4 block */
+extern const int jpeg_natural_order3[]; /* zz to natural order for 3x3 block */
+extern const int jpeg_natural_order2[]; /* zz to natural order for 2x2 block */
+
+/* Arithmetic coding probability estimation tables in jaricom.c */
+extern const INT32 jpeg_aritab[];
+
+/* Suppress undefined-structure complaints if necessary. */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef AM_MEMORY_MANAGER    /* only jmemmgr.c defines these */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+#endif
+#endif /* INCOMPLETE_TYPES_BROKEN */
--- a/pnna/pnna-armhf/third-party/jpeg/include/jpeglib.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jpeglib.h
--- a/pnna/pnna-armhf/third-party/jpeg/include/jversion.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/jversion.h
@ -0,0 +1,14 @@
+/*
+ * jversion.h
+ *
+ * Copyright (C) 1991-2016, Thomas G. Lane, Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains software version identification.
+ */
+
+
+#define JVERSION    "9b  17-Jan-2016"
+
+#define JCOPYRIGHT    "Copyright (C) 2016, Thomas G. Lane, Guido Vollbeding"
--- a/pnna/pnna-armhf/third-party/jpeg/include/transupp.h
+++ b/pnna/pnna-armhf/third-party/jpeg/include/transupp.h
@ -0,0 +1,219 @@
+/*
+ * transupp.h
+ *
+ * Copyright (C) 1997-2013, Thomas G. Lane, Guido Vollbeding.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for image transformation routines and
+ * other utility code used by the jpegtran sample application.  These are
+ * NOT part of the core JPEG library.  But we keep these routines separate
+ * from jpegtran.c to ease the task of maintaining jpegtran-like programs
+ * that have other user interfaces.
+ *
+ * NOTE: all the routines declared here have very specific requirements
+ * about when they are to be executed during the reading and writing of the
+ * source and destination files.  See the comments in transupp.c, or see
+ * jpegtran.c for an example of correct usage.
+ */
+
+/* If you happen not to want the image transform support, disable it here */
+#ifndef TRANSFORMS_SUPPORTED
+#define TRANSFORMS_SUPPORTED 1        /* 0 disables transform code */
+#endif
+
+/*
+ * Although rotating and flipping data expressed as DCT coefficients is not
+ * hard, there is an asymmetry in the JPEG format specification for images
+ * whose dimensions aren't multiples of the iMCU size.  The right and bottom
+ * image edges are padded out to the next iMCU boundary with junk data; but
+ * no padding is possible at the top and left edges.  If we were to flip
+ * the whole image including the pad data, then pad garbage would become
+ * visible at the top and/or left, and real pixels would disappear into the
+ * pad margins --- perhaps permanently, since encoders & decoders may not
+ * bother to preserve DCT blocks that appear to be completely outside the
+ * nominal image area.  So, we have to exclude any partial iMCUs from the
+ * basic transformation.
+ *
+ * Transpose is the only transformation that can handle partial iMCUs at the
+ * right and bottom edges completely cleanly.  flip_h can flip partial iMCUs
+ * at the bottom, but leaves any partial iMCUs at the right edge untouched.
+ * Similarly flip_v leaves any partial iMCUs at the bottom edge untouched.
+ * The other transforms are defined as combinations of these basic transforms
+ * and process edge blocks in a way that preserves the equivalence.
+ *
+ * The "trim" option causes untransformable partial iMCUs to be dropped;
+ * this is not strictly lossless, but it usually gives the best-looking
+ * result for odd-size images.  Note that when this option is active,
+ * the expected mathematical equivalences between the transforms may not hold.
+ * (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim
+ * followed by -rot 180 -trim trims both edges.)
+ *
+ * We also offer a lossless-crop option, which discards data outside a given
+ * image region but losslessly preserves what is inside.  Like the rotate and
+ * flip transforms, lossless crop is restricted by the current JPEG format: the
+ * upper left corner of the selected region must fall on an iMCU boundary.  If
+ * this does not hold for the given crop parameters, we silently move the upper
+ * left corner up and/or left to make it so, simultaneously increasing the
+ * region dimensions to keep the lower right crop corner unchanged.  (Thus, the
+ * output image covers at least the requested region, but may cover more.)
+ * The adjustment of the region dimensions may be optionally disabled.
+ *
+ * A complementary lossless-wipe option is provided to discard (gray out) data
+ * inside a given image region while losslessly preserving what is outside.
+ *
+ * We also provide a lossless-resize option, which is kind of a lossless-crop
+ * operation in the DCT coefficient block domain - it discards higher-order
+ * coefficients and losslessly preserves lower-order coefficients of a
+ * sub-block.
+ *
+ * Rotate/flip transform, resize, and crop can be requested together in a
+ * single invocation.  The crop is applied last --- that is, the crop region
+ * is specified in terms of the destination image after transform/resize.
+ *
+ * We also offer a "force to grayscale" option, which simply discards the
+ * chrominance channels of a YCbCr image.  This is lossless in the sense that
+ * the luminance channel is preserved exactly.  It's not the same kind of
+ * thing as the rotate/flip transformations, but it's convenient to handle it
+ * as part of this package, mainly because the transformation routines have to
+ * be aware of the option to know how many components to work on.
+ */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jtransform_parse_crop_spec    jTrParCrop
+#define jtransform_request_workspace    jTrRequest
+#define jtransform_adjust_parameters    jTrAdjust
+#define jtransform_execute_transform    jTrExec
+#define jtransform_perfect_transform    jTrPerfect
+#define jcopy_markers_setup        jCMrkSetup
+#define jcopy_markers_execute        jCMrkExec
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/*
+ * Codes for supported types of image transformations.
+ */
+
+typedef enum {
+    JXFORM_NONE,        /* no transformation */
+    JXFORM_FLIP_H,        /* horizontal flip */
+    JXFORM_FLIP_V,        /* vertical flip */
+    JXFORM_TRANSPOSE,    /* transpose across UL-to-LR axis */
+    JXFORM_TRANSVERSE,    /* transpose across UR-to-LL axis */
+    JXFORM_ROT_90,        /* 90-degree clockwise rotation */
+    JXFORM_ROT_180,        /* 180-degree rotation */
+    JXFORM_ROT_270,        /* 270-degree clockwise (or 90 ccw) */
+    JXFORM_WIPE        /* wipe */
+} JXFORM_CODE;
+
+/*
+ * Codes for crop parameters, which can individually be unspecified,
+ * positive or negative for xoffset or yoffset,
+ * positive or forced for width or height.
+ */
+
+typedef enum {
+        JCROP_UNSET,
+        JCROP_POS,
+        JCROP_NEG,
+        JCROP_FORCE
+} JCROP_CODE;
+
+/*
+ * Transform parameters struct.
+ * NB: application must not change any elements of this struct after
+ * calling jtransform_request_workspace.
+ */
+
+typedef struct {
+  /* Options: set by caller */
+  JXFORM_CODE transform;    /* image transform operator */
+  boolean perfect;        /* if TRUE, fail if partial MCUs are requested */
+  boolean trim;            /* if TRUE, trim partial MCUs as needed */
+  boolean force_grayscale;    /* if TRUE, convert color image to grayscale */
+  boolean crop;            /* if TRUE, crop or wipe source image */
+
+  /* Crop parameters: application need not set these unless crop is TRUE.
+   * These can be filled in by jtransform_parse_crop_spec().
+   */
+  JDIMENSION crop_width;    /* Width of selected region */
+  JCROP_CODE crop_width_set;    /* (forced disables adjustment) */
+  JDIMENSION crop_height;    /* Height of selected region */
+  JCROP_CODE crop_height_set;    /* (forced disables adjustment) */
+  JDIMENSION crop_xoffset;    /* X offset of selected region */
+  JCROP_CODE crop_xoffset_set;    /* (negative measures from right edge) */
+  JDIMENSION crop_yoffset;    /* Y offset of selected region */
+  JCROP_CODE crop_yoffset_set;    /* (negative measures from bottom edge) */
+
+  /* Internal workspace: caller should not touch these */
+  int num_components;        /* # of components in workspace */
+  jvirt_barray_ptr * workspace_coef_arrays; /* workspace for transformations */
+  JDIMENSION output_width;    /* cropped destination dimensions */
+  JDIMENSION output_height;
+  JDIMENSION x_crop_offset;    /* destination crop offsets measured in iMCUs */
+  JDIMENSION y_crop_offset;
+  JDIMENSION drop_width;    /* drop/wipe dimensions measured in iMCUs */
+  JDIMENSION drop_height;
+  int iMCU_sample_width;    /* destination iMCU size */
+  int iMCU_sample_height;
+} jpeg_transform_info;
+
+
+#if TRANSFORMS_SUPPORTED
+
+/* Parse a crop specification (written in X11 geometry style) */
+EXTERN(boolean) jtransform_parse_crop_spec
+    JPP((jpeg_transform_info *info, const char *spec));
+/* Request any required workspace */
+EXTERN(boolean) jtransform_request_workspace
+    JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info));
+/* Adjust output image parameters */
+EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters
+    JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+         jvirt_barray_ptr *src_coef_arrays,
+         jpeg_transform_info *info));
+/* Execute the actual transformation, if any */
+EXTERN(void) jtransform_execute_transform
+    JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+         jvirt_barray_ptr *src_coef_arrays,
+         jpeg_transform_info *info));
+/* Determine whether lossless transformation is perfectly
+ * possible for a specified image and transformation.
+ */
+EXTERN(boolean) jtransform_perfect_transform
+    JPP((JDIMENSION image_width, JDIMENSION image_height,
+         int MCU_width, int MCU_height,
+         JXFORM_CODE transform));
+
+/* jtransform_execute_transform used to be called
+ * jtransform_execute_transformation, but some compilers complain about
+ * routine names that long.  This macro is here to avoid breaking any
+ * old source code that uses the original name...
+ */
+#define jtransform_execute_transformation    jtransform_execute_transform
+
+#endif /* TRANSFORMS_SUPPORTED */
+
+
+/*
+ * Support for copying optional markers from source to destination file.
+ */
+
+typedef enum {
+    JCOPYOPT_NONE,        /* copy no optional markers */
+    JCOPYOPT_COMMENTS,    /* copy only comment (COM) markers */
+    JCOPYOPT_ALL        /* copy all optional markers */
+} JCOPY_OPTION;
+
+#define JCOPYOPT_DEFAULT  JCOPYOPT_COMMENTS    /* recommended default */
+
+/* Setup decompression object to save desired markers in memory */
+EXTERN(void) jcopy_markers_setup
+    JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option));
+/* Copy markers saved in the given source object to the destination object */
+EXTERN(void) jcopy_markers_execute
+    JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+         JCOPY_OPTION option));
--- a/pnna/pnna-armhf/third-party/jpeg/lib/libjpeg.a
+++ b/pnna/pnna-armhf/third-party/jpeg/lib/libjpeg.a
--- a/pnna/pnna-c6x/DSP端部署说明.md
+++ b/pnna/pnna-c6x/DSP端部署说明.md
@ -0,0 +1,258 @@
+# DSP端PNNA应用部署
+
+
+
+## 一、概述
+
+本项目为 DSP 做主控时，说明如何通过 Lite 驱动，在 pnna 上部署应用程序的过程。
+
+------
+
+
+
+## 二、环境搭建
+
+### 2.1 环境要求
+
+- 目标板：FT78E_DSKC_202311V0
+
+- 目标板配套的电源
+
+- 仿真器FT-EMU560及USB连接线
+
+- CCS版本：CCS7.4，编译器版本 v8.2.2。（请自行安装）
+
+### 2.2 所需文件
+
+```shell
+pnna-c6x
+  |
+  ├── c6x_DDR_init            
+  |   |
+  |   └── c6x_DDR_init.out            /* DDR 初始化可执行程序 */
+  |
+  ├── project                         /* CCS 工程文件夹 */
+  |   |
+  │   ├── 78E.ccxml                   /* 描述和配置调试器连接信息 */
+  |   |
+  │   └── 78E.cmd                     /* 内存布局和程序段在内存中的放置情况 */
+  |
+  ├── pnna-drivers                    /* lite 驱动相关、DSP 端 PSC 相关的头文件和库文件 */
+  |
+  ├── emulation-drivers               /* 芯片相关驱动 */
+  |
+  ├── USB仿真器设备驱动.rar            /* Windows下仿真器的安装驱动 */
+  |
+  └── DSP端部署说明.md  
+```
+
+### 2.3 驱动安装
+
+- 找到CCS安装目录，如：X:\ti\ccsv7\ccs_base\emulation。
+
+- 备份driver目录。
+
+- 将**emulation-drivers**文件中的所有文件添加至driver目录，如果有相同文件，则选择替换原来的文件。
+
+- 解压 **USB仿真器设备驱动.rar**，完成后再解压**CDM21228_Setup.zip**，双击运行**CDM21228_Setup.exe**，安装仿真器驱动，如果是内网机器，联系系统管理员开启USB权限。
+
+
+### 2.4 连接仿真器
+
+- 连接好目标板电源。
+
+- 连接仿真器，一端接电脑USB，另一端接到板子的 **JTAG_DSP** 口。
+
+
+  其中，仿真器的RUN灯亮表示正常工作，ERROR灯亮表示连接异常，如果出现这种现象，需要重新插拔仿真器，如果重新插拔仿真器后还是有问题，需要重启目标板和仿真器。
+
+------
+
+
+## 三、导入工程
+
+  ### 3.1 将**project** 工程添加至CCS工作目录
+
+1. 创建 CCS 工作目录。复制安装目录中的 **project** 工程到 CCS 工作目录。
+
+2. 将 **example** 文件夹复制 CCS 工作目录中的 **project** 工程中。
+   **example** 目录结构及其主要功能，详见 example 下 ***.md** 文件
+
+3. 打开CCS7.4
+
+4. 打开file -> import -> C/C++ -> CCS Projects -> Next
+
+5. 选择Select search-directory -> **project** 文件夹 -> Finish
+
+  ### 3.2 添加依赖的库文件和头文件
+  
+  库文件和头文件在 **pnna-c6x/pnna-drivers** 目录中。
+
+1. 拷贝 **pnna-c6x/pnna-drivers** 中文件到工作目录，**注意：尽量避免中文路径。**
+
+2. 左键单击工程，右键 -> Properties -> Build -> C6000 Compiler -> Include Options中添加头文件
+
+   - 将 **pnna-drivers/include** 中头文件路径都添加至 "Add dir to #include search path" 一栏中
+
+3. 左键单击工程，右键 -> Properties -> Build -> C6000 Linker -> File search Path中添加库文件
+
+   - 将 **pnna-drivers/lib** 的路径添加至 "Add dir to library search path" 一栏中
+
+   - 将 **pnna-drivers/lib** 中所有的 lib 库名字（全称）填写至 "Include library file or command file as input" 一栏中
+
+4. 点击 "OK" 按钮，即添加完成。 
+  **相同的方法可添加其他网络模型示例工程。**
+
+------
+
+
+## 四、连接至目标板
+
+1. View->Target Configurations，**project** 工程中，有一个78E.ccxml文件。
+
+2. 右键78E.ccxml，选择Launch Selected Configuration，会跳转至调试界面，将出现8个DSP核和1个arm核连接的Debug界面
+
+3. 选择第一个**C66xx_0**核，Connect Target。连接成功会在核0下方出现如下字样：
+
+  ``` shell
+  0x20B00000 (no symbols are defined)
+  ```
+
+4. 至此，已成功连接至目标板，可下载程序至DSP核并运行，但在运行程序前，需要先初始化DDR。
+
+------
+
+
+## 五、初始化DDR
+
+  将 **c6x_DDR_init** 文件夹中的 **c6x_DDR_init.out** 可执行程序添加至 CCS 工作目录。
+
+1. 成功连接至目标板后，选择Run -> Load -> Load program... 或单击下载程序图标按钮。
+
+2. 在Program file一栏选择 **c6x_DDR_init.out** 文件，点击OK。
+
+3. 运行程序。Run -> Resume  或单击运行程序图标按钮。
+
+4. 程序最后几行打印如下，即可表示初始化DDR成功。如果目标板重新断电或者CCS重新启动，都需要重新运行初始化DDR程序。
+
+  ```shell
+    slice 0, PHY_PAD_VREF_CT = 0x4ab
+    slice 1, PHY_PAD_VREF_CT = 0x4a9
+    slice 2, PHY_PAD_VREF_CT = 0x4ad
+    slice 3, PHY_PAD_VREF_CT = 0x4a9
+    slice 4, PHY_PAD_VREF_CT = 0x4ab
+    slice 5, PHY_PAD_VREF_CT = 0x4af
+    slice 6, PHY_PAD_VREF_CT = 0x4a6
+    slice 7, PHY_PAD_VREF_CT = 0x4a8
+    slice 8, PHY_PAD_VREF_CT = 0x4a8
+    Start CTL address bist 
+    CTL Address bist passed
+    Start CTL data bist 
+    CTL Data bist passed
+    Start PI addr bist 
+    DDR4 addr bist pass!
+    Start PI data bist 
+    DDR data bist pass!
+    DDR zero memory start...
+    zero memory done
+  ```
+
+
+------
+
+
+## 六、程序运行
+
+### 6.1 编译和加载程序
+
+1. DSP端的 **project** 示例工程已添加至CCS7.4中。
+
+2. 找到 **nn_api.h** 文件中的定义：
+  
+  ```C
+  #define     NETWORK_ADDRS           0xE0000000      //NBG
+  #define     INPUT_DAT0_ADDRS        0xE1000000      //input_0.dat
+  #define     INPUT_DAT1_ADDRS        0xE2000000      //input_1.dat
+  #define     MY_NETWORK_SIZE         3816092          //yolov4-tiny NBG
+  #define     MY_INPUT_SIZE           519168           //yolov4-tiny input_0.dat
+  ```
+  其中，
+  - MY_INPUT_SIZE： 输入图片二进制的大小
+
+  - MY_NETWORK_SIZE： 网络模型文件NBG的大小。大小根据windows下，文件的属性->常规->大小确定。
+
+  - NBG_ADDRESS： NBG文件存放内存位置
+
+  - INPUT_DAT0_ADDRS： 输入图片存放内存位置
+
+  - INPUT_DAT1_ADDRS： 输入图片存放内存位置  （2个输入循环推理的时候可以用到）
+
+3. 根据NBG文件和图片的二进制文件大小，分别修改MY_INPUT_SIZE和MY_NETWORK_SIZE中的值。
+
+4. 示例中不需要修改。如果更改了参数，则需要重新编译工程。
+
+5. 在运行网络模型示例程序前，需要先连接至目标板并初始化DDR。
+
+6. 打开View->Memory Browser界面，点击load memory
+
+7. 根据文件中定义的地址**NBG_ADDRESS**和**DATA_ADDRESS**，分别下载NBG文件和图片文件，文件类型均选择Binary。
+
+8. 下载程序：Run -> Load -> Load program... 或单击下载程序图标按钮。选择该工程Debug目录下“xxx.out”，其中，xxx为工程名。
+
+9. 运行程序：Run -> Resume 
+
+- ***如果需要更换其他数据类型的网络模型，需要替换文件中 MY_INPUT_SIZE 和 MY_NETWORK_SIZE，同时重新下载 input_0.dat 和 network_binary.nb 即可。***
+
+### 6.2 输出结果
+
+  推理结果分别表示：目标类别、分数、中心点坐标x、中心点坐标y、框的宽、框的高
+
+  ```shell
+  start to run network=network_binary.nb, times=1
+  run network done...
+  profile inference time=0.000000ms, cycle=9392210
+
+  boxes number: 10
+  2 0.460957 0.775011 0.223272 0.305353 0.176144
+  16 0.902439 0.289818 0.642779 0.259141 0.637094
+  1 0.732628 0.423077 0.504524 0.660328 0.612339
+  7 0.745452 0.759695 0.218838 0.341707 0.176144
+  ```
+
+  ***请注意：程序只能推理二进制文件，并且 NBG 文件和输入文件都是在程序开始运行前，通过仿真器，先加载至 DDR 的固定位置。***
+
+
+------
+
+
+## 七、流程解释
+
+### 7.1 应用程序推理流程
+
+1. 应用程序读取待处理数据，根据数据类型进行预处理操作，选择是否需要归一化和量化。
+
+2. 预处理操作完成后将待推理数据和NBG文件交给PNNA核进行推理。
+
+3. 推理完成后将数据进行反量化操作，并根据模型类型进行相应的分类或检测等处理。
+
+4. 最后输出结果。
+
+
+### 7.2 编译、运行流程
+
+1. 通过 CCS 编译推理工程
+
+2. 将 NBG 文件和待推理数据传输至板卡上的 DDR 固定位置
+
+3. 板卡上主控制器（CPU / DSP）根据可执行程序内容，将 DDR 固定位置的 NBG 文件和待处理数据通过驱动加载至 PNNA 核上运行，处理完成后通知主控制器到固定地址取回结果
+
+
+------
+
+
+
+  <div align="center">Please contact us if you have any questions.</div>
+  <div align="center">Author : @xun</div>
+  <div align="center">Copyright (c) 2024 @ccyh</div>
+
+
--- a/pnna/pnna-c6x/USB仿真器设备驱动.rar
+++ b/pnna/pnna-c6x/USB仿真器设备驱动.rar
--- a/pnna/pnna-c6x/c6x_DDR_init/.ccsproject
+++ b/pnna/pnna-c6x/c6x_DDR_init/.ccsproject
@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<?ccsproject version="1.0"?>
+<projectOptions>
+	<deviceVariant value="com.ti.ccstudio.deviceModel.C6000.GenericC66xxDevice"/>
+	<deviceFamily value="C6000"/>
+	<deviceEndianness value="little"/>
+	<codegenToolVersion value="7.4.4"/>
+	<isElfFormat value="false"/>
+	<rts value="libc.a"/>
+	<templateProperties value="id=com.ti.ccstudio.project.templates.emptyAssemblyOnly,isAssemblyOnly=true,"/>
+	<isTargetManual value="false"/>
+</projectOptions>
--- a/pnna/pnna-c6x/c6x_DDR_init/.cproject
+++ b/pnna/pnna-c6x/c6x_DDR_init/.cproject
@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?fileVersion 4.0.0?>
+
+<cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
+	<storageModule configRelations="2" moduleId="org.eclipse.cdt.core.settings">
+		<cconfiguration id="com.ti.ccstudio.buildDefinitions.C6000.Debug.809847480">
+			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="com.ti.ccstudio.buildDefinitions.C6000.Debug.809847480" moduleId="org.eclipse.cdt.core.settings" name="Debug">
+				<externalSettings/>
+				<extensions>
+					<extension id="com.ti.ccstudio.binaryparser.CoffParser" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="com.ti.ccstudio.errorparser.CoffErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.LinkErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.AsmErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+				</extensions>
+			</storageModule>
+			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+				<configuration artifactExtension="out" artifactName="${ProjName}" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.C6000.Debug.809847480" name="Debug" parent="com.ti.ccstudio.buildDefinitions.C6000.Debug">
+					<folderInfo id="com.ti.ccstudio.buildDefinitions.C6000.Debug.809847480." name="/" resourcePath="">
+						<toolChain id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.DebugToolchain.2131718197" name="TI Build Tools" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.DebugToolchain" targetTool="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerDebug.1432799099">
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS.1965335426" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS" valueType="stringList">
+								<listOptionValue builtIn="false" value="DEVICE_CONFIGURATION_ID=com.ti.ccstudio.deviceModel.C6000.GenericC66xxDevice"/>
+								<listOptionValue builtIn="false" value="DEVICE_ENDIANNESS=little"/>
+								<listOptionValue builtIn="false" value="OUTPUT_FORMAT=ELF"/>
+								<listOptionValue builtIn="false" value="CCS_MBS_VERSION=5.5.0"/>
+								<listOptionValue builtIn="false" value="LINKER_COMMAND_FILE=M8024V.cmd"/>
+								<listOptionValue builtIn="false" value="RUNTIME_SUPPORT_LIBRARY=libc.a"/>
+								<listOptionValue builtIn="false" value="OUTPUT_TYPE=executable"/>
+							</option>
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION.799753310" name="Compiler version" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION" value="7.4.4" valueType="string"/>
+							<targetPlatform id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.targetPlatformDebug.8960912" name="Platform" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.targetPlatformDebug"/>
+							<builder buildPath="${BuildDirectory}" id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.builderDebug.375223141" keepEnvironmentInBuildfile="false" name="GNU Make" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.builderDebug"/>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.compilerDebug.122488386" name="C6000 Compiler" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.compilerDebug">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.SILICON_VERSION.302922535" name="Target processor version (--silicon_version, -mv)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.SILICON_VERSION" value="6600" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI.1159138410" name="Application binary interface (coffabi, eabi) [See 'General' page to edit] (--abi)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI.eabi" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DEBUGGING_MODEL.491539482" name="Debugging model" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DEBUGGING_MODEL" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DEBUGGING_MODEL.SYMDEBUG__DWARF" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.INCLUDE_PATH.1208184852" name="Add dir to #include search path (--include_path, -I)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.INCLUDE_PATH" valueType="includePath">
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${PDK_INSTALL_PATH}\packages&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${PDK_INSTALL_PATH}\packages\ti&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${PDK_INSTALL_PATH}\packages\ti\csl&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/include}&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/src}&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DISPLAY_ERROR_NUMBER.1871189191" name="Emit diagnostic identifier numbers (--display_error_number, -pden)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WARNING.201199310" name="Treat diagnostic &lt;id&gt; as warning (--diag_warning, -pdsw)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WARNING" valueType="stringList">
+									<listOptionValue builtIn="false" value="225"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP.1367058196" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.OPT_LEVEL.1670790659" name="Optimization level (--opt_level, -O)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.OPT_LEVEL" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.OPT_LEVEL._none" valueType="enumerated"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__C_SRCS.1495795263" name="C Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__C_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__CPP_SRCS.984488237" name="C++ Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__CPP_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM_SRCS.223852194" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM2_SRCS.1460590320" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM2_SRCS"/>
+							</tool>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerDebug.1432799099" name="C6000 Linker" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerDebug">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.OUTPUT_FILE.1289647272" name="Specify output file name (--output_file, -o)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.OUTPUT_FILE" value="&quot;${ProjName}.out&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.STACK_SIZE.1671495856" name="Set C system stack size (--stack_size, -stack)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.STACK_SIZE" value="0" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.MAP_FILE.309341989" name="Input and output sections listed into &lt;file&gt; (--map_file, -m)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.MAP_FILE" value="&quot;${ProjName}.map&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.HEAP_SIZE.1462436000" name="Heap size for C/C++ dynamic memory allocation (--heap_size, -heap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.HEAP_SIZE" value="0" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.SEARCH_PATH.11722505" name="Add &lt;dir&gt; to library search path (--search_path, -i)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.SEARCH_PATH" valueType="libPaths">
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/lib&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DISPLAY_ERROR_NUMBER.1098452702" name="Emit diagnostic identifier numbers (--display_error_number)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP.1716964386" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.XML_LINK_INFO.480970479" name="Detailed link information data-base into &lt;file&gt; (--xml_link_info, -xml_link_info)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.XML_LINK_INFO" value="&quot;${ProjName}_linkInfo.xml&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.INITIALIZATION_MODEL.1784051409" name="Initialization model" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.INITIALIZATION_MODEL" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.INITIALIZATION_MODEL._none" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.LIBRARY.2096965755" name="Include library file or command file as input (--library, -l)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.LIBRARY" valueType="libs">
+									<listOptionValue builtIn="false" value="&quot;libc.a&quot;"/>
+								</option>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD_SRCS.90021256" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD2_SRCS.1064901570" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD2_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__GEN_CMDS.742301679" name="Generated Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__GEN_CMDS"/>
+							</tool>
+						</toolChain>
+					</folderInfo>
+				</configuration>
+			</storageModule>
+			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+		</cconfiguration>
+		<cconfiguration id="com.ti.ccstudio.buildDefinitions.C6000.Release.1147125045">
+			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="com.ti.ccstudio.buildDefinitions.C6000.Release.1147125045" moduleId="org.eclipse.cdt.core.settings" name="Release">
+				<externalSettings/>
+				<extensions>
+					<extension id="com.ti.ccstudio.binaryparser.CoffParser" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="com.ti.ccstudio.errorparser.CoffErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.LinkErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.AsmErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+				</extensions>
+			</storageModule>
+			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+				<configuration artifactExtension="out" artifactName="${ProjName}" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.C6000.Release.1147125045" name="Release" parent="com.ti.ccstudio.buildDefinitions.C6000.Release">
+					<folderInfo id="com.ti.ccstudio.buildDefinitions.C6000.Release.1147125045." name="/" resourcePath="">
+						<toolChain id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.ReleaseToolchain.861138469" name="TI Build Tools" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.ReleaseToolchain" targetTool="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerRelease.1251394529">
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS.795705974" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS" valueType="stringList">
+								<listOptionValue builtIn="false" value="DEVICE_CONFIGURATION_ID=com.ti.ccstudio.deviceModel.C6000.GenericC66xxDevice"/>
+								<listOptionValue builtIn="false" value="DEVICE_ENDIANNESS=little"/>
+								<listOptionValue builtIn="false" value="OUTPUT_FORMAT=ELF"/>
+								<listOptionValue builtIn="false" value="CCS_MBS_VERSION=5.5.0"/>
+								<listOptionValue builtIn="false" value="RUNTIME_SUPPORT_LIBRARY=libc.a"/>
+								<listOptionValue builtIn="false" value="OUTPUT_TYPE=executable"/>
+							</option>
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION.475525490" name="Compiler version" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION" value="7.4.4" valueType="string"/>
+							<targetPlatform id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.targetPlatformRelease.143043871" name="Platform" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.targetPlatformRelease"/>
+							<builder buildPath="${BuildDirectory}" id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.builderRelease.2042255518" keepEnvironmentInBuildfile="false" name="GNU Make" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.builderRelease"/>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.compilerRelease.939662382" name="C6000 Compiler" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.compilerRelease">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.SILICON_VERSION.1395940148" name="Target processor version (--silicon_version, -mv)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.SILICON_VERSION" value="6600" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI.1455098265" name="Application binary interface (coffabi, eabi) [See 'General' page to edit] (--abi)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI.eabi" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.INCLUDE_PATH.2040775166" name="Add dir to #include search path (--include_path, -I)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.INCLUDE_PATH" valueType="includePath">
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/include}&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;../../../common/src&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/src}&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DISPLAY_ERROR_NUMBER.478839562" name="Emit diagnostic identifier numbers (--display_error_number, -pden)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WARNING.426989114" name="Treat diagnostic &lt;id&gt; as warning (--diag_warning, -pdsw)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WARNING" valueType="stringList">
+									<listOptionValue builtIn="false" value="225"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP.554743198" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__C_SRCS.401745140" name="C Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__C_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__CPP_SRCS.1872360106" name="C++ Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__CPP_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM_SRCS.1060005752" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM2_SRCS.1335026280" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM2_SRCS"/>
+							</tool>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerRelease.1251394529" name="C6000 Linker" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerRelease">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.OUTPUT_FILE.1832706734" name="Specify output file name (--output_file, -o)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.OUTPUT_FILE" value="&quot;${ProjName}.out&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.STACK_SIZE.28129130" name="Set C system stack size (--stack_size, -stack)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.STACK_SIZE" value="0" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.MAP_FILE.2073283757" name="Input and output sections listed into &lt;file&gt; (--map_file, -m)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.MAP_FILE" value="&quot;${ProjName}.map&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.HEAP_SIZE.1208810611" name="Heap size for C/C++ dynamic memory allocation (--heap_size, -heap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.HEAP_SIZE" value="0" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.SEARCH_PATH.1790630867" name="Add &lt;dir&gt; to library search path (--search_path, -i)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.SEARCH_PATH" valueType="libPaths">
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/lib&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DISPLAY_ERROR_NUMBER.852293668" name="Emit diagnostic identifier numbers (--display_error_number)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP.634489353" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.XML_LINK_INFO.2134716789" name="Detailed link information data-base into &lt;file&gt; (--xml_link_info, -xml_link_info)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.XML_LINK_INFO" value="&quot;${ProjName}_linkInfo.xml&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.INITIALIZATION_MODEL.632108381" name="Initialization model" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.INITIALIZATION_MODEL" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.INITIALIZATION_MODEL._none" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.LIBRARY.630890919" name="Include library file or command file as input (--library, -l)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.LIBRARY" valueType="libs">
+									<listOptionValue builtIn="false" value="&quot;libc.a&quot;"/>
+								</option>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD_SRCS.563594088" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD2_SRCS.2037789598" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD2_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__GEN_CMDS.763343447" name="Generated Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__GEN_CMDS"/>
+							</tool>
+						</toolChain>
+					</folderInfo>
+					<sourceEntries>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+					</sourceEntries>
+				</configuration>
+			</storageModule>
+			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+		</cconfiguration>
+	</storageModule>
+	<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
+	<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+		<project id="C66_L2_08_DDR_for8024v.com.ti.ccstudio.buildDefinitions.C6000.ProjectType.1810363256" name="C6000" projectType="com.ti.ccstudio.buildDefinitions.C6000.ProjectType"/>
+	</storageModule>
+	<storageModule moduleId="scannerConfiguration"/>
+	<storageModule moduleId="org.eclipse.cdt.core.language.mapping">
+		<project-mappings>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.asmSource" language="com.ti.ccstudio.core.TIASMLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cHeader" language="com.ti.ccstudio.core.TIGCCLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cSource" language="com.ti.ccstudio.core.TIGCCLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cxxHeader" language="com.ti.ccstudio.core.TIGPPLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cxxSource" language="com.ti.ccstudio.core.TIGPPLanguage"/>
+		</project-mappings>
+	</storageModule>
+</cproject>
--- a/pnna/pnna-c6x/c6x_DDR_init/.project
+++ b/pnna/pnna-c6x/c6x_DDR_init/.project
@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>c6x_DDR_init</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
+			<triggers>full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.ti.ccstudio.core.ccsNature</nature>
+		<nature>org.eclipse.cdt.core.cnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
+		<nature>org.eclipse.cdt.core.ccnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+	</natures>
+	<variableList>
+		<variable>
+			<name>PDK_INSTALL_PATH</name>
+			<value>file:/C:/ti/pdk_C6678_1_1_2_6</value>
+		</variable>
+	</variableList>
+</projectDescription>
--- a/pnna/pnna-c6x/c6x_DDR_init/.settings/org.eclipse.cdt.codan.core.prefs
+++ b/pnna/pnna-c6x/c6x_DDR_init/.settings/org.eclipse.cdt.codan.core.prefs
@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+inEditor=false
+onBuild=false
--- a/pnna/pnna-c6x/c6x_DDR_init/.settings/org.eclipse.cdt.debug.core.prefs
+++ b/pnna/pnna-c6x/c6x_DDR_init/.settings/org.eclipse.cdt.debug.core.prefs
@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+org.eclipse.cdt.debug.core.toggleBreakpointModel=com.ti.ccstudio.debug.CCSBreakpointMarker
--- a/pnna/pnna-c6x/c6x_DDR_init/.settings/org.eclipse.core.resources.prefs
+++ b/pnna/pnna-c6x/c6x_DDR_init/.settings/org.eclipse.core.resources.prefs
@ -0,0 +1,13 @@
+eclipse.preferences.version=1
+encoding//Debug/makefile=UTF-8
+encoding//Debug/objects.mk=UTF-8
+encoding//Debug/sources.mk=UTF-8
+encoding//Debug/src/subdir_rules.mk=UTF-8
+encoding//Debug/src/subdir_vars.mk=UTF-8
+encoding//Debug/subdir_rules.mk=UTF-8
+encoding//Debug/subdir_vars.mk=UTF-8
+encoding//include/mcu_config.h=UTF-8
+encoding//src/ECC_test.c=UTF-8
+encoding//src/dram_init.c=UTF-8
+encoding//src/main.c=UTF-8
+encoding//src/mcu_test.c=UTF-8
--- a/pnna/pnna-c6x/c6x_DDR_init/78E.cmd
+++ b/pnna/pnna-c6x/c6x_DDR_init/78E.cmd
@ -0,0 +1,45 @@
+/******************************************************************************/
+/*                                                                            */
+/*                               M6678V4.cmd                                   */
+/*                         Copyright (c): FTDSP                               */
+/*                                                                            */
+/*                                                                            */
+/*    Description: This file is a sample linker command file that can be      */
+/*                 used for linking programs built with the C compiler and    */
+/*                 running the resulting .out file on an M6678V4               */
+/*                 device.  Use it as a guideline.  You will want to          */
+/*                 change the memory layout to match your specific C6xxx      */
+/*                 target system.  You may want to change the allocation      */
+/*                 scheme according to the size of your program.              */
+/*                                                                            */
+/*                                                                            */
+/******************************************************************************/
+
+-c
+-heap  0x001000
+-stack 0x001000
+
+MEMORY
+{
+	/*³¬½Úµã0*/
+	vectors:       o = 0x0C000000  l = 0x00000200
+	SMC0:	       o = 0x0C000200  l = 0x001FFE00 /*SMC 2MB*/
+}
+
+SECTIONS
+{
+	vector         >  vectors
+	.text          >  SMC0
+	.stack         >  SMC0
+	.bss           >  SMC0
+	.cio           >  SMC0
+	.const         >  SMC0
+	.data          >  SMC0
+	.switch        >  SMC0
+	.sysmem        >  SMC0
+	.far           >  SMC0
+	.cinit         >  SMC0
+	.fardata       >  SMC0
+	.rodata        >  SMC0
+	.neardata      >  SMC0
+}
--- a/pnna/pnna-c6x/c6x_DDR_init/Debug/c6x_DDR_init.out
+++ b/pnna/pnna-c6x/c6x_DDR_init/Debug/c6x_DDR_init.out
--- a/pnna/pnna-c6x/c6x_DDR_init/include/CORE_Memory_Test.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/CORE_Memory_Test.h
@ -0,0 +1,43 @@
+/**
+**************************************************************************************************************************************************************
+*  @file 			CORE_Memory_Test.h
+*  @brief  		用于存储体测试的函数声明。
+*  @version 		V1.0
+*  @data			2023.07.07
+*  @attention
+*   \par
+*   ===================================================================================================
+*   @n	(c)	飞腾DSP技术支持团队.
+**************************************************************************************************************************************************************
+*/
+#ifndef DSP_CORE_TEST_H_
+#define DSP_CORE_TEST_H_
+
+extern void DSP_memory_test(unsigned int uiStartAddress,
+	                    unsigned int uiStopAddress,
+	                    unsigned int uiStep,
+	                    char * mem_name);
+extern void pass_fail_count(int iResult);
+
+extern unsigned int MEM_FillTest(unsigned int uiStartAddress,
+                        unsigned int uiCount,
+                        unsigned long long ulBitPattern,
+                        unsigned int uiStep);
+unsigned int MEM_FillTest_32bit(unsigned int uiStartAddress,
+                        unsigned int uiCount,
+                        unsigned int ulBitPattern_32bit,
+                        unsigned int uiStep);
+extern unsigned int MEM_AddrTest(unsigned int uiStartAddress,
+						unsigned int uiCount,
+                        int iStep);
+unsigned int MEM_AddrTest_32bit(unsigned int uiStartAddress,
+						unsigned int uiCount,
+                        int iStep);
+extern unsigned int MEM_Bit_Walking(unsigned int uiStartAddress,
+						unsigned int uiCount,
+                        unsigned int uiStep);
+extern int DSP_core_MEM_Test(unsigned int uiStartAddress,
+		                unsigned int uiStopAddress,
+		                unsigned int uiStep);
+
+#endif /* DSP_CORE_TEST_H_ */
--- a/pnna/pnna-c6x/c6x_DDR_init/include/M6678V4_PLL.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/M6678V4_PLL.h
@ -0,0 +1,79 @@
+/**
+********************************************************************************
+* @file       M6678V4_PLL.h
+* @brief      用于实现M6678V4 PLL设置的各种接口函数的声明和寄存器宏定义。
+* @version    V1.0
+* @date       2023.12.22
+* @attention
+* \par
+* ============================================================================
+* @n   (C) 飞腾DSP技术支持团队.
+********************************************************************************
+*/
+#ifndef __M6678V4_PLL_H_
+#define __M6678V4_PLL_H_
+#include <stdint.h>
+
+#define	KICK0 			*(volatile	unsigned int *)0x09000038
+#define	KICK1			*(volatile	unsigned int *)0x0900003C
+
+/********************* DSP_PLL 寄存器 ************************************************/
+#define	DSP_PLLCTL		*(volatile	unsigned int *)0x09020100
+#define	DSP_PLLCMD		*(volatile	unsigned int *)0x09020104
+#define	DSP_PLLDIV		*(volatile	unsigned int *)0x09020108
+
+/********************* NOC_PLL 寄存器 ************************************************/
+#define	NOC_PLLCTL		*(volatile	unsigned int *)0x09020110
+#define	NOC_PLLCMD		*(volatile	unsigned int *)0x09020114
+
+/********************* SYS_PLL 寄存器 ************************************************/
+#define	SYS_PLLCTL		*(volatile	unsigned int *)0x09020120
+#define	SYS_PLLCMD		*(volatile	unsigned int *)0x09020124
+#define	SYS_PLLDIV1		*(volatile	unsigned int *)0x09020128
+
+/********************* PCIE_PLL 寄存器 ************************************************/
+#define	PCIE_PLLCTL		*(volatile	unsigned int *)0x09020130
+#define	PCIE_PLLCMD		*(volatile	unsigned int *)0x09020134
+
+/********************* DDR_PLL 寄存器 ************************************************/
+#define	DDR_PLLCTL		*(volatile	unsigned int *)0x09020140
+#define	DDR_PLLCMD		*(volatile	unsigned int *)0x09020144
+
+/********************* ACC_PLL 寄存器 ************************************************/
+#define	ACC_PLLCTL		*(volatile	unsigned int *)0x09020150
+#define	ACC_PLLCMD		*(volatile	unsigned int *)0x09020154
+#define	ACC_PLLDIV1		*(volatile	unsigned int *)0x09020158
+#define	ACC_PLLDIV2		*(volatile	unsigned int *)0x0902015C
+
+
+/********************* SRIO_PLL 寄存器 ************************************************/
+#define	SRIO_PLLCTL	*(volatile	unsigned int *)0x09020160
+#define	SRIO_PLLCMD	*(volatile	unsigned int *)0x09020164
+
+/********************* SRIO_PLL 寄存器 ************************************************/
+#define	ARM_PLLCTL		*(volatile	unsigned int *)0x09020170
+#define	ARM_PLLCMD		*(volatile	unsigned int *)0x09020174
+#define	ARM_PLLDIV		*(volatile	unsigned int *)0x09020178
+
+/********************* SRIO2_PLL 寄存器 ************************************************/
+#define	SRIO2_PLLCTL	*(volatile	unsigned int *)0x09020180
+#define	SRIO2_PLLCMD	*(volatile	unsigned int *)0x09020184
+
+// 函数声明
+void DSP_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void NOC_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void SYS_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void PCIE_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void DDR_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void ACC_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void SRIO_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void ARM_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void SRIO2_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void DSPCLKV_PLL	(uint8_t RATIO);
+void ARMCLKV_PLL	(uint8_t RATIO_arm);
+void ACC_FFT_PLL	(uint8_t RATIO1);
+void ACC_VIP_PLL	(uint8_t RATIO2);
+
+
+
+#endif /* __M6678V4_PLL_H_ */
--- a/pnna/pnna-c6x/c6x_DDR_init/include/M6678V4_PSC.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/M6678V4_PSC.h
@ -0,0 +1,74 @@
+/** 
+********************************************************************************
+* @file       M6678V4_PSC.h
+* @brief      用于声明M6678V4开时钟接口函数和寄存器宏定义。
+* @version    V1.0
+* @date       2022.8.20
+* @attention  
+* \par
+* ============================================================================
+* @n   (C) 飞腾DSP技术支持团队.
+********************************************************************************
+*/
+#ifndef   _M6678V4_PSC_H_
+#define   _M6678V4_PSC_H_
+
+/***************PSC 接口函数声明***************************************************/
+extern void PSC_Open_Clk(const char *string , unsigned int Power_Domain);
+extern void PSC_Close_Clk(const char *string , unsigned int Power_Domain);
+
+/***************PSC 寄存器*******************************************************/
+#define PSC_BASE            0x09080000
+#define PTCMD_REG           0x09080120
+#define PTSTAT_REG	        0x09080128
+
+/***************PSC 模块时钟寄存器**************************************************/
+
+#define	DSP0CORE_offset		0xA04
+#define DSP1CORE_offset    	0xA08
+#define DSP2CORE_offset     0xA0C
+#define DSP3CORE_offset     0xA10
+#define DSP4CORE_offset     0xA14
+#define DSP5CORE_offset    	0xA18
+#define DSP6CORE_offset   	0xA1C
+#define DSP7CORE_offset    	0xA20
+
+#define DSP0_offset    		0xA28
+#define DSP1_offset    		0xA2C
+#define DSP2_offset    		0xA30
+#define DSP3_offset    		0xA34
+#define DSP4_offset    		0xA38
+#define DSP5_offset    		0xA3C
+#define DSP6_offset    		0xA40
+#define DSP7_offset    		0xA44
+#define ARMA15_offset    	0xA48
+
+#define	FFT_offset			0xA4C
+#define	FFT1_offset			0xAA4
+#define	VIP_offset			0xA50
+#define	RGMII_offset		0xA54
+#define	PCIE_offset			0xA58
+
+#define	SRIO0_offset		0xA5C
+#define	SRIO1_offset		0xA60
+#define	SRIO2_offset		0xA64
+#define	TP_offset			0xA68
+
+#define	SMC_offset			0xA6C
+#define	EMIF_offset			0xA70
+#define	DDR_offset			0xA74
+#define	DMA0_offset			0xA78
+#define	DMA1_offset			0xA7C
+#define	DMA2_offset			0xA80
+#define	DMA3_offset			0xA84
+#define	DMA4_offset			0xA88
+#define	GPIO_offset			0xA8C
+#define	I2C_offset			0xA90
+#define	SPI_offset			0xA94
+#define	UART_offset			0xA98
+#define	TIMER_offset		0xA9C
+#define	M1553B_offset		0xAA0
+
+
+
+#endif
--- a/pnna/pnna-c6x/c6x_DDR_init/include/mcu_config.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/mcu_config.h
@ -0,0 +1,414 @@
+#ifndef _MCU_CONFIG_H
+#define _MCU_CONFIG_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "M6678V4_PSC.h"
+#include "regconfig-1200M-FT.h"
+//#include "regconfig-800.h"
+
+//#include "regconfig-1600.h"
+//#include "regconfig-1600-qd.h"
+
+
+//#define   DDR_1_EXIST
+#ifdef DDR_1_EXIST
+#define    MCU_CHANNEL_CFG      0x2	 //DDR1
+#else
+#define   DDR_0_EXIST
+#define    MCU_CHANNEL_CFG      0x1  //DDR0
+#endif
+ 
+#define    MCU_CHANNEL_MAX      2
+
+
+#define 	DDR_CTL_BIST
+#define 	DDR_PI_BIST
+//#define     DDR_MEMTEST
+//#define 	DDR_Band_Test
+#define 	DDR_Scrub_mem
+//#define		ECC_test
+
+/*
+ * Default:WIDTH_64BIT,根据DDR颗粒，选区位宽
+ */
+//#define WIDTH_32BIT
+#define   WIDTH_64BIT
+
+#define   	INPUT_CLOCK                25  //units: MHZ
+
+#define 	GENMASK(h, l) \
+    ((((uint32_t)~0U) << (l)) & (((uint32_t)~0U) >> (32 - 1 - (h))))
+
+
+
+#define    DIMM_INFO_SRAM_ADDR  	0x0C100000
+#define    FTDDR_BASE_ADDR     			0x21000000//0x21000000   0x30900000
+#define    FTDDR_STIDE            				0x20000
+
+#define    DDR_CTL_BASE        		0x0
+#define    DDR_PI_BASE         		0x800
+#define    DDR_PHY_BASE        	0x1000
+
+#define    HALF_BUS_MODE       0
+#define    FULL_BUS_MODE       1
+
+
+#define    CTL_REG_NUM         787
+#define    PI_REG_NUM          	1080
+#define    PHY_REG_NUM         3246  /* 146~255 omit */
+
+#define    MASK_1BIT           	0x1
+#define    MASK_2BIT           	0x3
+#define    MASK_3BIT           	0x7
+#define    MASK_4BIT           	0xf
+#define    MASK_5BIT           	0x1f
+#define    MASK_6BIT           	0x3f
+#define    MASK_7BIT           	0x7f
+#define    MASK_8BIT           	0xff
+#define    MASK_9BIT           	0x1ff
+#define    MASK_10BIT          0x3ff
+#define    MASK_11BIT          0x7ff
+#define    MASK_12BIT          0xfff
+#define    MASK_13BIT          0x1fff
+#define    MASK_14BIT          0x3fff
+#define    MASK_15BIT          0x7fff
+#define    MASK_16BIT          0xffff
+#define    MASK_17BIT          0x1ffff
+#define    MASK_18BIT          0x3ffff
+#define    MASK_19BIT          0x7ffff
+#define    MASK_20BIT          0xfffff
+#define    MASK_21BIT          0x1fffff
+#define    MASK_22BIT          0x3fffff
+#define    MASK_23BIT          0x7fffff
+#define    MASK_24BIT          0xffffff
+#define    MASK_25BIT          0x1ffffff
+#define    MASK_26BIT          0x3ffffff
+#define    MASK_27BIT          0x7ffffff
+#define    MASK_28BIT          0xfffffff
+#define    MASK_29BIT          0x1fffffff
+#define    MASK_30BIT          0x3fffffff
+#define    MASK_31BIT          0x7fffffff
+#define    MASK_32BIT          0xffffffff
+
+#define   BIST_32GB_SPACE					35
+#define   BIST_16GB_SPACE					34
+#define   BIST_8GB_SPACE					33
+#define   BIST_4GB_SPACE					32
+#define   BIST_2GB_SPACE					31
+#define   BIST_1GB_SPACE					30
+#define   BIST_512MB_SPACE				29
+#define   BIST_256MB_SPACE				28
+#define   BIST_128MB_SPACE				27
+#define   BIST_64MB_SPACE				26
+#define   BIST_32MB_SPACE				25
+#define   BIST_16MB_SPACE				24
+#define   BIST_1MB_SPACE					20
+#define   BIST_1KB_SPACE					10
+
+#define     RDIMM_TYPE                  1
+#define     UDIMM_TYPE                  2
+#define     DIMM_x4                     		0x0
+#define     DIMM_x8                     		0x1
+#define     DIMM_x16                    		0x2
+#define     DIMM_x32                    		0x3
+#define     MIRROR                     		0x1
+#define     NO_MIRROR                   	0x0
+#define     ECC_TYPE                    1
+#define     NO_ECC_TYPE            0
+#define     ROW_NUM                     	17
+#define     COL_NUM                     	10
+#define     DDR3_TYPE                   	0xB
+#define     DDR4_TYPE                   	0xC
+#define     MAX_ROW                     	18
+#define     MAX_COL                     		12
+
+#define		CWL_9			(0<<3)		//1600
+#define		CWL_10			(1<<3)		//1866
+#define		CWL_11			(2<<3)		//2133,1600
+#define		CWL_12			(3<<3)		//2400,1866
+#define		CWL_14			(4<<3)		//2133
+#define		CWL_16			(5<<3)		//2400
+#define		CWL_18			(6<<3)		//2400
+#define		CWL_20			(7<<3)		//2933,3200
+
+#define		CL_17				(25<<2)
+#define		CL_18				(16<<2)
+#define		CL_20				(17<<2)
+#define		CL_22				(20<<2)
+#define		CL_24				(21<<2)
+
+#define		TWR_10			0x0
+#define		TWR_12			(1<<9)
+#define		TWR_14			(2<<9)
+#define		TWR_16			(3<<9)
+#define		TWR_18			(4<<9)
+#define		TWR_20			(5<<9)
+#define		TWR_24			(6<<9)
+#define		TWR_22			(7<<9)
+#define		TWR_26			(16<<9)
+#define		TWR_28			(17<<9)
+
+#define     RTT_NOM_DIS                 			0
+#define     RTT_NOM_60OHM               	(1<<8)
+#define     RTT_NOM_120OHM              	(2<<8)
+#define     RTT_NOM_40OHM               	(3<<8)
+#define     RTT_NOM_240OHM              	(4<<8)
+#define     RTT_NOM_48OHM               	(5<<8)
+#define     RTT_NOM_80OHM               	(6<<8)
+#define     RTT_NOM_34OHM               	(7<<8)
+
+#define     DRV_IMP_34OHM               0
+#define     DRV_IMP_48OHM               (1<<1)
+
+#define     RTT_PARK_DIS                			0
+#define     RTT_PARK_60OHM              	(1<<6)
+#define     RTT_PARK_120OHM             	(2<<6)
+#define     RTT_PARK_40OHM              	(3<<6)
+#define     RTT_PARK_240OHM             	(4<<6)
+#define     RTT_PARK_48OHM              	(5<<6)
+#define     RTT_PARK_80OHM              	(6<<6)
+#define     RTT_PARK_34OHM              	(7<<6)
+
+#define     MR1_NOM_MASK                	(0x7<<8)
+#define     MR1_IMP_MASK                		(0x3<<1)
+#define     MR5_PARK_MASK               	(0x7<<6)
+#define     MR6_VREF_MASK               		0x3F
+
+#define     RTT_WR_DIS                  			0
+#define     RTT_WR_120OHM               	(1<<9)
+#define     RTT_WR_240OHM               	(2<<9)
+#define     RTT_WR_HIZ                  			(3<<9)
+#define     RTT_WR_80OHM                		(4<<9)
+
+#define     DLL_ENABLE                   			1
+#define     WR_PREAMBLE_2N              	(1<<12)
+#define     RD_PREAMBLE_2N              	(1<<11)
+
+#define     DM_ENA                      				(1<<10)
+#define     CCD_L_5N                    				(1<<10)
+#define     CCD_L_6N                    				(2<<10)
+#define     CCD_L_8N                    				(4<<10)
+
+#define     DM_1                        1   //DM enable
+#define     DM_0                        0
+
+#define     writel(v,a)                 	(*(volatile unsigned int *)(a) = (v))
+#define     writeq(v,a)                 (*(volatile unsigned long *)(a) = (v))
+#define     readl(a)                    	(*(volatile unsigned int *)(a))
+#define     readq(a)                    	(*(volatile unsigned long *)(a))
+
+static inline uint32_t ddr_para_cycle_rnd(uint32_t para, uint32_t freq)
+{
+		uint32_t val,val_1,val_2,val_3 ;
+		val_3 = para * freq;
+		val_2 = val_3/1000000;
+		val_1 = (val_3 % 1000000)?1:0;
+		val   = val_2 + val_1;
+		return val;
+}
+
+static inline uint32_t ddr_para_cycle_rnd_jit(uint32_t para, uint32_t freq)
+{
+		uint32_t val,val_1,val_2,val_3 ;
+		val_3 = para * freq;
+		val_2 = val_3/980000;//with 2% clock jitter
+		val_1 = (val_3 % 980000)?1:0;
+		val   = val_2 + val_1;
+		return val;
+}
+
+static inline  void mcu_misc_write(uint8_t ch, uint32_t addr, uint32_t val)
+{
+//    	writel(val, FTDDR_BASE_ADDR + (ch<<17) + addr);
+    *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + addr) = val;
+
+}
+
+static inline unsigned int mcu_ctl_read32(uint8_t ch, uint32_t addr)
+{
+		writel((DDR_CTL_BASE + addr)<<2, FTDDR_BASE_ADDR + (ch<<17) + 0x80);
+		return readl(FTDDR_BASE_ADDR + (ch<<17) + 0x84);
+    
+//    *(volatile unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x80) = (DDR_CTL_BASE + addr)<<2;
+//    return *( volatile unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84);
+
+    
+}
+
+static  inline void mcu_ctl_write32(uint8_t ch, uint32_t addr, uint32_t val)
+{
+		writel((DDR_CTL_BASE + addr)<<2, FTDDR_BASE_ADDR + (ch<<17) + 0x80);
+		writel(val, FTDDR_BASE_ADDR + (ch<<17) + 0x84);
+    
+//    *(volatile unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x80) = (DDR_CTL_BASE + addr)<<2;
+//    *(volatile unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84) = val;
+//     mprintf("CTL ddr_regwrite ADDR =  %x, WRITE DATA =%x\r\n", (DDR_CTL_BASE + addr)<<2, val);
+//     mprintf("CTL ddr_regwrite ADDR =  %x, WRITE DATA =%x\r\n", (DDR_CTL_BASE + addr), val);
+    
+}
+//inline
+static inline void mcu_ctl_clrsetbits(uint8_t ch, uint32_t addr, uint32_t mask, uint32_t val)
+{
+
+		uint32_t tmp = mcu_ctl_read32(ch, addr);
+		tmp &= ~(mask);
+		tmp |= val;
+		mcu_ctl_write32(ch, addr, tmp);
+
+}
+
+static inline uint32_t mcu_phy_read32(uint8_t ch, uint32_t addr)
+{
+	
+		writel((DDR_PHY_BASE + addr)<<2, FTDDR_BASE_ADDR + (ch<<17) + 0x80);
+		return readl(FTDDR_BASE_ADDR + (ch<<17) + 0x84);
+    
+//    *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x80) = (DDR_PHY_BASE + addr)<<2;
+//    return *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84);
+//   mprintf("PHY ddr_regread ADDR =  %x, read DATA =%x\r\n", (DDR_PHY_BASE + addr)<<2, *( unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84));
+//   mprintf("PHY ddr_regread ADDR =  %d =DDR_PHY_BASE %d  + addr %d, read DATA =%x\r\n", (DDR_PHY_BASE + addr),DDR_PHY_BASE,addr, *( unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84));
+}
+
+static inline void mcu_phy_write32(uint8_t ch, uint32_t addr, uint32_t val)
+{
+		writel((DDR_PHY_BASE + addr)<<2, FTDDR_BASE_ADDR + (ch<<17) + 0x80);
+		writel(val, FTDDR_BASE_ADDR + (ch<<17) + 0x84);
+
+//    *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x80) = (DDR_PHY_BASE + addr)<<2;
+//    *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84) = val;
+//    mprintf("PHY ddr_regwrite ADDR =  %x  = DDR_PHY_BASE %d + addr %d , WRITE DATA =%x\r\n", (DDR_PHY_BASE + addr)<<2,DDR_PHY_BASE, addr,val);   
+//    mprintf("PHY ddr_regwrite ADDR =  %x  , WRITE DATA =%x\r\n", (DDR_PHY_BASE + addr)<<2 ,val);   
+
+}
+
+static inline void mcu_phy_clrsetbits(uint8_t ch, uint32_t addr, uint32_t mask, uint32_t val)
+{
+
+		uint32_t tmp = mcu_phy_read32(ch, addr);
+		tmp &= ~(mask);
+		tmp |= val;
+		mcu_phy_write32(ch, addr, tmp);
+
+}
+
+static inline uint32_t mcu_pi_read32(uint8_t ch, uint32_t addr)
+{
+		writel((DDR_PI_BASE + addr)<<2, FTDDR_BASE_ADDR + (ch<<17) + 0x80);
+		return readl(FTDDR_BASE_ADDR + (ch<<17) + 0x84);
+    
+//    *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x80) = (DDR_PI_BASE + addr)<<2;
+//    return *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84);
+//    mprintf("PI ddr_regread ADDR =  %x, read DATA =%x\r\n", (DDR_PI_BASE + addr)<<2 , *( unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84));
+//  	mprintf("PI ddr_regread ADDR =  %d, read DATA =%x\r\n", (DDR_PI_BASE + addr), *( unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84));
+}
+
+static inline void mcu_pi_write32(uint8_t ch, uint32_t addr, uint32_t val)
+{
+		writel((DDR_PI_BASE + addr)<<2, FTDDR_BASE_ADDR + (ch<<17) + 0x80);
+		writel(val, FTDDR_BASE_ADDR + (ch<<17) + 0x84);
+    
+//    *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x80) = (DDR_PI_BASE + addr)<<2;
+//    *(unsigned int *)(FTDDR_BASE_ADDR + ((unsigned int)ch<<17) + 0x84) = val;
+//    mprintf("PI ddr_regwrite ADDR =  %x, WRITE DATA =%x\r\n", (DDR_PI_BASE + addr)<<2 , val);
+//     mprintf("PI ddr_regwrite ADDR =  %d, WRITE DATA =%x\r\n", (DDR_PI_BASE + addr), val);
+}
+//inline
+static inline void mcu_pi_clrsetbits(uint8_t ch, uint32_t addr, uint32_t mask, uint32_t val)
+{
+
+		uint32_t tmp = mcu_pi_read32(ch, addr);
+		tmp &= ~(mask);
+		tmp |= val;
+		mcu_pi_write32(ch, addr, tmp);
+
+}
+
+typedef struct ddr_spd_eeprom {
+		uint8_t  dimm_type;    /* 1: RDIMM;2: UDIMM;3: SODIMM;4: LRDIMM */
+		uint8_t  data_width:2; /* 0: x4; 1: x8; 2: x16 */
+		uint8_t  mirror_type:1;/* 0: stardard; 1: mirror */
+		uint8_t  ecc_type:1;   /* 0: no-ecc; 1:ecc */
+		uint8_t  dram_type:4;  /* 0xB: DDR3; 0xC: DDR4 */
+		uint8_t  rank_num;
+		uint8_t  row_num;
+		uint8_t  col_num;
+		uint8_t  bg_num:4;
+		uint8_t  bank_num:4;
+		uint16_t sdram_density; /* units: Mb */
+
+		uint64_t dimm_capacity;
+
+		uint16_t tRCDmin;
+		uint16_t tRPmin;
+		uint16_t tRASmin;
+		uint16_t tRCmin;
+
+		uint16_t tFAWmin;
+		uint16_t tRRD_Smin;
+		uint16_t tRRD_Lmin;
+		uint16_t tCCD_Lmin;
+
+		uint16_t tWRmin;
+		uint16_t tWTR_Smin;
+		uint16_t tWTR_Lmin;
+
+		uint16_t tAAmin;
+		uint8_t  dm_cfg;
+		uint8_t  pad1;
+		uint32_t pad2;
+
+		uint16_t mr0;
+		uint16_t mr1;
+		uint16_t mr2;
+		uint16_t mr3;
+
+		uint16_t mr4;
+		uint16_t mr5;
+		uint16_t mr6;
+		uint16_t pad3;
+
+} ddr_spd_t;
+
+typedef enum {
+		DDR_CLK_800MHZ,
+		DDR_CLK_933MHZ,
+		DDR_CLK_1066MHZ,
+		DDR_CLK_1200MHZ,
+		DDR_CLK_1333MHZ,
+		DDR_CLK_1466MHZ,
+		DDR_CLK_1600MHZ
+}DDR_CLK_t;
+
+typedef struct sys_dimm_info {
+		uint64_t    sys_dimm_capacity;
+		uint16_t    lmu_frequency;      /* units: MHZ */
+		uint16_t    pad1;
+		uint32_t    pad2;
+
+		ddr_spd_t   spd_info[MCU_CHANNEL_MAX];
+}sys_dimm_info_t;    /* 8 + 7*8*2 = 120 bytes */
+
+
+extern sys_dimm_info_t *dimm_info;
+extern void dram_ddr_test(void);
+extern void DMA_ddr_test(void);
+extern void qualiphy_test(void);
+extern void DDR_Bandwidth_Test(void);
+extern void mcu_init(uint8_t ch);
+extern void mcu_dram_init(void);
+extern void display_ctl_reg(uint8_t ch);
+extern void display_pi_reg(uint8_t ch);
+extern void display_phy_reg(uint8_t ch);
+extern int DDR_CLK(DDR_CLK_t ddr_freq);
+extern void display_lvl_rlst(uint8_t ch);
+extern void lvl_process(uint8_t ch);
+extern void signal_intergrity(uint8_t ch);
+extern int e_printf(const char *fmt, ...);
+extern void print_spd_info(uint8_t ch);
+extern void phy_config(uint8_t ch);
+extern void ctl_config(uint8_t ch);
+extern void pi_config(uint8_t ch);
+extern void ECC_int_test(void);
+
+#endif
--- a/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-1200M-FT.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-1200M-FT.h
--- a/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-1600-qd.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-1600-qd.h
--- a/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-1600.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-1600.h
--- a/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-800.h
+++ b/pnna/pnna-c6x/c6x_DDR_init/include/regconfig-800.h
--- a/pnna/pnna-c6x/c6x_DDR_init/src/CORE_Memory_Test.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/CORE_Memory_Test.c
@ -0,0 +1,404 @@
+/**
+**************************************************************************************************************************************************************
+*  @file 			CORE_Memory_Test.c
+*  @brief  		用于实现 6678V4_DDR4 存储体测试的接口函数。
+*  @version 		V1.0
+*  @data			2023.07.07
+*  @attention
+*   \par
+*   ===================================================================================================
+*   @n	(c)	飞腾DSP技术支持团队.
+**************************************************************************************************************************************************************
+*/
+#include <stdio.h>
+#include "CORE_Memory_Test.h"
+#include "mcu_config.h"
+
+/*********************测试选择区域*************************************************/
+#define  BIT_PATTERN_FILLING_TEST                     /* 数据测试 */
+#define  ADDRESS_TEST                                 /* 地址测试 */
+#define  BIT_WALKING_TEST                             /* 走bit测试*/
+
+#define  MAX_FILL_FAIL_COUNT 		(10)              /* 填充测试错误最大值限制*/
+#define  MAX_ADDRESS_FAIL_COUNT 		(10)          /* 地址测试错误最大值限制*/
+#define  MAX_BITWALKING_FAIL_COUNT 	(2)               /* 走bit测试错误最大值限制*/
+#define  MAX_BITWALKING_RANGE 		(1024*1024*1024)  /*走bit测试最大限制*/
+
+/*实际使用时可以将PRINT_DETAILS设置为0，屏蔽打印信息。*/
+#define  PRINT_DETAILS 	1                             /* 打印调试信息选择开关*/
+#if      PRINT_DETAILS
+#define  PRINT	 		printf
+#else
+#define  PRINT			//
+#endif
+
+/* 填充测试时使用的数据源 */
+
+#ifdef  WIDTH_32BIT
+unsigned int ulDataPatternTable_32bit[] = {
+	0x00000000,
+	0xffffffff,
+	0xaaaaaaaa,
+	0x55555555,
+	0xcccccccc,
+	0x33333333,
+	0xf0f0f0f0,
+	0xff00ff00,
+	0xffff0000,
+	0x0000ffff,
+};
+#endif
+
+#ifdef  WIDTH_64BIT
+unsigned long long ulDataPatternTable[] = { 
+	0x0000000000000000,
+	0xffffffffffffffff,
+	0xaaaaaaaaaaaaaaaa,
+	0x5555555555555555,
+	0xcccccccccccccccc,
+	0x3333333333333333,
+	0xf0f0f0f0f0f0f0f0, 
+	0xff00ff00ff00ff00, 
+    0xffff0000ffff0000, 
+    0x0000ffff0000ffff,
+    0x00000000ffffffff,
+    0xffffffff00000000
+};
+#endif
+
+
+/*******************************************************************************
+*函数名：pass_fail_count(iResult)
+*功    能： 测试通过判断函数。
+*参    数：intiResult  测试结束后传递过来的错误次数
+*返回值：无
+*******************************************************************************/
+void pass_fail_count(int iResult)
+{
+	if(iResult)
+		printf("\n   存储体测试不通过! \n");
+	else
+		printf("\n   存储体测试通过! \n");
+}
+
+/*******************************************************************************
+*函数名：KeyStone_memory_test(unsigned int uiStartAddress, unsigned int uiStopAddress, unsigned int uiStep, char * mem_name)
+*功    能： 存储体测试
+*参    数：uiStartAddress  存储体起始地址
+*      uiStopAddress  存储体结束地址
+*      uiStep         填充的数据的间隔，间隔   = uiStep*2 个字，所以1表示连续填充，正常测试选1即可。
+*      mem_name       测试存储区域的名字
+*返回值：无
+*说    明：1、函数内部有打印信息，三种测试均有过程说明。
+*      2、测试通过打印“测试通过”，否则打印“测试不通过”。
+*      3、常规连续测试，uiStep设置为1即可。
+*******************************************************************************/
+void DSP_memory_test(unsigned int uiStartAddress,
+	unsigned int uiStopAddress, unsigned int uiStep, char * mem_name)
+{
+	printf("\n   对   %s 区域进行测试   \n", mem_name);
+	pass_fail_count(DSP_core_MEM_Test(uiStartAddress, uiStopAddress, uiStep));
+}
+
+/*******************************************************************************
+*函数名：MEM_FillTest(unsigned int uiStartAddress,unsigned int uiCount,unsigned long long ulBitPattern,unsigned int uiStep)
+*功    能： 填充数据测试
+*参    数：uiStartAddress  存储体起始地址
+*      uiCount        填充数据的次数
+*      ulBitPattern   填充的数据
+*      uiStep         表示测试的步长
+*返回值： uiFailCount    出错的次数
+*注    意： 填充测试的原理是 给整片空间填充固定的数值。
+*******************************************************************************/
+unsigned int MEM_FillTest(unsigned int uiStartAddress,
+                        unsigned int uiCount,
+                        unsigned long long ulBitPattern,
+                        unsigned int uiStep)
+{
+    unsigned int i, uiFailCount=0;
+    volatile unsigned long long *ulpAddressPointer;
+    volatile unsigned long long ulReadBack;
+
+    /*对存储体填充数据，填充的数据为ulBitPattern*/
+	ulpAddressPointer = (unsigned long long *)uiStartAddress;
+	for(i=0; i<uiCount; i++)
+	{
+        *ulpAddressPointer = ulBitPattern;
+        ulpAddressPointer += (uiStep);
+    }
+
+	/* 写完之后进行数据校验 */
+	ulpAddressPointer = (unsigned long long *)uiStartAddress;
+	for(i=0; i<uiCount; i++)
+	{
+        ulReadBack = *ulpAddressPointer;
+        if ( ulReadBack!= ulBitPattern)
+        {
+			PRINT("  存储体测试在 0x%8x 位置出错, 写进去的数值为 0x%016llx, 读出来的数值为 0x%016llx\n", (unsigned int)ulpAddressPointer, ulBitPattern, ulReadBack);
+            uiFailCount++;
+			if(uiFailCount>=MAX_FILL_FAIL_COUNT)/* 错误次数超过MAX_FILL_FAIL_COUNT次直接退出*/
+				return uiFailCount;
+        }
+        ulpAddressPointer += (uiStep);
+    }
+	return uiFailCount;
+}
+/*******************************************************************************
+*函数名：MEM_FillTest_32bit(unsigned int uiStartAddress,unsigned int uiCount,unsigned long long ulBitPattern,unsigned int uiStep)
+*功    能：32bit填充数据测试
+*参    数：uiStartAddress  存储体起始地址
+*      uiCount        填充数据的次数
+*      ulBitPattern   填充的数据
+*      uiStep         表示测试的步长
+*      WIDTH_BIT      DDR位宽选择
+*返回值： uiFailCount    出错的次数
+*返回值：
+*注    意： 填充测试的原理是 给整片空间填充固定的数值。
+*注     MEM_FillTest_32bit(uiStartAddress, uiCount, ulDataPatternTable_32bit[j], uiStep);
+*******************************************************************************/
+unsigned int MEM_FillTest_32bit(unsigned int uiStartAddress,
+                        unsigned int uiCount,
+                        unsigned int ulBitPattern_32bit,
+                        unsigned int uiStep)
+{
+    unsigned int i, uiFailCount=0;
+    volatile unsigned int *ulpAddressPointer;
+    volatile unsigned int ulReadBack;
+
+    /*对存储体填充数据，填充的数据为ulBitPattern*/
+	ulpAddressPointer = (unsigned int *)uiStartAddress;
+	for(i=0; i<uiCount; i++)
+	{
+        *ulpAddressPointer = ulBitPattern_32bit;
+        ulpAddressPointer += (uiStep);
+    }
+
+	/* 写完之后进行数据校验 */
+	ulpAddressPointer = (unsigned int *)uiStartAddress;
+	for(i=0; i<uiCount; i++)
+	{
+        ulReadBack = *ulpAddressPointer;
+        if ( ulReadBack!= ulBitPattern_32bit)
+        {
+			PRINT("  存储体测试在 0x%8x 位置出错, 写进去的数值为 0x%8x, 读出来的数值为 0x%8x\n", (unsigned int)ulpAddressPointer, ulBitPattern_32bit, ulReadBack);
+            uiFailCount++;
+			if(uiFailCount>=MAX_FILL_FAIL_COUNT)/* 错误次数超过MAX_FILL_FAIL_COUNT次直接退出*/
+				return uiFailCount;
+        }
+        ulpAddressPointer += (uiStep);
+    }
+	return uiFailCount;
+}
+
+/*******************************************************************************
+*函数名：MEM_AddrTest(unsigned int uiStartAddress, unsigned int uiCount, int iStep)
+*功    能： 地址测试
+*参    数：uiStartAddress  存储体起始地址
+*      uiCount        填充的次数
+*      uiStep          填充的数据的间隔，间隔   = uiStep*2 个字，所以1表示连续填充
+*返回值： uiFailCount     出错的次数
+*注    意：地址测试的原理是 给每个功能单元填充该功能单元的地址，比如在 地址0写数据0、地址1写数据1
+*******************************************************************************/
+unsigned int MEM_AddrTest(unsigned int uiStartAddress, 
+						unsigned int uiCount,
+                        int iStep)
+{
+    unsigned int i, uiFailCount=0;
+    volatile unsigned long long *ulpAddressPointer;
+    volatile unsigned long long ulReadBack;
+
+	ulpAddressPointer = (unsigned long long *)uiStartAddress;
+	for(i=0; i<uiCount; i++)
+	{
+		/* 用地址值进行填充   */
+        *ulpAddressPointer = _itoll(((unsigned int)ulpAddressPointer)+4, 
+        	(unsigned int)ulpAddressPointer);	  
+        ulpAddressPointer += (iStep);
+    }
+
+	ulpAddressPointer = (unsigned long long *)uiStartAddress;
+	for(i=0; i<uiCount; i++)
+	{
+        ulReadBack = *ulpAddressPointer;
+        if ( ulReadBack != _itoll(((unsigned int)ulpAddressPointer)+4, 
+        	(unsigned int)ulpAddressPointer)) /* 数据对比 */
+        {
+			PRINT("  在地址 0x%8x 测试出错, 写入的值为  0x%016llx, 读回来的值为  0x%016llx\n", (unsigned int)ulpAddressPointer, _itoll(((unsigned int)ulpAddressPointer)+4, (unsigned int)ulpAddressPointer), ulReadBack);
+            uiFailCount++;
+			if(uiFailCount>=MAX_ADDRESS_FAIL_COUNT) /* 错误次数超过MAX_ADDRESS_FAIL_COUNT次直接退出*/
+				return uiFailCount;
+        }
+        ulpAddressPointer += (iStep);
+    }
+    return uiFailCount;
+}
+/*******************************************************************************
+*函数名：MEM_AddrTest_32bit(unsigned int uiStartAddress, unsigned int uiCount, int iStep)
+*功    能： 32bit地址测试
+*参    数：uiStartAddress  存储体起始地址
+*      uiCount        填充的次数
+*      uiStep          填充的数据的间隔，间隔   = uiStep*2 个字，所以1表示连续填充
+*返回值： uiFailCount     出错的次数
+*注    意：地址测试的原理是 给每个功能单元填充该功能单元的地址，比如在 地址0写数据0、地址1写数据1
+*******************************************************************************/
+unsigned int MEM_AddrTest_32bit(unsigned int uiStartAddress,
+						unsigned int uiCount,
+                        int iStep)
+{
+    unsigned int i, uiFailCount=0;
+    volatile unsigned int *ulpAddressPointer;
+    volatile unsigned int ulReadBack;
+
+		ulpAddressPointer = (unsigned int *)uiStartAddress;
+		for(i=0; i<uiCount; i++)
+		{
+			/* 用地址值进行填充   */
+			*ulpAddressPointer = (unsigned int)ulpAddressPointer;
+			ulpAddressPointer += (iStep);
+
+		}
+		ulpAddressPointer = (unsigned int *)uiStartAddress;
+		for(i=0; i<uiCount; i++)
+		{
+			ulReadBack = *ulpAddressPointer;
+			if ( ulReadBack != (unsigned int)ulpAddressPointer) /* 数据对比 */
+			{
+				PRINT("  在地址 0x%8x 测试出错, 写入的值为  0x%8x, 读回来的值为  0x%8x\n", (unsigned int)ulpAddressPointer, (unsigned int)ulpAddressPointer, ulReadBack);
+				uiFailCount++;
+				if(uiFailCount>=MAX_ADDRESS_FAIL_COUNT) /* 错误次数超过MAX_ADDRESS_FAIL_COUNT次直接退出*/
+					return uiFailCount;
+			}
+			ulpAddressPointer += (iStep);
+		}
+    return uiFailCount;
+}
+
+/*******************************************************************************
+*函数名：MEM_Bit_Walking(unsigned int uiStartAddress,unsigned int uiCount,unsigned int uiStep)
+*功    能： 走bit测试
+*参    数：uiStartAddress  存储体起始地址
+*      uiCount        填充的次数
+*      uiStep          填充的数据的间隔，间隔   = uiStep*2 个字，所以1表示连续填充
+*返回值： uiFailCount    标示出错的次数
+*说    明：测试的原理为   1、 在全0数据中单独每一位赋1填充存储体； 2、 在全1数据中单独每一位赋0填充存储体
+*******************************************************************************/
+unsigned int MEM_Bit_Walking(unsigned int uiStartAddress,
+						unsigned int uiCount,
+                        unsigned int uiStep)
+{
+    unsigned int uiFailCount=0;
+    unsigned int j;
+    unsigned int uiBitMask=1;
+    for (j = 0; j < 32; j++)
+    {
+    	PRINT("从地址 0x%8x 处填充数据： 0x%16llx\n",uiStartAddress, _itoll(uiBitMask, uiBitMask));
+    	if(MEM_FillTest(uiStartAddress, uiCount, _itoll(uiBitMask, uiBitMask), uiStep))
+    		uiFailCount++;
+
+    	PRINT("从地址 0x%8x 处填充数据： 0x%16llx\n",uiStartAddress, _itoll(~uiBitMask, ~uiBitMask));
+    	if(MEM_FillTest(uiStartAddress, uiCount, _itoll(~uiBitMask, ~uiBitMask), uiStep))
+    		uiFailCount++;
+
+    	if(uiFailCount>= MAX_BITWALKING_FAIL_COUNT)/* 错误次数超过MAX_BITWALKING_FAIL_COUNT次直接退出*/
+			return uiFailCount;
+
+        uiBitMask <<= 1;
+    }
+	return uiFailCount;
+}
+
+/*******************************************************************************
+*函数名：DSP_core_MEM_Test(unsigned int uiStartAddress, unsigned int uiStopAddress, unsigned int uiStep)
+*功    能： DSP内核访问存储体测试
+*参    数：uiStartAddress   存储体起始地址，
+*      uiStopAddress   存储体结束地址，
+*      uiStep          填充的数据的间隔，间隔   = uiStep*2 个字，所以1表示连续填充
+*返回值：uiTotalFailCount 出错的总次数
+*说    明：该接口函数主要包含三个部分 1、数据填充测试  2、地址测试  3、走bit测试
+*******************************************************************************/
+int DSP_core_MEM_Test(unsigned int uiStartAddress, unsigned int uiStopAddress, unsigned int uiStep)
+{
+    unsigned int uiCount, uiFailCount=0, uiTotalFailCount=0;
+    int j;
+
+    /*uiCount为数据填充的次数*/
+#ifdef   WIDTH_64BIT
+    uiCount = ((uiStopAddress - uiStartAddress)/8)/uiStep;
+#endif
+
+#ifdef   WIDTH_32BIT
+    uiCount = ((uiStopAddress - uiStartAddress)/4)/uiStep;
+#endif
+
+
+#ifdef  BIT_PATTERN_FILLING_TEST   /* 数据填充测试  */
+    PRINT(" 1、数据填充测试开始！  \n" );
+    /* 将数据表中的数据填充到测试空间  */
+  #ifdef   WIDTH_64BIT
+    for (j = 0; j < sizeof(ulDataPatternTable)/8; j++)
+    {
+        uiFailCount = MEM_FillTest(uiStartAddress, uiCount, ulDataPatternTable[j], uiStep);
+	    if (uiFailCount)
+	    {
+	    	PRINT(" 出现了%d 次错误，在填充数据 0x%016llx时。  \n",uiFailCount, ulDataPatternTable[j]);
+	    	uiTotalFailCount+=uiFailCount;
+	    }
+		else
+		    PRINT(" 从地址  0x%8x 到  地址0x%8x 填充数据  0x%16llx 通过！ \n",uiStartAddress,uiStopAddress, ulDataPatternTable[j]);
+    }
+    PRINT(" 1、64bit数据填充测试结束！  \n" );
+    #endif
+    #ifdef   WIDTH_32BIT
+	for (j = 0; j < sizeof(ulDataPatternTable_32bit)/4; j++)
+	    {
+		uiFailCount = MEM_FillTest_32bit(uiStartAddress, uiCount, ulDataPatternTable_32bit[j], uiStep);
+		if (uiFailCount)
+		    {
+		    PRINT(" 出现了%d 次错误，在填充数据 0x%8x时。  \n",uiFailCount, ulDataPatternTable_32bit[j]);
+		    uiTotalFailCount+=uiFailCount;
+		    }
+    		else
+    		    PRINT(" 从地址  0x%8x 到  地址0x%8x 填充数据  0x%8x 通过！ \n",uiStartAddress,uiStopAddress, ulDataPatternTable_32bit[j]);
+	    }
+	    PRINT(" 1、32bit数据填充测试结束！  \n" );
+    #endif
+
+
+#endif
+
+#ifdef  ADDRESS_TEST
+    PRINT(" \n 2、 地址测试开始！  \n" );
+    /* 从低到高进行地址测试  */
+ #ifdef WIDTH_64BIT
+    uiFailCount = MEM_AddrTest(uiStartAddress, uiCount, uiStep);
+ #endif
+ #ifdef   WIDTH_32BIT
+    uiFailCount = MEM_AddrTest_32bit(uiStartAddress, uiCount, uiStep);
+ #endif
+    if (uiFailCount)
+    {
+    	PRINT("  在地址测试时出现 %d 次错误！ \n",uiFailCount);
+        uiTotalFailCount+=uiFailCount;
+    }
+	else
+	   	PRINT("  从地址 0x%8x 到  地址 0x%8x 地址测试成功 ！\n",uiStartAddress,uiStopAddress);
+    PRINT(" 2、地址测试结束！  \n" );
+#endif
+
+#ifdef  BIT_WALKING_TEST
+    PRINT("\n 3、 走bit测试开始！  \n" );
+    /* 走bit测试  */
+    if(uiCount>MAX_BITWALKING_RANGE)
+			uiCount= MAX_BITWALKING_RANGE;     /* 避免测试时间过长，此处对测试规模进行了限制，用户可自定义修改 */
+    uiFailCount = MEM_Bit_Walking(uiStartAddress,uiCount, uiStep);
+    if (uiFailCount)
+    {
+	   	PRINT(" 测试共有 %d 次出现错误   \n",uiFailCount);
+        uiTotalFailCount+=uiFailCount;
+    }    
+	else
+	  	PRINT("    从地址 0x%8x 到  地址 0x%8x 地址测试成功 ！ \n",uiStartAddress,uiStopAddress);
+    PRINT(" 3、 走bit测试结束！  \n" );
+#endif
+  	return uiTotalFailCount;
+}
--- a/pnna/pnna-c6x/c6x_DDR_init/src/ECC_test.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/ECC_test.c
@ -0,0 +1,80 @@
+#include "mcu_config.h"
+
+void ECC_int_test(void)
+{
+	int i = 0 , j = 0;
+	int *ReadAdd,*WriteAdd;
+	int ch ;
+	if (MCU_CHANNEL_CFG == 0x1)
+ 	ch = 0;
+	 	
+  	if (MCU_CHANNEL_CFG == 0x2)
+	 	ch = 1;
+/**********写一片GSM空间 待用****************/
+	for(i = 0; i < 100; i++)
+		{
+			*(unsigned int *)(0x70600000+j) = i;
+			j = j+4;
+		}
+		
+/**********ECC 使能的情况下 进行满位宽的搬移 形成正确的ECC码****************/
+//	M7004_datatrans( 0x70600000, 0x80000000, 0x20);
+//	CONFIG_DMA(0,0x5006,0,0x70600000,0x40,0x80000000,0x40,0,0);
+//	clear_CIPR();
+//	*(unsigned long*)ESR = 0x1;//DMA启动传输标志
+//	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);//DMA传输完成判断语句
+
+	
+	//搬移完成后断点查看空间数据
+/**********关闭ECC ，手动修改1bit错误****************/
+	mcu_ctl_clrsetbits(ch, 488, MASK_2BIT<<24, 0x0<<24);
+	mcu_ctl_clrsetbits(ch, 491, MASK_1BIT<<8, 0x0<<8);
+	mcu_pi_clrsetbits(ch, 98, MASK_1BIT<<16, 0x0<<16);	
+	
+	//CPU修改DDR空间数据产生 2位错
+//		*(unsigned int *)0x80000000 = 0xFFFFFF65;
+
+	//CPU修改DDR空间数据产生 1位错
+	*(unsigned int *)0x80000000 = 0x1;
+	//修改注错完成后，为了便于观察 在下一步操作进行之前断点查看memory空间是否修改
+//	asm(" snop 5 ");
+//	asm(" snop 5 ");
+//	asm(" snop 5 ");
+//	asm(" snop 5 ");					
+/**********开启ECC ，进行读操作（1bit错误会触发读修改写） ****************/
+	mcu_ctl_clrsetbits(ch, 488, MASK_2BIT<<24, 0x3<<24);
+	mcu_ctl_clrsetbits(ch, 491, MASK_1BIT<<8,  0x1<<8);
+	mcu_pi_clrsetbits(ch, 98, MASK_1BIT<<16, 0x1<<16);							
+//	asm(" snop 5 ");
+//	asm(" snop 5 ");
+//	asm(" snop 5 ");
+//	asm(" snop 5 ");
+									
+//	M7004_datatrans( 0x80000000, 0x70610000, 0x20);
+	//读完成后，再断点查看是否进行了修改
+//	CONFIG_DMA(0,0x5006,0,0x80000000,0x20,0x70610000,0x20,0,0);
+//	clear_CIPR();
+//	*(unsigned long*)ESR = 0x1;//DMA启动传输标志
+//	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);//DMA传输完成判断语句
+
+											
+																																	
+	ReadAdd  = (unsigned int*)0x80000000;
+	WriteAdd = (unsigned int*)0x70600000;
+	int Redata,Wrdata;
+	for(i=0;i<8;i++)
+	{
+		Redata = *ReadAdd;
+		Wrdata = *WriteAdd;
+		if(Redata != Wrdata)
+		{
+			printf("ERR addr = 0x%8x,write data = 0x%x,read data = 0x%x\n",ReadAdd,*WriteAdd,*ReadAdd);
+		}
+		ReadAdd = ReadAdd + 1;
+		WriteAdd = WriteAdd+ 1;
+	}
+	printf("teat done\n");											
+//		ReadAdd  = *(unsigned int*)0x80000000;
+//	printf("read data = 0x%8x\n",ReadAdd);												
+															
+}
--- a/pnna/pnna-c6x/c6x_DDR_init/src/M6678V4_PLL.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/M6678V4_PLL.c
@ -0,0 +1,695 @@
+/**
+********************************************************************************
+* @file       6678V4_PLL.c
+* @brief      用于配置时钟的接口函数。
+* @version    V1.0
+* @date       2023/9/13
+* @attention
+* \par
+* ==============================================================================
+* @n   (C) 飞腾DSP技术支持团队.
+********************************************************************************
+*/
+#include "M6678V4_PLL.h"
+#include "M6678V4_PSC.h"
+/** @addtogroup PLL_FUNCTION
+ @{ */
+
+/**
+********************************************************************************
+ *   @n@b void //pll_wait(uint32_t i)
+ *
+ *   @b 功能：
+ *   @n  延时函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			i		--------	设置循环执行nop 5的次数。注意该延时函数只是粗略的延时。
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n 无
+ *******************************************************************************
+ */
+
+
+static void pll_wait(uint32_t i)
+{
+	volatile uint32_t c=0;
+	for(c=0;c<i;c++)
+	{
+		asm(" nop 5 ");
+	}
+}
+
+void DSPCLKV_PLL(uint8_t RATIO)
+{
+
+	//2.3.2.2	可变分频的配置
+
+	PSC_Close_Clk("EMIF",1);	//改变配置前，要求关闭EMIF时钟；
+
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	asm(" MFENCE ");
+
+		KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+		KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2) 通过编程将DSP_PLLDIV中的RATIO域改变为预定值。
+	DSP_PLLDIV = RATIO;
+	pll_wait(1000);
+
+	PSC_Open_Clk("EMIF",1);	//开启EMIF时钟
+
+}
+
+void ARMCLKV_PLL(uint8_t RATIO_arm)
+{
+
+	//2.3.2.2	可变分频的配置
+
+	PSC_Close_Clk("ARMA15",3);	//改变配置前，要求关闭ARM时钟；
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	asm(" MFENCE ");
+
+		KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+		KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2) 通过编程将ARM_PLLDIV中的RATIO域改变为预定值。
+	ARM_PLLDIV = RATIO_arm;
+	pll_wait(1000);
+
+	PSC_Open_Clk("ARMA15",3);	//开启ARM时钟
+
+}
+
+void ACC_FFT_PLL(uint8_t RATIO1)
+{
+
+	//2.3.2.2	可变分频的配置
+
+	PSC_Close_Clk("FFT",1);		//改变配置前，要求关闭FFT时钟；
+	PSC_Close_Clk("FFT1",1);	//改变配置前，要求关闭FFT时钟；
+
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	asm(" MFENCE ");
+
+	KICK0=0x83e70b13;  		//解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0; 	 	//解锁Kicker机制寄存器 KICK1
+
+	//	2) 通过编程将ACC_PLLDIV1中的RATIO域改变为预定值。
+	ACC_PLLDIV1 = RATIO1;
+	pll_wait(1000);
+
+	PSC_Open_Clk("FFT",1);	//开启FFT时钟；
+	PSC_Open_Clk("FFT1",1);	//开启FFT1时钟；
+
+
+}
+
+
+void ACC_VIP_PLL(uint8_t RATIO2)
+{
+
+	//2.3.2.2	可变分频的配置
+
+	PSC_Close_Clk("VIP",1);		//改变配置前，要求关闭VIP时钟；
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	asm(" MFENCE ");
+
+		KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+		KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2) 通过编程将ACC_PLLDIV2中的RATIO域改变为预定值。
+	ACC_PLLDIV2 = RATIO2;
+	pll_wait(1000);
+
+	PSC_Open_Clk("VIP",1);		//开启VIP时钟
+
+}
+
+
+/**
+********************************************************************************
+ *   @n@b void DSP_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  DSP_PLL_Init初始化函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			PLLM ------- 倍频系数
+ *	   		PLLN ------- 前分频系数
+ *	   		POSTDIV2 --- 后分频系数2
+ *	   		POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM  | PLLN | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | 1200         | 50(DSK)       		| 48     | 1      |       2    |     1     |
+ * | 1000         | 50(DSK)             | 60    | 1      |       3    |     1     |
+ * | 800          | 50(DSK)             | 48    | 1      |       3    |     1     |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM			oscclk为输入时钟
+ *   	DSP_PLL = FOUTVCO/POSTDIV2/POSTDIV1
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+void DSP_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+		asm(" MFENCE ");
+		//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+		KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+		KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+		//	2）将DSP_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+		DSP_PLLCTL |= 0x1;
+		pll_wait(20);
+
+		//	3) 将DSP_PLLCMD中的ENPLL写为0，关断PLL；
+		DSP_PLLCMD &= 0xfffffffe;
+
+		//	4) 设置DSP_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+		DSP_PLLCTL = (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+		//	5) 至少等待1us后将DSP_PLLCMD中的ENPLL写为1；
+		pll_wait(200);
+		DSP_PLLCMD |= 0x1;
+
+		//	6) 至少等待500us，或 查询DSP_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+		while(!(DSP_PLLCMD & (1<<1)));
+
+		//7) 将DSP_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+		DSP_PLLCTL &= 0xfffffffe;
+		pll_wait(1000);
+	}
+
+
+/**
+********************************************************************************
+ *   @n@b void DSP_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  DSP_PLL_Init初始化函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			PLLM ------- 倍频系数
+ *	   		PLLN ------- 前分频系数
+ *	   		POSTDIV2 --- 后分频系数2
+ *	   		POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM  | PLLN | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | 1200         | 50(DSK)       		| 48     | 1      |       2    |     1     |
+ * | 1000         | 50(DSK)             | 60    | 1      |       3    |     1     |
+ * | 800          | 50(DSK)             | 48    | 1      |       3    |     1     |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM			oscclk为输入时钟
+ *   	DSP_PLL = FOUTVCO/POSTDIV2/POSTDIV1
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+void NOC_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+		asm(" MFENCE ");
+		//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+		KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+		KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+		//	2）将NOC_PLLCTL中的BYPASS写为1，至少等待NOC_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+		NOC_PLLCTL |= 0x1;
+		pll_wait(20);
+
+		//	3) 将NOC_PLLCMD中的ENPLL写为0，关断PLL；
+		NOC_PLLCMD &= 0xfffffffe;
+
+		//	4) 设置NOC_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+		NOC_PLLCTL = (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+		//	5) 至少等待1us后将NOC_PLLCMD中的ENPLL写为1；
+		pll_wait(200);
+		NOC_PLLCMD |= 0x1;
+
+		//	6) 至少等待500us，或 查询NOC_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+		while(!(NOC_PLLCMD & (1<<1)));
+
+		//7) 将NOC_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+		NOC_PLLCTL &= 0xfffffffe;
+		pll_wait(1000);
+	}
+
+
+
+/**
+********************************************************************************
+ *   @n@b void SYS_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  SYS_PLL_Init初始化函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			PLLM ------- 倍频系数
+ *	   		PLLN ------- 分频系数
+ *	   		POSTDIV2 --- 后分频系数2
+ *	   		POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM  | PLLN | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | 2500         | 50(DSK)       		| 50    | 1      |       1    |     1     |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM
+ *   	SYS_PLL = FOUTVCO/POSTDIV2/POSTDIV1 	oscclk为输入时钟
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+void SYS_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+	asm(" MFENCE ");
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2）将SYS_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+	SYS_PLLCTL |= 0x1;
+	pll_wait(20);
+
+	//	3) 将SYS_PLLCMD中的ENPLL写为0，关断PLL；
+	SYS_PLLCMD &= 0xfffffffe;
+
+	//	4) 设置SYS_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+	SYS_PLLCTL =  (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+	//	5) 至少等待1us后将SYS_PLLCMD中的ENPLL写为1；
+	pll_wait(200);
+	SYS_PLLCMD |= 0x1;
+
+	//	6) 至少等待500us，或 查询SYS_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+	while(!(SYS_PLLCMD & (1<<1)));
+
+	//7) 将SYS_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+	SYS_PLLCTL &= 0xfffffffe;
+	pll_wait(1000);
+}
+
+
+
+
+/**
+********************************************************************************
+ *   @n@b void PCIE_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  PCIE_PLL_Init初始化函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			PLLM ------- 倍频系数
+ *	   		PLLN ------- 分频系数
+ *	   		POSTDIV2 --- 后分频系数2
+ *	   		POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM  | PLLN | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | 400          | 50(DSK)       		| 48     | 1      |       3    |     2     |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM
+ *   	PCIE_PLL = FOUTVCO/POSTDIV2/POSTDIV1 	oscclk为输入时钟
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+
+void PCIE_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+	asm(" MFENCE ");
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2）将PCIE_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+	PCIE_PLLCTL |= 0x1;
+	pll_wait(20);
+
+	//	3) 将PCIE_PLLCMD中的ENPLL写为0，关断PLL；
+	PCIE_PLLCMD &= 0xfffffffe;
+
+	//	4) 设置PCIE_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+	PCIE_PLLCTL =  (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+	//	5) 至少等待1us后将PCIE_PLLCMD中的ENPLL写为1；
+	pll_wait(200);
+	PCIE_PLLCMD |= 0x1;
+
+	//	6) 至少等待500us，或 查询PCIE_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+	while(!(PCIE_PLLCMD & (1<<1)));
+
+	//7) 将PCIE_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+	PCIE_PLLCTL &= 0xfffffffe;
+	pll_wait(1000);
+}
+
+
+
+
+/**
+********************************************************************************
+ *   @n@b void DDR_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  DDR_PLL_Init初始化函数，提供DDR时钟
+ *
+ *   @b 形参：
+ *   @verbatim
+ *	   PLLM ------- 倍频系数
+ *	   PLLN ------- 分频系数
+ *	   POSTDIV2 --- 后分频系数2
+ *	   POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+---------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM   | PLLN    | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+---------+------------+-----------+
+ * | 800          | 50(DSK)       		| 48    | 1        |      3     |     1     |
+ * | 400          | 50(DSK)             | 48     | 1       |      3     |     2     |
+ * +--------------+---------------------+--------+---------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM
+ *   	DDR_PLL = FOUTVCO/POSTDIV2/POSTDIV1 	oscclk为输入时钟
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+
+void DDR_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+	asm(" MFENCE ");
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2）将DDR_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+	DDR_PLLCTL |= 0x1;
+	pll_wait(20);
+
+	//	3) 将DDR_PLLCMD中的ENPLL写为0，关断PLL；
+	DDR_PLLCMD &= 0xfffffffe;
+
+	//	4) 设置DDR_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+	DDR_PLLCTL =  (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+	//	5) 至少等待1us后将DDR_PLLCMD中的ENPLL写为1；
+	pll_wait(200);
+	DDR_PLLCMD |= 0x1;
+
+	//	6) 至少等待500us，或 至少等待500us，或 至少等待500us，或查询DDR_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+	while(!(DDR_PLLCMD & (1<<1)));
+
+	//7) 将DDR_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+	DDR_PLLCTL &= 0xfffffffe;
+	pll_wait(1000);
+}
+
+
+
+
+/**
+********************************************************************************
+ *   @n@b void ACC_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  ACC_PLL_Init初始化函数，提供ACC时钟
+ *
+ *   @b 形参：
+ *   @verbatim
+ *	   PLLM ------- 倍频系数
+ *	   PLLN ------- 分频系数
+ *	   POSTDIV2 --- 后分频系数2
+ *	   POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+---------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM   | PLLN    | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+---------+------------+-----------+
+ * | 800          | 50(DSK)       		| 48    | 1        |      3     |     1     |
+ * | 400          | 50(DSK)             | 48     | 1       |      3     |     2     |
+ * +--------------+---------------------+--------+---------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM
+ *   	ACC_PLL = FOUTVCO/POSTDIV2/POSTDIV1 	oscclk为输入时钟
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+
+void ACC_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+	asm(" MFENCE ");
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2）将ACC_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+	ACC_PLLCTL |= 0x1;
+	pll_wait(20);
+
+	//	3) 将ACC_PLLCMD中的ENPLL写为0，关断PLL；
+	ACC_PLLCMD &= 0xfffffffe;
+
+	//	4) 设置ACC_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+	ACC_PLLCTL =  (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+	//	5) 至少等待1us后将ACC_PLLCMD中的ENPLL写为1；
+	pll_wait(200);
+	ACC_PLLCMD |= 0x1;
+
+	//	6) 至少等待500us，或 至少等待500us，或 查询ACC_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+	while(!(ACC_PLLCMD & (1<<1)));
+
+	//7) 将ACC_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+	ACC_PLLCTL &= 0xfffffffe;
+	pll_wait(1000);
+}
+
+
+/**
+********************************************************************************
+ *   @n@b void SRIO_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  SRIO_PLL_Init初始化函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			PLLM ------- 倍频系数
+ *	   		PLLN ------- 分频系数
+ *	   		POSTDIV2 --- 后分频系数2
+ *	   		POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM  | PLLN | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | 500         | 50(DSK)       		| 60     | 1      |       3    |     1     |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM
+ *   	SRIO_PLL = FOUTVCO/POSTDIV2/POSTDIV1 	oscclk为输入时钟
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+void SRIO_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+	asm(" MFENCE ");
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2）将SRIO_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+	SRIO_PLLCTL |= 0x1;
+	pll_wait(20);
+
+	//	3) 将SRIO_PLLCMD中的ENPLL写为0，关断PLL；
+	SRIO_PLLCMD &= 0xfffffffe;
+
+	//	4) 设置SRIO_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+	SRIO_PLLCTL = (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+	//	5) 至少等待1us后将SRIO_PLLCMD中的ENPLL写为1；
+	pll_wait(200);
+	SRIO_PLLCMD |= 0x1;
+
+	//	6) 至少等待500us，或 至少等待500us，或 查询SRIO_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+	while(!(SRIO_PLLCMD & (1<<1)));
+
+	//7) 将SRIO_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+	SRIO_PLLCTL &= 0xfffffffe;
+	pll_wait(1000);
+}
+
+
+
+/**
+********************************************************************************
+ *   @n@b void SRIO2_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  SRIO2_PLL_Init初始化函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			PLLM ------- 倍频系数
+ *	   		PLLN ------- 分频系数
+ *	   		POSTDIV2 --- 后分频系数2
+ *	   		POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM  | PLLN | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | 500         | 50(DSK)       		| 60     | 1      |       3    |     1     |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM
+ *   	SRIO2_PLL = FOUTVCO/POSTDIV2/POSTDIV1 	oscclk为输入时钟
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+void SRIO2_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+	asm(" MFENCE ");
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2）将SRIO2_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+	SRIO2_PLLCTL |= 0x1;
+	pll_wait(20);
+
+	//	3) 将SRIO2_PLLCMD中的ENPLL写为0，关断PLL；
+	SRIO2_PLLCMD &= 0xfffffffe;
+
+	//	4) 设置SRIO2_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+	SRIO2_PLLCTL = (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+	//	5) 至少等待1us后将SRIO2_PLLCMD中的ENPLL写为1；
+	pll_wait(200);
+	SRIO2_PLLCMD |= 0x1;
+
+	//	6) 至少等待500us，或 查询SRIO2_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+	while(!(SRIO2_PLLCMD & (1<<1)));
+
+	//7) 将SRIO2_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+	SRIO2_PLLCTL &= 0xfffffffe;
+	pll_wait(1000);
+}
+
+
+	/**
+********************************************************************************
+ *   @n@b void ARM_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+ *
+ *   @b 功能：
+ *   @n  ARM_PLL_Init初始化函数
+ *
+ *   @b 形参：
+ *   @verbatim
+ *			PLLM ------- 倍频系数
+ *	   		PLLN ------- 分频系数
+ *	   		POSTDIV2 --- 后分频系数2
+ *	   		POSTDIV1 --- 后分频系数1
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | Rate (MHz)   | Input Clock (MHz)   | PLLM  | PLLN | POSTDIV1   | POSTDIV2  |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ * | 1400         | 50(DSK)       		| 56     | 1     |       2    |     1     |
+ * | 1200         | 50(DSK)       		| 48    | 1      |       2    |     1     |
+ * | 1000         | 50(DSK)       		| 60    | 1      |       3    |     2     |
+ * +--------------+---------------------+--------+--------+------------+-----------+
+ *   @endverbatim
+ *
+ *   <b> 返回值： </b>
+ *   @n 无
+ *
+ *   <b> 注意事项： </b>
+ *   @n FOUTVCO	= oscclk/PLLN * PLLM
+ *   	ARM_PLL = FOUTVCO/POSTDIV2/POSTDIV1 	oscclk为输入时钟
+ *    	1MHz<= oscclk <= 1200MHz
+ *    	2MHz<= oscclk/PLLN <=50MHz
+ *******************************************************************************
+ */
+void ARM_PLL_Init(uint16_t PLLM, uint8_t PLLN,  uint8_t POSTDIV1, uint8_t POSTDIV2)
+{
+	asm(" MFENCE ");
+	//	1) 各DSP核执行MFENCE指令，确保前序请求已处理完毕；
+	KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+	KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1
+
+	//	2）将ARM_PLLCTL中的BYPASS写为1，至少等待DSP_PLL晶振时钟oscclk八个时钟周期，来保证系统时钟切换到BYPASS模式；
+	ARM_PLLCTL |= 0x1;
+	pll_wait(20);
+
+	//	3) 将ARM_PLLCMD中的ENPLL写为0，关断PLL；
+	ARM_PLLCMD &= 0xfffffffe;
+
+	//	4) 设置ARM_PLLCTL的输入控制信号，包括：PLLN，PLLM，POSTDIV1,POSTDIV2；
+	ARM_PLLCTL =  (PLLN<<24)|(PLLM<<8)|(POSTDIV2<<4)|(POSTDIV1<<1)|(1<<0);
+
+	//	5) 至少等待1us后将ARM_PLLCMD中的ENPLL写为1；
+	pll_wait(200);
+	ARM_PLLCMD |= 0x1;
+
+	//	6) 至少等待500us，或 查询ARM_PLLCMD中的LOCK是否为1，如果为1，执行序列7，否则继续等待；
+	while(!(ARM_PLLCMD & (1<<1)));
+
+	//7) 将ARM_PLLCTL中的BYPASS写为0，将系统时钟切换到PLL模式。
+	ARM_PLLCTL &= 0xfffffffe;
+	pll_wait(1000);
+}
+
+
+
+
--- a/pnna/pnna-c6x/c6x_DDR_init/src/M6678V4_PSC.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/M6678V4_PSC.c
@ -0,0 +1,476 @@
+/**
+********************************************************************************
+* @file       M6678V4_PSC.c
+* @brief      实现M6678V4电源、时钟相关接口函数。
+* @version    V1.0
+* @date       2023.12.22
+* @attention
+* \par
+* ==============================================================================
+* @n   (C) 飞腾DSP技术支持团队.
+********************************************************************************
+*/
+#include <stdio.h>
+#include <string.h>
+#include "M6678V4_PSC.h"
+
+/** @addtogroup PSC_FUNCTION
+ @{ */
+
+/*******************************************************************************
+*函数名：PSC_Open_Clk(const char *string , unsigned int Power_Domain)
+*功    能： 开时钟接口函数
+*参    数：string表示准备开启时钟的区域
+*      Power_Domain指示控制了哪部分的电源转换
+*注    意：
+*     Power_Domain = 0 ，  控制内核部分
+*     Power_Domain = 1 ，  控制外设类
+*     Power_Domain = 2 ，  控制IP类
+*     Power_Domain = 3 ，  控制DSP类
+*******************************************************************************/
+void PSC_Open_Clk(const char *string , unsigned int Power_Domain)
+{
+	volatile int *psc_unit;
+	volatile int temp = 1 ;
+	volatile int *psc_com  = (int*)PTCMD_REG;
+	volatile int *psc_check= (int*)PTSTAT_REG;
+
+	if ( Power_Domain == 0 )
+	{
+		if (strcmp(string ,"DSP0CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP0CORE_offset);
+		}
+		else if (strcmp(string ,"DSP1CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP1CORE_offset);
+		}
+		else if (strcmp(string ,"DSP2CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP2CORE_offset);
+		}
+		else if (strcmp(string ,"DSP3CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP3CORE_offset);
+		}
+		else if (strcmp(string ,"DSP4CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP4CORE_offset);
+		}
+		else if (strcmp(string ,"DSP5CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP5CORE_offset);
+		}
+		else if (strcmp(string ,"DSP6CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP6CORE_offset);
+		}
+		else if (strcmp(string ,"DSP7CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP7CORE_offset);
+		}
+
+
+
+		*psc_unit = 3;             // MDCTLy 模块控制寄存器
+		*psc_com  = 1;             // PTCMD  电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+	else if ( Power_Domain == 1 )
+	{
+		if (strcmp(string ,"FFT") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + FFT_offset);
+		}
+		else if (strcmp(string ,"FFT1") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + FFT1_offset);
+		}
+		else if (strcmp(string ,"VIP") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + VIP_offset);
+		}
+		else if (strcmp(string ,"TP") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + TP_offset);
+		}
+		else if (strcmp(string ,"SMC") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SMC_offset);
+		}
+		else if (strcmp(string ,"EMIF") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + EMIF_offset);
+		}
+		else if (strcmp(string ,"DDR") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DDR_offset);
+		}
+		else if (strcmp(string ,"DMA0") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA0_offset);
+		}
+		else if (strcmp(string ,"DMA1") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA1_offset);
+		}
+		else if (strcmp(string ,"DMA2") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA2_offset);
+		}
+		else if (strcmp(string ,"DMA3") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA3_offset);
+		}
+		else if (strcmp(string ,"DMA4") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA4_offset);
+		}
+		else if (strcmp(string ,"GPIO") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + GPIO_offset);
+		}
+		else if (strcmp(string ,"I2C") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + I2C_offset);
+		}
+		else if (strcmp(string ,"SPI") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SPI_offset);
+		}
+		else if (strcmp(string ,"UART") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + UART_offset);
+		}
+		else if (strcmp(string ,"TIMER") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + TIMER_offset);
+		}
+		else if (strcmp(string ,"M1553B") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + M1553B_offset);
+		}
+		*psc_unit = 3;             // MDCTLy 模块控制寄存器
+		*psc_com  = 2;             // PTCMD 电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+	else if( Power_Domain == 2 )
+	{
+
+		if (strcmp(string ,"RGMII") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + RGMII_offset);
+		}
+		if (strcmp(string ,"SRIO0") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SRIO0_offset);
+		}
+		if (strcmp(string ,"SRIO1") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SRIO1_offset);
+		}
+		if (strcmp(string ,"SRIO2") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SRIO2_offset);
+		}
+		if (strcmp(string ,"PCIE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + PCIE_offset);
+		}
+
+		*psc_unit = 3;             // MDCTLy 模块控制寄存器
+		*psc_com  = 4;             // PTCMD 电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+	else if( Power_Domain == 3 )
+	{
+		if (strcmp(string ,"ARMA15") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + ARMA15_offset);
+		}
+		else if (strcmp(string ,"DSP0") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP0_offset);
+		}
+		else if (strcmp(string ,"DSP1") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP1_offset);
+		}
+		else if (strcmp(string ,"DSP2") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP2_offset);
+		}
+		else if (strcmp(string ,"DSP3") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP3_offset);
+		}
+		else if (strcmp(string ,"DSP4") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP4_offset);
+		}
+		else if (strcmp(string ,"DSP5") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP5_offset);
+		}
+		else if (strcmp(string ,"DSP6") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP6_offset);
+		}
+		else if (strcmp(string ,"DSP7") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP7_offset);
+		}
+		*psc_unit = 3;             // MDCTLy 模块控制寄存器
+		*psc_com  = 8;             // PTCMD 电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+}
+
+/*******************************************************************************
+*函数名：PSC_Close_Clk(const char *string , unsigned int Power_Domain)
+*功    能：关时钟接口函数
+*参    数：string表示准备开启时钟的区域
+*      Power_Domain指示控制了哪部分的电源转换
+*注    意：
+*     Power_Domain = 0 ，  控制内核部分
+*     Power_Domain = 1 ，  控制外设类
+*     Power_Domain = 2 ，  控制IP类
+*     Power_Domain = 3 ，  控制DSP类
+*******************************************************************************/
+void PSC_Close_Clk(const char *string , unsigned int Power_Domain)
+{
+	volatile int *psc_unit;
+	volatile int temp = 1 ;
+	volatile int *psc_com  = (int*)PTCMD_REG;
+	volatile int *psc_check= (int*)PTSTAT_REG;
+
+	if ( Power_Domain == 0 )
+	{
+		if (strcmp(string ,"DSP0CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP0CORE_offset);
+		}
+		else if (strcmp(string ,"DSP1CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP1CORE_offset);
+		}
+		else if (strcmp(string ,"DSP2CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP2CORE_offset);
+		}
+		else if (strcmp(string ,"DSP3CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP3CORE_offset);
+		}
+		else if (strcmp(string ,"DSP4CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP4CORE_offset);
+		}
+		else if (strcmp(string ,"DSP5CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP5CORE_offset);
+		}
+		else if (strcmp(string ,"DSP6CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP6CORE_offset);
+		}
+		else if (strcmp(string ,"DSP7CORE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DSP7CORE_offset);
+		}
+
+		*psc_unit = 0;             // MDCTLy 模块控制寄存器
+		*psc_com  = 1;             // PTCMD  电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+
+	else if ( Power_Domain == 1 )
+		{
+		if (strcmp(string ,"FFT") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + FFT_offset);
+		}
+		else if (strcmp(string ,"FFT1") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + FFT1_offset);
+		}
+		else if (strcmp(string ,"VIP") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + VIP_offset);
+		}
+		else if (strcmp(string ,"TP") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + TP_offset);
+		}
+		else if (strcmp(string ,"SMC") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SMC_offset);
+		}
+		else if (strcmp(string ,"EMIF") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + EMIF_offset);
+		}
+		else if (strcmp(string ,"DDR") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DDR_offset);
+		}
+		else if (strcmp(string ,"DMA0") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA0_offset);
+		}
+		else if (strcmp(string ,"DMA1") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA1_offset);
+		}
+		else if (strcmp(string ,"DMA2") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA2_offset);
+		}
+		else if (strcmp(string ,"DMA3") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA3_offset);
+		}
+		else if (strcmp(string ,"DMA4") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + DMA4_offset);
+		}
+		else if (strcmp(string ,"GPIO") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + GPIO_offset);
+		}
+		else if (strcmp(string ,"I2C") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + I2C_offset);
+		}
+		else if (strcmp(string ,"SPI") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SPI_offset);
+		}
+		else if (strcmp(string ,"UART") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + UART_offset);
+		}
+		else if (strcmp(string ,"TIMER") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + TIMER_offset);
+		}
+		else if (strcmp(string ,"M1553B") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + M1553B_offset);
+		}
+
+		*psc_unit = 0;             // MDCTLy 模块控制寄存器
+		*psc_com  = 2;             // PTCMD 电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+	else if( Power_Domain == 2 )
+		{
+		if (strcmp(string ,"RGMII") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + RGMII_offset);
+		}
+		if (strcmp(string ,"SRIO0") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SRIO0_offset);
+		}
+		if (strcmp(string ,"SRIO1") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SRIO1_offset);
+		}
+		if (strcmp(string ,"SRIO2") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + SRIO2_offset);
+		}
+		if (strcmp(string ,"PCIE") == 0)
+		{
+			psc_unit=(int*)(PSC_BASE + PCIE_offset);
+		}
+
+		*psc_unit = 0;             // MDCTLy 模块控制寄存器
+		*psc_com  = 4;             // PTCMD 电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+	else if( Power_Domain == 3 )
+		{
+			if (strcmp(string ,"ARMA15") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + ARMA15_offset);
+			}
+			else if (strcmp(string ,"DSP0") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP0_offset);
+			}
+			else if (strcmp(string ,"DSP1") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP1_offset);
+			}
+			else if (strcmp(string ,"DSP2") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP2_offset);
+			}
+			else if (strcmp(string ,"DSP3") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP3_offset);
+			}
+			else if (strcmp(string ,"DSP4") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP4_offset);
+			}
+			else if (strcmp(string ,"DSP5") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP5_offset);
+			}
+			else if (strcmp(string ,"DSP6") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP6_offset);
+			}
+			else if (strcmp(string ,"DSP7") == 0)
+			{
+				psc_unit=(int*)(PSC_BASE + DSP7_offset);
+			}
+		*psc_unit = 0;             // MDCTLy 模块控制寄存器
+		*psc_com  = 8;             // PTCMD 电源区域转换命令寄存器
+		do
+		{
+			temp=*psc_check;       // PTSTAT 电源区域转换状态寄存器
+		}
+		while(temp!=0);
+	}
+
+}
+
--- a/pnna/pnna-c6x/c6x_DDR_init/src/dram_init.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/dram_init.c
@ -0,0 +1,775 @@
+
+#include "mcu_config.h"
+#include "M6678V4_PLL.h"
+
+sys_dimm_info_t *dimm_info = (sys_dimm_info_t *)DIMM_INFO_SRAM_ADDR;
+
+/************DDR CTL BIST********************/
+/**
+********************************************************************************
+ *    DDR_start_data/address_bist(unsigned int ch, unsigned char end)
+ *
+ *       start   设置 bist的起始地址，一般为0x0
+ *       end    设置address/data bist的内存空间大小不超过2.^end - 1
+ *
+ *******************************************************************************
+ */
+static unsigned int DDR_start_address_bist(unsigned int ch,unsigned char end) {
+
+	unsigned int value = 0;
+
+	printf("Start CTL address bist \n");
+
+	//bist_addr_check = 1'b0
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<16, 0x0<<16);
+
+	//bist_data_check = 1'b0
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<8, 0x0<<8);
+
+	//bist_start_addr = 0
+	mcu_ctl_clrsetbits(ch, 471, MASK_32BIT,0x0);
+	mcu_ctl_clrsetbits(ch, 472, MASK_10BIT,0x0);
+
+	//BIST = 2^addr_space
+	mcu_ctl_clrsetbits(ch, 470, MASK_6BIT,end);
+	//bist_addr_check = 1'b1
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<16, 0x1<<16);
+	
+	//bist_test_mode  • ’b000 = Standard BIST operation
+	mcu_ctl_clrsetbits(ch, 477, MASK_3BIT<<16, 0x0<<16);
+//chen wang 
+	mcu_ctl_clrsetbits(ch, 583, MASK_1BIT, 0x1);	
+	mcu_ctl_clrsetbits(ch, 559, MASK_2BIT<<16, 0x0<<16);
+	mcu_ctl_clrsetbits(ch, 272, MASK_4BIT, 0x0);
+		
+	//bist_go = 1'b1
+	mcu_ctl_clrsetbits(ch, 469, MASK_1BIT<<16, 0x1<<16);
+
+//	check   INT STATUS BIST
+//	while((mcu_ctl_read32(ch, 597) & MASK_1BIT) != 0x1);
+	while(!((mcu_ctl_read32(ch, 597) >> 16) & 0x1));
+	/* ack */
+	mcu_ctl_clrsetbits(ch, 605, MASK_8BIT<<16, 0xff<<16);
+	//evaluate results
+	value = mcu_ctl_read32(ch, 469);
+	if ((value & (0x1 << 25)) == 0x0)
+	{
+		printf("CTL Address bist failed\n");
+
+	}
+	else
+	{
+		printf("CTL Address bist passed\n");
+
+	}
+
+	//bist_addr_check = 1'b0
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<16, 0x0<<16);
+	//bist_go = 1'b0
+	mcu_ctl_clrsetbits(ch, 469, MASK_1BIT<<16, 0x0<<16);
+	
+	mcu_ctl_clrsetbits(ch, 469, MASK_2BIT<<24, 0x0<<24);	//clear bist result
+	mcu_ctl_clrsetbits(ch, 605, 0x1<<16, 0x1<<16);			//bist int status ack (clear)
+
+
+	return 0;
+}
+static unsigned int DDR_start_data_bist(unsigned int ch , unsigned char end) {
+
+	unsigned int value = 0, value0 = 0;
+	printf("Start CTL data bist \n");
+
+	//bist_addr_check = 1'b0
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<16, 0x0<<16);
+	//bist_data_check = 1'b0
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<8, 0x0<<8);
+
+	//bist_start_addr = 0
+	mcu_ctl_clrsetbits(ch, 471, MASK_32BIT, 0x0);
+	mcu_ctl_clrsetbits(ch, 472, MASK_10BIT, 0x0);
+	//addr_space
+	mcu_ctl_clrsetbits(ch, 470, MASK_6BIT,end);
+	//bist_data_mask    ’b0 = do not mask error check  ’b1 = mask error check
+	mcu_ctl_clrsetbits(ch, 473, MASK_32BIT, 0x0);//MASK_32BIT);  	//[31:0]
+	mcu_ctl_clrsetbits(ch, 474, MASK_32BIT, 0x0);//MASK_32BIT);		//[63:32]   bit53 0x200000
+	mcu_ctl_clrsetbits(ch, 475, MASK_32BIT, 0x0);//MASK_32BIT);		//[95:94]
+	mcu_ctl_clrsetbits(ch, 476, MASK_32BIT, 0x0);//MASK_32BIT);    	//[127:96]
+	mcu_ctl_clrsetbits(ch, 477, MASK_16BIT, 0x0);//MASK_16BIT);		//[143:128]   ecc?
+
+	//bist_data_pattern
+	//bist_test_mode  • ’b000 = Standard BIST operation
+	mcu_ctl_clrsetbits(ch, 477, MASK_3BIT<<16, 0x0<<16);
+//chen wang 
+	mcu_ctl_clrsetbits(ch, 583, MASK_1BIT, 0x1);	
+	mcu_ctl_clrsetbits(ch, 559, MASK_2BIT<<16, 0x0<<16);
+	mcu_ctl_clrsetbits(ch, 272, MASK_4BIT, 0x0);
+	
+//	mcu_ctl_write32(ch, 477, 0x0);	
+	//bist_data_check = 1'b1
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<8, 0x1<<8);
+/***********TEST MODE*****************/	
+//	mcu_ctl_clrsetbits(ch, 487, MASK_12BIT<<8, 0x1<<8);		//err_stop
+//	mcu_ctl_clrsetbits(ch, 477, MASK_3BIT<<16, 0x1<<16);	//bist_test_mode
+//	if(dimm_info->spd_info[ch].ecc_type != ECC_TYPE)
+//		mcu_ctl_clrsetbits(ch, 477, MASK_16BIT, 0xffff);	//bist_test_mode
+//	mcu_ctl_write32(ch, 478, 0x11111111);
+//	mcu_ctl_write32(ch, 479, 0x22222222);
+//	mcu_ctl_write32(ch, 480, 0x44444444);
+//	mcu_ctl_write32(ch, 481, 0x88888888);
+//	mcu_ctl_write32(ch, 482, 0x33333333);
+//	mcu_ctl_write32(ch, 483, 0x77777777);
+//	mcu_ctl_write32(ch, 484, 0xffffffff);
+//	mcu_ctl_write32(ch, 485, 0xcccccccc);
+//	mcu_ctl_write32(ch, 486, 0xeeeeeeee);	
+		
+/***********TEST MODE*****************/	
+	
+	//bist_go = 1'b1
+	mcu_ctl_clrsetbits(ch, 469, MASK_1BIT<<16, 0x1<<16);
+
+//bist test mode 	bist  • ’b0 = BIST is not waiting • ’b1 = BIST is waiting
+//	while((mcu_ctl_read32(ch, 487) & MASK_1BIT) != 0x0);
+//	check_bist done  INT STATUS BIST
+//	while((mcu_ctl_read32(ch, 597) & MASK_1BIT) != 0x1);
+	while(!((mcu_ctl_read32(ch, 597) >> 16) & 0x1));
+
+	//bist_ret_state_exit
+//	while((mcu_ctl_read32(ch, 488) & MASK_1BIT) != 0x0);
+//	value0 = mcu_ctl_read32(ch, 469);
+//	printf("bist_ret_state_exit = 0x%x\n", value0 );
+	// int_ack_bist   clear the interrupt
+//	mcu_ctl_clrsetbits(ch, 605, MASK_8BIT<<16, 0xff<<16);
+	//int mask bist
+//	mcu_ctl_clrsetbits(ch, 613, MASK_8BIT<<16, 0xff<<16);
+	//evaluate results
+	value = mcu_ctl_read32(ch, 469);
+	if ((value & (0x1 << 24)) == 0x0)
+	{
+		printf("CTL Data bist failed\n");
+
+
+		printf("bist_err_stop				= 0x%x\r\n", mcu_ctl_read32(ch, 487));
+		printf("bist_err_count[11:0]		= 0x%x\r\n", (mcu_ctl_read32(ch, 488)& 0x00000fff));//& 0xFFFFF000
+		printf("CTL Data bist failed\r\n");
+		printf("bist_exp_data[31:0] 		= 0x%x\r\n", mcu_ctl_read32(ch, 619) );
+		printf("bist_exp_data[63:32] 		= 0x%x\r\n", mcu_ctl_read32(ch, 620) );
+		printf("bist_exp_data[95:64] 		= 0x%x\r\n", mcu_ctl_read32(ch, 621) );
+		printf("bist_exp_data[127:96] 		= 0x%x\r\n", mcu_ctl_read32(ch, 622) );
+		printf("bist_exp_data[159:128]		= 0x%x\r\n", mcu_ctl_read32(ch, 623) );
+		printf("bist_exp_data[191:160]		= 0x%x\r\n", mcu_ctl_read32(ch, 624) );
+		printf("bist_exp_data[223:192]		= 0x%x\r\n", mcu_ctl_read32(ch, 625) );
+		printf("bist_exp_data[255:224]		= 0x%x\r\n", mcu_ctl_read32(ch, 626) );
+		printf("bist_exp_data[287:256]		= 0x%x\r\n", mcu_ctl_read32(ch, 627) );
+
+		printf("bist_fail_data[31:0] 		= 0x%x\r\n", mcu_ctl_read32(ch, 628) );
+		printf("bist_fail_data[63:32] 		= 0x%x\r\n", mcu_ctl_read32(ch, 629) );
+		printf("bist_fail_data[95:64] 		= 0x%x\r\n", mcu_ctl_read32(ch, 630) );
+		printf("bist_fail_data[127:96]	 	= 0x%x\r\n", mcu_ctl_read32(ch, 631) );
+		printf("bist_fail_data[159:128] 	= 0x%x\r\n", mcu_ctl_read32(ch, 632) );
+		printf("bist_fail_data[191:160] 	= 0x%x\r\n", mcu_ctl_read32(ch, 633) );
+		printf("bist_fail_data[223:192] 	= 0x%x\r\n", mcu_ctl_read32(ch, 634) );
+		printf("bist_fail_data[255:224] 	= 0x%x\r\n", mcu_ctl_read32(ch, 635) );
+		printf("bist_fail_data[287:256] 	= 0x%x\r\n", mcu_ctl_read32(ch, 636) );
+
+		printf("bist_fail_addr[31:0] 		= 0x%x\r\n", mcu_ctl_read32(ch, 637) );
+		printf("bist_fail_addr[41:32] 		= 0x%x\r\n", (mcu_ctl_read32(ch, 638)& 0xFFFFFC00));
+
+	}
+	else
+	{
+		printf("CTL Data bist passed\n");
+
+	}
+
+	//bist_data_check = 1'b0
+	mcu_ctl_clrsetbits(ch, 470, MASK_1BIT<<8, 0x0<<8);
+
+	//bist_go = 1'b0
+	mcu_ctl_clrsetbits(ch, 469, MASK_1BIT<<16, 0x0<<16);
+	
+	mcu_ctl_clrsetbits(ch, 469, MASK_2BIT<<24, 0x0<<24);	//clear bist result
+	mcu_ctl_clrsetbits(ch, 605, 0x1<<16, 0x1<<16);			//bist int status ack (clear)
+
+
+	return 0;
+}
+/*******************************************/
+static unsigned int pi_address_bist(unsigned int ch,unsigned char end) {
+
+	unsigned int  i = 0;
+
+	printf("Start PI addr bist \n");
+
+//bist_start_addr = 0
+	mcu_pi_write32(ch, 151, 0x0);					//bist start address[31:0]
+	mcu_pi_clrsetbits(ch, 152, MASK_16BIT, 0x0);	//bist start address[47:32]
+	
+	//bist_addr_check = 1'b0
+	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<24, 0x0<<24);
+
+	//bist_data_check = 1'b0
+	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<16, 0x0<<16);
+
+
+	//BIST = 2^addr_space
+	mcu_pi_clrsetbits(ch, 150, MASK_8BIT<<8,end<<8);
+	
+	//bist_addr_check = 1'b1
+	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<24, 0x1<<24);
+	//bist_data_check = 1'b0
+//	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<16, 0x1<<16);	
+
+/***********************************************************/
+	mcu_pi_clrsetbits(ch, 158, MASK_12BIT<<0, 0x1);		//err_stop
+	mcu_pi_clrsetbits(ch, 179, MASK_3BIT<<0, 0X1<<0);	//patt
+	mcu_pi_clrsetbits(ch, 178, MASK_3BIT<<16, 0X1<<16);	//bist_mode
+	mcu_pi_write32(ch, 180, 0x55555555);
+	mcu_pi_write32(ch, 181, 0x55555555);
+	mcu_pi_write32(ch, 182, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 183, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 184, 0x55555555);
+	mcu_pi_write32(ch, 185, 0x55555555);
+	mcu_pi_write32(ch, 186, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 187, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 188, 0x7);
+#ifdef   WIDTH_32BIT	
+	mcu_pi_clrsetbits(ch, 154, MASK_32BIT, MASK_32BIT);
+	mcu_pi_clrsetbits(ch, 156, MASK_32BIT, MASK_32BIT);
+#endif
+	mcu_pi_clrsetbits(ch, 157, MASK_16BIT, 0xffff);
+//	mcu_pi_clrsetbits(ch, 157, MASK_16BIT, 0xff00);
+//	mcu_pi_clrsetbits(ch, 157, MASK_16BIT, 0x00ff);
+/***********************************************************/
+	
+	//bist_go = 1'b1
+	mcu_pi_clrsetbits(ch, 149, MASK_1BIT<<16, 0x1<<16);
+//	check   INT STATUS BIST
+	while(!((mcu_pi_read32(ch, 118) >> 14) & 0x1));
+
+
+		i = mcu_pi_read32(ch, 149);
+		if((i>>25)&0x1){
+			printf("DDR4 addr bist pass!\n");
+
+		}else{
+			printf("DDR4 addr bist fail!\n");
+
+		}
+	
+
+	mcu_pi_clrsetbits(ch, 149, MASK_2BIT<<24, 0x0<<24);		//clear bist result
+	mcu_pi_clrsetbits(ch, 149, 0x1<<16, 0x0<<16);			//bist disable
+	mcu_pi_clrsetbits(ch, 119, 0x1<<14, 0x1<<14);			//bist int status ack (clear)
+	mcu_pi_clrsetbits(ch, 150, 0x1<<16, 0x0<<16);			//clear bist_data_check_en
+	mcu_pi_clrsetbits(ch, 150, 0x1<<24, 0x0<<24);			//clear bist_addr_check_en
+//	printf("pi addr bist test end...\n");
+
+
+	return 0;
+}
+
+static unsigned int pi_data_bist(unsigned int ch,unsigned char end) {
+
+	unsigned int  i = 0;
+
+	printf("Start PI data bist \n");
+
+//bist_start_addr = 0
+	mcu_pi_write32(ch, 151, 0x0);					//bist start address[31:0]
+	mcu_pi_clrsetbits(ch, 152, MASK_16BIT, 0x0);	//bist start address[47:32]
+
+//	mcu_pi_write32(ch, 150, 0x10000 | addr_space<<8);	//bist_data_check[8] addr_space[5:0]
+//	mcu_pi_write32(ch, 150, 0x1000000 | addr_space<<8);	//bist_addr_check[16] addr_space[5:0]
+	
+	//bist_addr_check = 1'b0
+	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<24, 0x0<<24);
+
+	//bist_data_check = 1'b0
+	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<16, 0x0<<16);
+
+
+	//BIST = 2^addr_space
+	mcu_pi_clrsetbits(ch, 150, MASK_8BIT<<8,end<<8);
+	
+	//bist_addr_check = 1'b1
+//	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<24, 0x1<<24);
+	//bist_data_check = 1'b0
+	mcu_pi_clrsetbits(ch, 150, MASK_1BIT<<16, 0x1<<16);	
+	
+/***********************************************************/
+	mcu_pi_clrsetbits(ch, 158, MASK_12BIT<<0, 0x1);		//err_stop
+	mcu_pi_clrsetbits(ch, 179, MASK_3BIT<<0, 0X1<<0);	//patt
+	mcu_pi_clrsetbits(ch, 178, MASK_3BIT<<16, 0X1<<16);	//bist_mode
+	mcu_pi_write32(ch, 180, 0x55555555);
+	mcu_pi_write32(ch, 181, 0x55555555);
+	mcu_pi_write32(ch, 182, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 183, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 184, 0x55555555);
+	mcu_pi_write32(ch, 185, 0x55555555);
+	mcu_pi_write32(ch, 186, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 187, 0xaaaaaaaa);
+	mcu_pi_write32(ch, 188, 0x7);
+#ifdef   WIDTH_32BIT	
+	mcu_pi_clrsetbits(ch, 154, MASK_32BIT, MASK_32BIT);
+	mcu_pi_clrsetbits(ch, 156, MASK_32BIT, MASK_32BIT);
+#endif	
+	mcu_pi_clrsetbits(ch, 157, MASK_16BIT, 0xffff);
+/***********************************************************/
+	
+	//bist_go = 1'b1
+	mcu_pi_clrsetbits(ch, 149, MASK_1BIT<<16, 0x1<<16);
+//	check   INT STATUS BIST
+	while(!((mcu_pi_read32(ch, 118) >> 14) & 0x1));
+
+//	mcu_phy_clrsetbits(ch, 15, MASK_1BIT<<24, 0x1<<24);
+
+
+		i = mcu_pi_read32(ch, 149);
+		if((i>>24)&0x1){
+			printf("DDR data bist pass!\n" );
+
+		}else{
+			printf("DDR data bist fail!\n" );
+
+			i = mcu_pi_read32(ch, 140) & MASK_10BIT;
+			i = (i<<32) | mcu_pi_read32(ch, 139);
+			printf("bist fail addr: 0x%lx\n", (long unsigned int)i);
+
+			i = mcu_pi_read32(ch, 131+6);
+			i = (i<<32) | mcu_pi_read32(ch, 130+6);
+			printf("bist fail data: 0x%lx\n", (long unsigned int)i);
+
+			i = mcu_pi_read32(ch, 122+6);
+			i = (i<<32) | mcu_pi_read32(ch, 121+6);
+			printf("bist expe data: 0x%lx\n", (long unsigned int)i);
+
+			i = mcu_pi_read32(ch, 131+4);
+			i = (i<<32) | mcu_pi_read32(ch, 130+4);
+			printf("bist fail data: 0x%lx\n", (long unsigned int)i);
+			i = mcu_pi_read32(ch, 122+4);
+			i = (i<<32) | mcu_pi_read32(ch, 121+4);
+			printf("bist expe data: 0x%lx\n", (long unsigned int)i);
+
+			i = mcu_pi_read32(ch, 131+2);
+			i = (i<<32) | mcu_pi_read32(ch, 130+2);
+			printf("bist fail data: 0x%lx\n", (long unsigned int)i);
+			i = mcu_pi_read32(ch, 122+2);
+			i = (i<<32) | mcu_pi_read32(ch, 121+2);
+			printf("bist expe data: 0x%lx\n", (long unsigned int)i);
+
+			i = mcu_pi_read32(ch, 131);
+			i = (i<<32) | mcu_pi_read32(ch, 130);
+			printf("bist fail data: 0x%lx\n", (long unsigned int)i);
+			i = mcu_pi_read32(ch, 122);
+			i = (i<<32) | mcu_pi_read32(ch, 121);
+			printf("bist expe data: 0x%lx\n", (long unsigned int)i);
+		}
+
+	mcu_pi_clrsetbits(ch, 149, MASK_2BIT<<24, 0x0<<24);		//clear bist result
+	mcu_pi_clrsetbits(ch, 149, 0x1<<16, 0x0<<16);			//bist disable
+	mcu_pi_clrsetbits(ch, 119, 0x1<<14, 0x1<<14);			//bist int status ack (clear)
+	mcu_pi_clrsetbits(ch, 150, 0x1<<16, 0x0<<16);			//clear bist_data_check_en
+	mcu_pi_clrsetbits(ch, 150, 0x1<<24, 0x0<<24);			//clear bist_addr_check_en
+//	printf("pi data bist test end...\n");
+
+	return 0;
+}
+/***************************scrub_mem********************************/
+static unsigned int scrub_mem( uint32_t start_addr, uint8_t addr_space)
+{
+	int ch;
+	printf("DDR zero memory start...\n");
+	
+
+			
+	if (MCU_CHANNEL_CFG == 0x1)
+	 	ch = 0;
+	 	
+  	if (MCU_CHANNEL_CFG == 0x2)
+	 	ch = 1;
+	 	
+		mcu_ctl_write32(ch, 471, (start_addr>>0)  & 0xffffffff);	//bist start address[31:0]
+		mcu_ctl_write32(ch, 472, (start_addr>>32) & 0xffffffff);	//bist start address[47:32]
+	//	printf("DDR%d start_addr = 0x%llx, addr_space = %d scrub_mem \n", ch, start_addr, addr_space);
+		mcu_ctl_write32(ch, 470, 0x100 | addr_space);	//bist_data_check[8] addr_space[5:0]
+		mcu_ctl_write32(ch, 477, 0x40000);		//bist_test_mode
+		mcu_ctl_write32(ch, 478, 0x0);
+		mcu_ctl_write32(ch, 479, 0x0);
+		mcu_ctl_write32(ch, 480, 0x0);
+		mcu_ctl_write32(ch, 481, 0x0);
+		mcu_ctl_write32(ch, 482, 0x0);
+		mcu_ctl_write32(ch, 483, 0x0);
+		mcu_ctl_write32(ch, 484, 0x0);
+		mcu_ctl_write32(ch, 485, 0x0);
+		mcu_ctl_write32(ch, 486, 0x0);
+//		printf("DDR zero memory start...\n");	
+		
+		
+		mcu_ctl_write32(ch, 469, 0x10000);		//bist_go
+		while(!((mcu_ctl_read32(ch, 597) >> 16) & 0x1)){
+//			printf("CTL_597 = 0x%x\n", mcu_ctl_read32(ch, 597));;
+		}
+		mcu_ctl_write32(ch, 469, 0x0);
+//		mcu_ctl_clrsetbits(ch, 469, MASK_1BIT<<16, 0x0<<16);
+		mcu_ctl_clrsetbits(ch, 605, 0x1<<16, 0x1<<16);	//bist int status ack (clear)
+		mcu_ctl_clrsetbits(ch, 470, 0x1<<8, 0x0<<8);
+		printf("zero memory done\n");
+		
+
+
+	return 0;
+
+}
+/*******************************************/
+int DDR_CLK(DDR_CLK_t ddr_freq)
+    {
+
+	 if(ddr_freq == DDR_CLK_1600MHZ){
+		 	DDR_PLL_Init (128 , 1, 1, 1);
+//		 	DDR_PLL_Init (128 , 2, 1, 0);
+		}else if (ddr_freq == DDR_CLK_1466MHZ) {
+			DDR_PLL_Init (176, 3, 1, 0);
+   	 	} else if (ddr_freq == DDR_CLK_1333MHZ) {
+   	 		DDR_PLL_Init (160 , 3, 1, 0);
+   	 	}else if (ddr_freq == DDR_CLK_1200MHZ) {
+   	 		DDR_PLL_Init (96 , 1, 1, 1);
+   	 	} else if (ddr_freq == DDR_CLK_1066MHZ) {
+   	 		DDR_PLL_Init (128, 3, 1, 0);
+   	 	} else if (ddr_freq == DDR_CLK_933MHZ) {
+   	 		DDR_PLL_Init (224 , 3, 1, 1);
+   	 	}else { //800MHZ
+   	 		DDR_PLL_Init (128 , 1, 2, 1);
+   	 	}
+   	 		
+
+		return 0;
+}
+
+
+
+
+static void ddr4_reset(uint8_t ch)
+{
+
+
+    uint32_t offset = 0x4 * ch;
+
+	writel(0x8, 0x300100a8 + offset);
+	writel(0xc, 0x300100a8 + offset);
+	writel(0xf, 0x300100a8 + offset);
+
+#if 0
+	//7004v CLC  0x3001_0000
+/*
+    int tmp = readl(0x30000020);   //32GB interleave
+	tmp &= 0x1F << 22;
+	tmp |= 0x15 << 22;
+	writel(tmp, 0x30000020);    //
+*/
+
+#ifdef USING_DDRA
+	//DDR0 reset
+	writel(0x8, 0x300100a8);
+	writel(0xc, 0x300100a8);
+	writel(0xf, 0x300100a8);
+#endif
+
+#ifdef USING_DDRB
+	//DDR1 reset
+	writel(0x8, 0x300100ac);
+	writel(0xc, 0x300100ac);
+	writel(0xf, 0x300100ac);
+
+#endif
+#endif
+}
+
+
+//static void psc_ddr4_clk(uint8_t ch)
+//{
+//
+//    uint32_t offset = 0x4 * ch;
+//
+//	writel(0x3, PSC_BASE + DDR0_offset + offset);
+//	writel(0x2, PTCMD_REG);
+//
+//	while(readl(PTSTAT_REG));
+//
+//}
+
+
+static int caculate_ddr_freq(uint8_t ch)
+{
+		uint32_t freq,val;
+		uint32_t freq_val0 = 0 ,freq_val=0;
+		uint32_t refdiv,fbdiv,postdiv2,postdiv1;
+		val = 0x0;
+		KICK0=0x83e70b13;  //解锁Kicker机制寄存器 KICK0
+		KICK1=0x95a4f1e0;  //解锁Kicker机制寄存器KICK1    解锁后可随DSP_PLL控制寄存器进行软件操作（可写）
+
+		val = DDR_PLLCTL;
+
+		refdiv = (val & GENMASK(29,24))>>24;
+		fbdiv = (val & GENMASK(15,8))>>8;
+		postdiv2 = (val & GENMASK(5,4))>>4;
+		postdiv1 = (val & GENMASK(2,1))>>1;
+
+		freq_val = INPUT_CLOCK * fbdiv/refdiv/(1<<(postdiv2+postdiv1));
+//    printf("config DDR controller freq = %d Mhz\n", freq_val);
+		if(freq_val == 533|freq_val == 733){
+				freq = freq_val*2;
+		}else{
+			   freq_val = freq_val*2 ;
+			   freq_val0 = (freq_val % 100)?1:0;
+
+			   freq = freq_val + freq_val0 ;
+		}
+    printf("config DDR controller freq = %d Mhz\n", freq);
+
+	return freq ;
+
+}
+
+
+static int init_dimm_param(uint8_t ch)
+{
+    uint8_t temp;
+
+    dimm_info->lmu_frequency = caculate_ddr_freq(ch);  //MHz >=800  800   800 ; //
+    dimm_info->spd_info[ch].data_width = DIMM_x16;    //DIMM_x8
+    dimm_info->spd_info[ch].mirror_type = NO_MIRROR;
+    dimm_info->spd_info[ch].ecc_type = NO_ECC_TYPE;  //ECC_TYPE/NO_ECC_TYPE
+    dimm_info->spd_info[ch].rank_num = 1;
+    dimm_info->spd_info[ch].bg_num = 2;
+    dimm_info->spd_info[ch].row_num = ROW_NUM;
+    dimm_info->spd_info[ch].col_num = COL_NUM;
+    dimm_info->spd_info[ch].bank_num = 4;
+    dimm_info->spd_info[ch].dm_cfg = DM_1;  //DM_0
+
+    temp = (dimm_info->spd_info[ch].data_width == DIMM_x8)? 8 : 16;//x8,x16
+    dimm_info->spd_info[ch].sdram_density =
+        ((unsigned long long)(1<<(dimm_info->spd_info[ch].row_num + dimm_info->spd_info[ch].col_num)) * temp
+         * dimm_info->spd_info[ch].bg_num * dimm_info->spd_info[ch].bank_num) >> 20; //units: Mb
+
+    /* example : MT40A1G16-062E  3200Mhz Target CL-nRCD-nRP :22-22-22,  units:ps*/
+    if(dimm_info->lmu_frequency >= 800)  //1600Mb/s
+    {
+        dimm_info->spd_info[ch].tAAmin = 13750;
+        dimm_info->spd_info[ch].tRCDmin = 13750;//15
+        dimm_info->spd_info[ch].tRPmin = 13750;
+        dimm_info->spd_info[ch].tRASmin = 35000;
+        dimm_info->spd_info[ch].tRCmin = 48750; //RAS+RP
+        if(dimm_info->spd_info[ch].data_width == DIMM_x16) //2KB page size
+        {
+            dimm_info->spd_info[ch].tFAWmin = 35000;
+            dimm_info->spd_info[ch].tRRD_Smin = 6000; //different bank 6ns
+            dimm_info->spd_info[ch].tRRD_Lmin = 7500;  //same bank 7.5ns
+        }else{//1KB
+            dimm_info->spd_info[ch].tFAWmin = 25000;
+            dimm_info->spd_info[ch].tRRD_Smin = 5000;
+            dimm_info->spd_info[ch].tRRD_Lmin = 6000; //same bank 6ns ,different bank 5ns
+        }
+        dimm_info->spd_info[ch].tWRmin = 15000;//2ck=1CK + tWR1ck(15ns)
+        dimm_info->spd_info[ch].tWTR_Smin = 2500;
+        dimm_info->spd_info[ch].tWTR_Lmin = 7500;//2ck= 1CK + tWTR_L1ck(7.5ns)same bank  different bank =2.5ns
+    }else if(dimm_info->lmu_frequency >= 932) //1866Mb/s
+    {
+        dimm_info->spd_info[ch].tAAmin = 13620;
+        dimm_info->spd_info[ch].tRCDmin = 13920;//15
+        dimm_info->spd_info[ch].tRPmin = 13920;
+        dimm_info->spd_info[ch].tRASmin = 34000;
+        dimm_info->spd_info[ch].tRCmin = 47920;
+        if(dimm_info->spd_info[ch].data_width == DIMM_x16) //2KB page size
+        {
+            dimm_info->spd_info[ch].tFAWmin = 30000;
+            dimm_info->spd_info[ch].tRRD_Smin = 5300;
+            dimm_info->spd_info[ch].tRRD_Lmin = 6400;//same bank groups 6.4ns ,different 5.3ns
+        }else{
+            dimm_info->spd_info[ch].tFAWmin = 23000;
+            dimm_info->spd_info[ch].tRRD_Smin = 4200;
+            dimm_info->spd_info[ch].tRRD_Lmin = 5300;//same bank groups 5.3ns ,different 4.2ns
+        }
+        dimm_info->spd_info[ch].tWRmin = 15000;//2ck=1CK + tWR1ck(15ns)
+        dimm_info->spd_info[ch].tWTR_Smin = 2500;
+        dimm_info->spd_info[ch].tWTR_Lmin = 7500;//2ck= 1CK + tWTR_L1ck(7.5ns)same bank  different bank =2.5ns
+
+    }else if(dimm_info->lmu_frequency >= 1065) //2133Mb/s
+    {
+        dimm_info->spd_info[ch].tAAmin = 14060;
+        dimm_info->spd_info[ch].tRCDmin = 14060;//15
+        dimm_info->spd_info[ch].tRPmin = 14060;
+        dimm_info->spd_info[ch].tRASmin = 33000;
+        dimm_info->spd_info[ch].tRCmin = 47060;
+        if(dimm_info->spd_info[ch].data_width == DIMM_x16) //2KB page size
+        {
+            dimm_info->spd_info[ch].tFAWmin = 30000;
+            dimm_info->spd_info[ch].tRRD_Smin = 5300;
+            dimm_info->spd_info[ch].tRRD_Lmin = 6400;//same bank groups 6.4ns ,different 5.3n
+        }else{
+            dimm_info->spd_info[ch].tFAWmin = 21000;
+            dimm_info->spd_info[ch].tRRD_Smin = 3700;
+            dimm_info->spd_info[ch].tRRD_Lmin = 5300;//same bank groups 5.3ns ,different 3.7ns
+        }
+        dimm_info->spd_info[ch].tWRmin = 15000;//2ck=1CK + tWR1ck(15ns)
+        dimm_info->spd_info[ch].tWTR_Smin = 2500;
+        dimm_info->spd_info[ch].tWTR_Lmin = 7500;//2ck= 1CK + tWTR_L1ck(7.5ns)same bank  different bank =2.5ns
+
+    }else if(dimm_info->lmu_frequency >= 1200) //2400Mb/s
+    {
+        dimm_info->spd_info[ch].tAAmin = 13320;//13320
+        dimm_info->spd_info[ch].tRCDmin = 13320;//14.16  13320
+        dimm_info->spd_info[ch].tRPmin = 13320;
+        dimm_info->spd_info[ch].tRASmin = 32000;
+        dimm_info->spd_info[ch].tRCmin = 45320;//45320
+        if(dimm_info->spd_info[ch].data_width == DIMM_x16) //2KB page size
+        {
+            dimm_info->spd_info[ch].tFAWmin = 45000;
+            dimm_info->spd_info[ch].tRRD_Smin = 5300;
+            dimm_info->spd_info[ch].tRRD_Lmin = 6400;//same bank groups 6.4ns ,different 5.3ns
+        }else{
+            dimm_info->spd_info[ch].tFAWmin = 30000;
+            dimm_info->spd_info[ch].tRRD_Smin = 3300;
+            dimm_info->spd_info[ch].tRRD_Lmin = 4900;//same bank groups 4.9ns ,different 3.3ns
+        }
+        dimm_info->spd_info[ch].tWRmin = 15000;//2ck=1CK + tWR1ck(15ns)
+        dimm_info->spd_info[ch].tWTR_Smin = 2500;
+        dimm_info->spd_info[ch].tWTR_Lmin = 7500;//2ck= 1CK + tWTR_L1ck(7.5ns)same bank  different bank =2.5ns
+
+    }else if(dimm_info->lmu_frequency >= 1332) //2666Mb/s
+    {
+        dimm_info->spd_info[ch].tAAmin = 13500;
+        dimm_info->spd_info[ch].tRCDmin = 13500;//14.25
+        dimm_info->spd_info[ch].tRPmin = 13500;
+        dimm_info->spd_info[ch].tRASmin = 32000;
+        dimm_info->spd_info[ch].tRCmin = 45500;
+        if(dimm_info->spd_info[ch].data_width == DIMM_x16) //2KB page size
+        {
+            dimm_info->spd_info[ch].tFAWmin = 30000;
+            dimm_info->spd_info[ch].tRRD_Smin = 5300;
+            dimm_info->spd_info[ch].tRRD_Lmin = 6400;//same bank groups 6.4ns ,different 5.3ns
+        }else{
+            dimm_info->spd_info[ch].tFAWmin = 21000;
+            dimm_info->spd_info[ch].tRRD_Smin = 3000;
+            dimm_info->spd_info[ch].tRRD_Lmin = 4900;//same bank groups 4.9ns ,different 3.0ns
+        }
+        dimm_info->spd_info[ch].tWRmin = 15000;//2ck=1CK + tWR1ck(15ns)
+        dimm_info->spd_info[ch].tWTR_Smin = 2500;
+        dimm_info->spd_info[ch].tWTR_Lmin = 7500;//2ck= 1CK + tWTR_L1ck(7.5ns)same bank  different bank =2.5ns
+    }else if(dimm_info->lmu_frequency >=1465) //2933Mb/s
+    {
+        dimm_info->spd_info[ch].tAAmin = 13640;
+        dimm_info->spd_info[ch].tRCDmin = 13640;//14.32 13.75
+        dimm_info->spd_info[ch].tRPmin = 13640;//14.32 13.75
+        dimm_info->spd_info[ch].tRASmin = 32000;
+        dimm_info->spd_info[ch].tRCmin = 45640;//RAS+RP
+        if(dimm_info->spd_info[ch].data_width == DIMM_x16) //2KB page size
+        {
+            dimm_info->spd_info[ch].tFAWmin = 30000;
+            dimm_info->spd_info[ch].tRRD_Smin = 5300;
+            dimm_info->spd_info[ch].tRRD_Lmin = 6400;//same bank groups 6.4ns ,different 5.3ns
+        }else{
+            dimm_info->spd_info[ch].tFAWmin = 21000;
+            dimm_info->spd_info[ch].tRRD_Smin = 2700;
+            dimm_info->spd_info[ch].tRRD_Lmin = 4900;//same bank groups 4.9ns ,different 2.7ns
+        }
+        dimm_info->spd_info[ch].tWRmin = 15000;
+        dimm_info->spd_info[ch].tWTR_Smin = 2500;
+        dimm_info->spd_info[ch].tWTR_Lmin = 7500;
+
+    }else{ //1600MHZ  3200Mb/s
+        dimm_info->spd_info[ch].tAAmin = 13750;
+        dimm_info->spd_info[ch].tRCDmin = 13750;
+        dimm_info->spd_info[ch].tRPmin = 13750;
+        dimm_info->spd_info[ch].tRASmin = 32000;
+        dimm_info->spd_info[ch].tRCmin = 45750; //RAS+RP
+
+        if(dimm_info->spd_info[ch].data_width == DIMM_x16) //2KB page size
+        {
+            dimm_info->spd_info[ch].tFAWmin = 30000;
+            dimm_info->spd_info[ch].tRRD_Smin = 5300;
+            dimm_info->spd_info[ch].tRRD_Lmin = 6400;//same bank 6.4ns ,different bank 5.3ns
+        }else{
+            dimm_info->spd_info[ch].tFAWmin = 21000;
+            dimm_info->spd_info[ch].tRRD_Smin = 2500;
+            dimm_info->spd_info[ch].tRRD_Lmin = 4900;//same bank 4.9ns ,different bank 2.5ns
+        }
+
+        dimm_info->spd_info[ch].tWRmin = 15000;//2ck=1CK + tWR1ck(15ns)
+        dimm_info->spd_info[ch].tWTR_Smin = 2500;
+        dimm_info->spd_info[ch].tWTR_Lmin = 7500;//2ck= 1CK + tWTR_L1ck(7.5ns)same bank  different bank =2.5ns
+
+    }
+
+		print_spd_info(ch);
+
+		temp = (dimm_info->spd_info[ch].data_width == DIMM_x8)? 8 : 16;
+		dimm_info->spd_info[ch].dimm_capacity = dimm_info->spd_info[ch].sdram_density
+			* dimm_info->spd_info[ch].rank_num * 64 / temp >> 13;   //units: GB
+
+		printf("Systemp DRAM Capacity = %lldGB\r\n", dimm_info->spd_info[ch].dimm_capacity );
+		dimm_info->sys_dimm_capacity += dimm_info->spd_info[ch].dimm_capacity;
+
+		return 0;
+}
+
+
+
+static void clearspace(unsigned int addr, unsigned int size)
+{
+    unsigned int i;
+    for(i = 0; i < size; i+= 0x4)
+         writeq(0x0, addr + i);
+}
+
+
+void mcu_dram_init(void)
+{
+
+		printf("\n mcu start work \n");
+		uint8_t i;
+
+		clearspace(DIMM_INFO_SRAM_ADDR, 0x1000);
+
+
+    for (i = 0; i < MCU_CHANNEL_MAX; i++)
+    {  
+        if( !(MCU_CHANNEL_CFG & (0x1 << i)))
+            continue;
+
+		printf("\nMcu Channel %d\n", i);
+		
+        //ddr4_set_freq(i);
+        //psc_ddr4_clk(i);
+
+        ddr4_reset(i);
+
+        init_dimm_param(i);
+
+        mcu_init(i);
+
+#ifdef DDR_CTL_BIST
+		DDR_start_address_bist(i,BIST_32MB_SPACE);
+		DDR_start_data_bist(i,BIST_32MB_SPACE);//BIST_2GB_SPACE
+#endif
+
+#ifdef DDR_PI_BIST
+		pi_address_bist(i,BIST_32MB_SPACE);
+		pi_data_bist(i,BIST_32MB_SPACE);//BIST_32MB_SPACE
+#endif
+
+    }   
+    
+#ifdef DDR_Scrub_mem
+		scrub_mem(0 , BIST_2GB_SPACE);	//BIST_2GB_SPACE
+#endif
+
+#ifdef DDR_MEMTEST
+		dram_ddr_test();
+//		DMA_ddr_test();
+#endif
+
+//		qualiphy_test();
+
+
+}
+
--- a/pnna/pnna-c6x/c6x_DDR_init/src/main.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/main.c
@ -0,0 +1,91 @@
+/**
+**************************************************************************************************************************************************************
+*  @file 				main.c
+*  @brief  			用于 M6678V4 DDR  初始化等功能测试。
+*  @version 		V0
+*  @data				2023.12.21
+*  @attention		M6678V4  一个DDR独立
+*
+*   \par
+*   ===================================================================================================
+*   @n	(c)	飞腾DSP技术支持团队.
+**************************************************************************************************************************************************************
+*/
+#include <c6x.h>
+//#include <csl_cacheAux.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "mcu_config.h"
+#include "CORE_Memory_Test.h"
+#include "M6678V4_PSC.h"
+#include "M6678V4_PLL.h"
+
+int main(void)
+{
+/****************** 6678V4********************/
+//CACHE DISABLE
+//	Set_SM_Mode(SM_0KCACHE);
+//	CACHE_setL1PSize( CACHE_L1_0KCACHE );
+//	CACHE_setL1DSize( CACHE_L1_0KCACHE );
+//	CACHE_setL2Size( CACHE_0KCACHE );
+	// 输入时钟25M 输出主频 1250M  = 25M/1*100/2^(1+0)，主频，提供DSP核和部分外设部件时钟
+	DSP_PLL_Init(100, 1, 1, 0);
+
+	PSC_Close_Clk("DDR", 1);
+//	 *(unsigned int *)0x090200B4 = 0x1;
+//	 asm(" nop 5 ");
+//	 asm(" nop 5 ");
+//DDR PSC Enable
+	 PSC_Open_Clk("DDR", 1);
+	 *(unsigned int *)0x090200B4 = 0x1;			//DDR RESET 退出复位  （CLC）
+	 asm(" nop 5 ");
+	 asm(" nop 5 ");
+	 asm(" nop 5 ");
+/************DDR  freq entry ************************************************/
+/*
+ * Input DDR CLK
+ *option: 	DDR_CLK_800MHZ			DDR_CLK_1066MHZ		DDR_CLK_1333MHZ
+ *  	    DDR_CLK_1200MHZ 		DDR_CLK_1466MHZ		DDR_CLK_1600MHZ	
+****************** ******************************************************/
+	DDR_CLK( DDR_CLK_1600MHZ  );
+//	DDR_CLK( DDR_CLK_1200MHZ  );
+//	DDR_CLK( DDR_CLK_800MHZ  );
+
+
+/*******************DDR_init**************************/	
+	mcu_dram_init();
+
+/*************DDR_Band_Test**************************/		
+#ifdef DDR_Band_Test	
+	DDR_Bandwidth_Test();
+#endif	
+
+
+#if 0
+//	int i ;
+//    for(i = 0; i < 10000000; i++ )
+//    {
+	DSP_memory_test(0x80000000, 0x80100000, 1, "6678V4_DDR4");
+//	DSP_memory_test(0x80000000, 0x8f000000, 1, "6678V4_DDR4");
+//	DSP_memory_test(0x80000000, 0xFFFFFFFF, 1, "6678V4_DDR4");
+	DSP_memory_test(0x90000000, 0x90100000, 1, "6678V4_DDR4");
+	DSP_memory_test(0xa0000000, 0xa0100000, 1, "6678V4_DDR4");
+	DSP_memory_test(0xb0000000, 0xb0100000, 1, "6678V4_DDR4");
+	DSP_memory_test(0xc0000000, 0xc0100000, 1, "6678V4_DDR4");
+	DSP_memory_test(0xd0000000, 0xd0100000, 1, "6678V4_DDR4");
+	DSP_memory_test(0xe0000000, 0xe0100000, 1, "6678V4_DDR4");
+	DSP_memory_test(0xf0000000, 0xf0100000, 1, "6678V4_DDR4");
+//    }
+#endif
+
+/*************DDR_ECC_Test**************************/
+#ifdef ECC_test
+	ECC_int_test();
+#endif
+
+    return 0;
+}
+
+
+
--- a/pnna/pnna-c6x/c6x_DDR_init/src/mcu_display.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/mcu_display.c
--- a/pnna/pnna-c6x/c6x_DDR_init/src/mcu_init.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/mcu_init.c
@ -0,0 +1,685 @@
+#include "mcu_config.h"
+
+static void ctl_pi_phy_cfg(uint8_t ch)
+{
+
+    ctl_config(ch);
+    pi_config(ch);
+    phy_config(ch);
+
+}
+
+
+static void recfg_addressmap(uint8_t ch)
+{
+
+    uint32_t cs_map = 1;
+    uint32_t slice;
+
+    if(dimm_info->spd_info[ch].rank_num == 1)
+        cs_map = 1;
+
+    //CS_MAP
+    mcu_ctl_clrsetbits(ch, 558, MASK_4BIT<<16, cs_map<<16);
+
+    //PI_CS_MAP
+    mcu_pi_clrsetbits(ch, 14, MASK_16BIT<<8, cs_map<<8);
+
+    //WRLVL_CS_MAP
+    mcu_pi_clrsetbits(ch, 56, MASK_16BIT, cs_map);
+
+    //RDLVL_GATE_CS_MAP
+    mcu_pi_clrsetbits(ch, 77, MASK_16BIT<<16, cs_map<<16);
+
+    //RDLVL_CS_MAP
+    mcu_pi_clrsetbits(ch, 77, MASK_16BIT, cs_map);
+
+    //WDQLVL_CS_MAP
+    mcu_pi_clrsetbits(ch, 100, MASK_16BIT<<8, cs_map<<8);
+
+    //CS_MAP_DIMM_0
+    mcu_ctl_clrsetbits(ch, 162, MASK_4BIT<<24, cs_map<<24);
+
+    //CS_MAP_DIMM_1/2/3 = 0
+    mcu_ctl_write32(ch, 163, 0x0);
+
+    //RANK0_MAP_DIMM_0
+    mcu_ctl_clrsetbits(ch, 164, MASK_4BIT<<16, cs_map<<16);
+    //RANK0_MAP_DIMM_1
+    mcu_ctl_clrsetbits(ch, 164, MASK_4BIT<<24, 0x0<<24);
+
+    //PI_CS_MAP_DIMM_0
+    mcu_pi_clrsetbits(ch, 600, MASK_16BIT, cs_map);
+    //PI_CS_MAP_DIMM_1
+    mcu_pi_clrsetbits(ch, 600, MASK_16BIT<<16, 0x0<<16);
+
+    //PI_RANK0_MAP_DIMM_0
+    mcu_pi_clrsetbits(ch, 602, MASK_16BIT, cs_map);
+    //PI_RANK0_MAP_DIMM_1
+    mcu_pi_clrsetbits(ch, 602, MASK_16BIT<<16, 0x0<<16);
+
+    //BANK_DIFF
+    if(dimm_info->spd_info[ch].data_width == DIMM_x16)
+    {
+        mcu_ctl_clrsetbits(ch, 541, MASK_2BIT<<16, 0x1<<16);
+        mcu_pi_clrsetbits(ch, 111, MASK_2BIT<<24, 0x1<<24);
+    }
+
+    //ROW_DIFF
+    mcu_ctl_clrsetbits(ch, 542, MASK_3BIT<<16,
+        (MAX_ROW - dimm_info->spd_info[ch].row_num)<<16);
+    mcu_pi_clrsetbits(ch, 112, MASK_3BIT,
+        MAX_ROW - dimm_info->spd_info[ch].row_num);
+
+    //COL_DIFF
+    mcu_ctl_clrsetbits(ch, 543, MASK_3BIT<<16,
+        (MAX_COL - dimm_info->spd_info[ch].col_num)<<16);
+    mcu_pi_clrsetbits(ch, 197, MASK_4BIT,
+        (MAX_COL - dimm_info->spd_info[ch].col_num));
+
+    //PHY_PER_RANK_CS_MAP 
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 5 + (slice << 8), MASK_4BIT << 16, 0x1 << 16);
+    }
+
+    //PHY_MEM_CLASS  1:DDR4, 2:DDR5 default 2
+//must be 2, or wdqlvl error  
+//    for(slice = 0; slice < 9; slice++ )
+//    {
+//        mcu_phy_clrsetbits(ch, 24 + (slice << 8), MASK_3BIT << 24, 0x1 << 24);
+//    }
+	
+	//set CS_MSK = 0  qf
+//	mcu_ctl_clrsetbits(ch, 547, MASK_16BIT,	0x0);
+//	mcu_ctl_clrsetbits(ch, 549, MASK_16BIT,	0x0);
+//	mcu_ctl_clrsetbits(ch, 551, MASK_16BIT,	0x0);
+//	mcu_ctl_clrsetbits(ch, 553, MASK_16BIT,	0x0);
+	
+#ifdef WIDTH_32BIT
+	mcu_ctl_clrsetbits(ch, 559, MASK_1BIT<<0, 0x1<<0);
+#endif
+}
+
+static void mcu_rst(uint8_t ch)
+{
+
+	//PHY I/O retention disabled
+	mcu_misc_write(ch, 0x038, 0x55555555);
+	mcu_misc_write(ch, 0x03c, 0x55555555);
+
+	//;;open  interrupt_en ecc
+	mcu_misc_write(ch, 0x08, 0x1f);
+
+	//;; 1. axi_port reset
+
+	//;; 2. reset, bit[16]:apb_rst_n, bit[3]:rst_n
+	//;; 2.1 reset_register and release
+	mcu_misc_write(ch, 0x004, 0x00000009);
+	//;;repeat 1000 @ posedge top.pclk ;
+	mcu_misc_write(ch, 0x004, 0x00010009);
+	//;; 2.2 reset controller and release
+	mcu_misc_write(ch, 0x004, 0x00010001);
+	//DDR_Delay 10
+	mcu_misc_write(ch, 0x004, 0x00010009);
+	//;; 2.3 reset phy and release
+	mcu_misc_write(ch, 0x004, 0x00010008);
+	//DDR_Delay 10
+	mcu_misc_write(ch, 0x004, 0x00010009);
+	
+
+}
+
+static void recfg_dm(uint8_t ch)
+{
+
+    if(dimm_info->spd_info[ch].dm_cfg == DM_1)
+    {
+        mcu_pi_clrsetbits(ch, 108, MASK_1BIT<<24, 0x0<<24); 
+        mcu_ctl_clrsetbits(ch, 91, MASK_1BIT<<16, 0x0<<16); 
+
+
+        mcu_pi_clrsetbits(ch, 701, MASK_1BIT<<10, 0x1<<10);   //PI_MR5
+        mcu_ctl_clrsetbits(ch, 382, MASK_1BIT<<10, 0x1<<10);  //CTL_MR5
+    
+    }else{
+
+        mcu_pi_clrsetbits(ch, 108, MASK_1BIT<<24, 0x1<<24); 
+        mcu_ctl_clrsetbits(ch, 91, MASK_1BIT<<16, 0x1<<16); 
+
+        mcu_pi_clrsetbits(ch, 701, MASK_1BIT<<24, 0x0<<24);      //PI_MR5 
+        mcu_ctl_clrsetbits(ch, 382, MASK_1BIT<<10, 0x0<<10);     //CTL_MR5
+    }
+
+}
+
+static void recfg_data_width(uint8_t ch)
+{
+
+    if(dimm_info->spd_info[ch].data_width == DIMM_x16)
+    {
+        //PI_SLICE_PER_DEV_0
+        mcu_pi_clrsetbits(ch, 467, MASK_2BIT<<24, 0x2 << 24);
+
+        //PI_SLICE_PER_DEV_1
+        mcu_pi_clrsetbits(ch, 468, MASK_2BIT, 0x2);
+
+        //PI_SLICE_PER_DEV_2
+        mcu_pi_clrsetbits(ch, 468, MASK_2BIT << 8, 0x2 << 8);
+
+        //PI_SLICE_PER_DEV_3
+        mcu_pi_clrsetbits(ch, 468, MASK_2BIT << 16, 0x2 << 16);
+        
+        //MEMDATA_RATIO_X
+        mcu_ctl_clrsetbits(ch, 563, MASK_3BIT << 16, 0x2 << 16);
+        
+    }
+
+}
+
+static void recfg_performance(uint8_t ch)
+{
+	uint32_t slice;
+    //enable BG_ROTATE_EN
+    mcu_ctl_clrsetbits(ch, 589, MASK_1BIT<<16, 0x1<<16);//0x0
+    mcu_pi_clrsetbits(ch,  197, MASK_1BIT<<8,  0x1<<8 );//0x0
+
+    //IN_ORDER_ACCEPT enable
+    mcu_ctl_clrsetbits(ch, 583, MASK_1BIT, 0x1);//0x0 0x1
+    
+
+//PHY DDL TRACK UPD THRESHOLD  default 0x4
+ for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 67 + (slice<<8), MASK_8BIT<<0, 0x8<<0);// 0x8 0xc 
+        
+    }   
+
+//	mcu_ctl_clrsetbits(ch, 513, MASK_5BIT<<24, 0x10<<24);
+
+//	mcu_phy_clrsetbits(ch, 3133, MASK_4BIT<<16, 0xb<<16);
+
+
+}
+
+static void recfg_ecc(uint8_t ch)
+{
+
+    if(dimm_info->spd_info[ch].ecc_type == ECC_TYPE) {
+
+       //1: enable ECC with no error detecton or error correction
+       //2: enable ECC with error detection without error correction
+       //3: enable ECC with both error detection and error correction
+       mcu_ctl_clrsetbits(ch, 488, MASK_2BIT<<24, 0x3<<24); 
+        
+       //control_reg 491,bit8:0 ECC WRITEBACK EN
+       mcu_ctl_clrsetbits(ch, 491, MASK_1BIT<<8, 0x1<<8); 
+
+		//PI ECC EN
+	   mcu_pi_clrsetbits(ch, 98, MASK_1BIT<<16, 0x1<<16);
+
+       //ECC_TYPE   0:out-of-band ECC,  1:in-line ECC
+       //control_reg 491, default: 0   1 £ºin-line
+//	   mcu_ctl_clrsetbits(ch, 491, MASK_1BIT<<16, 0x0<<16);
+       
+       
+       
+//     mcu_ctl_clrsetbits(ch, 562, MASK_1BIT<<24, 0x0<<24);//ecc_axi_error_response_inhibit
+//	   mcu_ctl_clrsetbits(ch, 491, MASK_1BIT<< 0, 0x1<< 0);//ecc_disable_w_uc_err
+    
+    
+    }else{
+
+       mcu_ctl_clrsetbits(ch, 488, MASK_2BIT<<24, 0x0<<24); 
+
+       mcu_pi_clrsetbits(ch, 98, MASK_1BIT<<16, 0x0<<16);
+    }
+}
+
+static void recfg_dly(uint8_t ch)
+{
+
+    uint32_t dly = 0x3;//0x1f //0x3
+    
+/*
+    //R2R_DIFFCS_DLY
+    mcu_ctl_clrsetbits(ch, 648, MASK_5BIT << 24, dly << 24);
+    
+    //W2W_DIFFCS_DLY
+    mcu_ctl_clrsetbits(ch, 649, MASK_5BIT << 16, dly << 16);
+
+    //W2R_DIFFCS_DLY
+    mcu_ctl_clrsetbits(ch, 649, MASK_5BIT << 8, dly << 8);
+
+    //R2W_DIFFCS_DLY
+    mcu_ctl_clrsetbits(ch, 649, MASK_5BIT, dly);
+*/
+    //R2W_SAMECS_DLY
+//    dly = (mcu_ctl_read32(ch, 651) >> 24) & MASK_5BIT;
+//    dly += 1;
+    mcu_ctl_clrsetbits(ch, 651, MASK_5BIT << 24, dly << 24);
+
+    //W2R_SAMECS_DLY
+//    dly = (mcu_ctl_read32(ch, 652) >> 24) & MASK_5BIT;
+//    dly += 1;    
+    mcu_ctl_clrsetbits(ch, 652, MASK_5BIT << 24, dly << 24);
+
+    //R2R_SAMECS_DLY
+//    dly = (mcu_ctl_read32(ch, 652) >> 16) & MASK_5BIT;
+//    dly += 1;    
+//    mcu_ctl_clrsetbits(ch, 652, MASK_5BIT << 16, dly << 16);
+	mcu_ctl_clrsetbits(ch, 652, MASK_5BIT << 16, 0x0 << 16);
+
+    //W2W_SAMECS_DLY
+//    dly = mcu_ctl_read32(ch, 653)  & MASK_5BIT;
+//    dly += 1;   
+//    mcu_ctl_clrsetbits(ch, 653, MASK_5BIT, dly);
+    mcu_ctl_clrsetbits(ch, 653, MASK_5BIT, 0x0);
+    
+//    mcu_ctl_clrsetbits(ch, 648, MASK_5BIT <<  0,    0x0 <<  0);// rw2mrw_dly         <<  0);
+//    mcu_ctl_clrsetbits(ch, 648, MASK_5BIT << 24,    0x4 << 24);//r2r_diffcs_dly     << 24);
+//    mcu_ctl_clrsetbits(ch, 649, MASK_5BIT <<  0,    0x6 <<  0);//r2w_diffcs_dly     <<  0);
+//    mcu_ctl_clrsetbits(ch, 649, MASK_5BIT <<  8,    0x3 <<  8);//w2r_diffcs_dly     <<  8);
+//    mcu_ctl_clrsetbits(ch, 649, MASK_5BIT << 16,    0x0 << 16);//w2w_diffcs_dly     << 16);
+//    mcu_ctl_clrsetbits(ch, 651, MASK_5BIT << 24,    0x4 << 24);//r2w_samecs_dly     << 24);
+    	mcu_ctl_clrsetbits(ch, 652, MASK_5BIT << 24,    0x0 << 24);// w2r_samecs_dly     << 24);
+//    mcu_ctl_clrsetbits(ch, 652, MASK_5BIT << 16,    0x0 << 16);//r2r_samecs_dly     << 16);
+//    mcu_ctl_clrsetbits(ch, 653, MASK_5BIT <<  0,    0x0 <<  0);//w2w_samecs_dly     <<  0);
+
+}
+
+
+
+static void recfg_timing(uint8_t ch)
+{
+
+    const uint32_t rst_1 = 300; //200 300  //units: us
+    const uint32_t rst_2 = 800; //500 800  //units: us
+    const uint32_t TREF = 78;   //78  //units: us * 10;
+    const uint32_t TRFC = 350;     //units: ns,  16Gb; //350 550
+   	const uint32_t TINIT0 = 800;    //units: us
+   	
+// 	if(dimm_info->lmu_frequency >= 1333	){	//preamble_support
+//   		mcu_ctl_clrsetbits(ch, 584, MASK_2BIT<<16,	0x3<<16);
+//		mcu_pi_clrsetbits(ch, 359, MASK_2BIT<<0,	0x3<<0);
+		
+//		for(slice = 0; slice < 9; slice++)//2 cycle preamble support
+//		{
+//			mcu_phy_clrsetbits(ch, 80 + (slice<<8), MASK_2BIT<<16, 0x3<<16);
+//		}
+//   	}
+	
+    uint32_t trst_pwron = rst_1 * dimm_info->lmu_frequency;
+    uint32_t tcke_inactive = rst_2 * dimm_info->lmu_frequency;
+    uint32_t tref = TREF * dimm_info->lmu_frequency / 10;
+    uint32_t trfc = TRFC * dimm_info->lmu_frequency / 1000;
+//    uint32_t trfc_dlr  =  trfc >>1;
+    uint32_t tdll;
+    uint32_t tinit = TINIT0 * dimm_info->lmu_frequency;
+    uint32_t slice;
+	uint32_t tras_max = 9 * tref ;
+	
+    mcu_ctl_write32(ch, 23, trst_pwron);
+    mcu_pi_write32(ch, 201, trst_pwron);
+    mcu_ctl_write32(ch, 24, tcke_inactive);
+    mcu_pi_write32(ch, 202, tcke_inactive);
+//    mcu_ctl_clrsetbits(ch,  23,MASK_32BIT <<  0,   trst_pwron    <<  0);
+//    mcu_ctl_clrsetbits(ch,  24,MASK_32BIT <<  0,   tcke_inactive <<  0);
+//    mcu_pi_clrsetbits(ch, 201,MASK_32BIT <<  0,    trst_pwron    <<  0);
+//    mcu_pi_clrsetbits(ch, 202,MASK_32BIT <<  0,    tcke_inactive <<  0);
+
+//	mcu_ctl_clrsetbits(ch, 172,MASK_20BIT <<  0,    tref <<  0);
+//	mcu_pi_clrsetbits(ch,  253,MASK_20BIT <<  0,    tref <<  0);
+    mcu_ctl_write32(ch, 172, tref);
+    mcu_pi_write32(ch, 253, tref);
+
+ //qf   
+    mcu_ctl_clrsetbits(ch,  74,MASK_20BIT <<  0,    tras_max <<  0);
+    mcu_pi_clrsetbits(ch,  311,MASK_20BIT <<  0,    (tras_max*9/10) <<  0);
+
+    mcu_ctl_clrsetbits(ch, 171, MASK_10BIT << 16, trfc << 16);
+    mcu_pi_write32(ch, 252, trfc);
+//    mcu_ctl_clrsetbits(ch, 173,MASK_10BIT <<  0,   trfc_dlr <<  0);
+//    mcu_pi_clrsetbits(ch,  258,MASK_10BIT <<  0,   trfc_dlr <<  0);
+    
+//    tinit = 240000 * 4;//160000
+//	printf("tinit = %d\n", tinit);
+	mcu_ctl_clrsetbits(ch,  7, MASK_24BIT <<  8,   tinit  <<  8);
+	mcu_pi_clrsetbits(ch, 337, MASK_24BIT <<  0,    tinit  <<  0);
+//    tdll = 0x400 ;//0x225
+    switch(dimm_info->lmu_frequency) {//tdllk
+        case  800: tdll = 0x0255; break;
+        case  933: tdll = 0x0255; break;
+        case 1066: tdll = 0x0300; break;
+        case 1200: tdll = 0x0300; break;
+        case 1333: tdll = 0x0400; break;
+        case 1466: tdll = 0x0400; break;
+        case 1600: tdll = 0x0400; break;
+        default:   tdll = 0x0400; break;
+    }
+    
+    mcu_ctl_clrsetbits(ch,  25,MASK_16BIT <<  0,    tdll   <<  0);
+    mcu_pi_clrsetbits(ch, 333,MASK_16BIT <<  8,     tdll   <<  8);
+
+    
+
+///*********************** DFI PHY MASTER INTERFACE*********************/qf
+//    uint32_t tdfi_phymstr_max ;
+//    uint32_t tdfi_phymstr_resp ;
+
+//    tdfi_phymstr_max = 128 * tref; //32 * tref * max cs number
+//    tdfi_phymstr_resp = 7 * tref;//7 * tref;
+
+//    tdfi_phymstr_max = 0;	//128 * tref; //32 * tref * max cs number	
+//	tdfi_phymstr_resp = 0;	//qlc test
+
+//    mcu_ctl_clrsetbits(ch, 217,MASK_32BIT <<  0,    tdfi_phymstr_max   <<  0);
+//    mcu_ctl_clrsetbits(ch, 218,MASK_32BIT <<  0,    tdfi_phymstr_max   <<  0);
+//    mcu_ctl_clrsetbits(ch, 219,MASK_32BIT <<  0,    tdfi_phymstr_max   <<  0);
+//    mcu_ctl_clrsetbits(ch, 220,MASK_32BIT <<  0,    tdfi_phymstr_max   <<  0);
+//    mcu_ctl_clrsetbits(ch, 221,MASK_32BIT <<  0,    tdfi_phymstr_max   <<  0);
+//    mcu_ctl_clrsetbits(ch, 223,MASK_20BIT <<  0,    tdfi_phymstr_resp  <<  0);
+//
+//	mcu_ctl_write32(ch, 287, 0xffffff);		//TDFI INIT START F0 
+//	mcu_ctl_write32(ch, 288, 0xffffff);		//TDFI INIT COMPLETE F0
+	
+
+/*********************** qf*********************/
+
+
+}
+//************************BASIC DRAM TIMING******************************//
+static void basic_dram_timing(uint8_t ch)
+{
+	uint32_t caslat ;
+	uint32_t tccd,tccd_l;
+	uint32_t trrd, trrd_l, trrd_dlr;
+	uint32_t trc;
+    uint32_t tras_min;
+    uint32_t trp;
+    uint32_t trtp;
+    uint32_t trcd;
+    uint32_t twr;
+    uint32_t tdal;
+    uint32_t twtr;
+    uint32_t twtr_l;
+    uint32_t trtp_ap;
+    uint32_t tvref ;
+    uint32_t tsdo ;
+    uint32_t tpdex;
+	uint32_t txp;
+	uint32_t txsnr;
+	uint32_t tcke;
+	uint32_t tckesr;
+	uint32_t tckelpd;
+	uint32_t tstab;
+
+
+	caslat = ddr_para_cycle_rnd (dimm_info->spd_info[ch].tAAmin,dimm_info->lmu_frequency);
+//	printf("caslat = %d\n", caslat);
+	mcu_ctl_clrsetbits(ch,  54, MASK_7BIT <<  0,   (caslat * 2) <<  0);
+	mcu_pi_clrsetbits(ch, 249,  MASK_7BIT <<  0,   (caslat * 2) <<  0);	
+	trrd = ddr_para_cycle_rnd_jit(dimm_info->spd_info[ch].tRRD_Smin,dimm_info->lmu_frequency);
+    trrd_l = ddr_para_cycle_rnd(dimm_info->spd_info[ch].tRRD_Lmin,dimm_info->lmu_frequency);
+	trrd_dlr = 0 ;
+	trc = ddr_para_cycle_rnd(dimm_info->spd_info[ch].tRCmin,dimm_info->lmu_frequency);
+    tras_min = ddr_para_cycle_rnd_jit (dimm_info->spd_info[ch].tRASmin,dimm_info->lmu_frequency);
+	trp = ddr_para_cycle_rnd(dimm_info->spd_info[ch].tRPmin,dimm_info->lmu_frequency);
+	trtp = ddr_para_cycle_rnd (7500,dimm_info->lmu_frequency);
+//	printf("trtp = %d\n", trtp);
+//	trtp = ddr_para_cycle_rnd_jit (7500,dimm_info->lmu_frequency);
+	trtp_ap = trtp;
+	trcd = ddr_para_cycle_rnd_jit (dimm_info->spd_info[ch].tRCDmin,dimm_info->lmu_frequency);
+//	twr = trtp*2;	//ddr_para_cycle_rnd_jit (dimm_info->spd_info[ch].tWRmin,dimm_info->lmu_frequency);
+	twr = ddr_para_cycle_rnd_jit (dimm_info->spd_info[ch].tWRmin,dimm_info->lmu_frequency);
+//    tdal = ddr_para_cycle_rnd_jit (dimm_info->spd_info[ch].tRPmin,dimm_info->lmu_frequency) + twr;//trp + twr;
+    twtr = ddr_para_cycle_rnd(dimm_info->spd_info[ch].tWTR_Smin,dimm_info->lmu_frequency);
+    twtr_l = ddr_para_cycle_rnd(dimm_info->spd_info[ch].tWTR_Lmin,dimm_info->lmu_frequency);
+  //wtr s: 2.5ns  wtr l :7.5ns  
+//    printf("wtr = %d  wtrl = %d\n", twtr,twtr_l);
+    tvref = ddr_para_cycle_rnd(150000,dimm_info->lmu_frequency);//150ns
+    tsdo  = ddr_para_cycle_rnd( 24000,dimm_info->lmu_frequency);// 24ns
+	tpdex = ddr_para_cycle_rnd(6000,dimm_info->lmu_frequency);// txp: max {4nCK,6ns}
+	txp = ddr_para_cycle_rnd(7500,dimm_info->lmu_frequency) + 3;
+	txsnr = 362* dimm_info->lmu_frequency / 1000;
+//	printf("trtp1 = %d\n", trtp);
+	txsnr = ddr_para_cycle_rnd(362000,dimm_info->lmu_frequency);
+//	printf("trtp2 = %d\n", trtp);
+	
+    tccd = 4;
+    switch(dimm_info->lmu_frequency) {
+        case  800: tccd_l = 5; break;
+        case  933: tccd_l = 5; break;
+        case 1066: tccd_l = 6; break;
+        case 1200: tccd_l = 6; break;
+        case 1333: tccd_l = 7; break;
+        case 1466: tccd_l = 7; break;
+        case 1600: tccd_l = 8; break;
+        default:   tccd_l = 8; break;
+    }
+    switch(dimm_info->lmu_frequency) {
+        case  800: tcke = 4; break;
+        case  933: tcke = 5; break;
+        case 1066: tcke = 6; break;
+        case 1200: tcke = 6; break;
+        case 1333: tcke = 7; break;
+        case 1466: tcke = 8; break;
+        case 1600: tcke = 8; break;
+        default:   tcke = 8; break;
+    }
+    tckesr = tcke + 1; 
+    tckelpd  = tcke;
+    
+    tstab = ddr_para_cycle_rnd(5000,dimm_info->lmu_frequency) * 1000;//5us
+    
+    mcu_ctl_clrsetbits(ch,  74, MASK_5BIT << 24,    tcke    << 24);
+    mcu_ctl_clrsetbits(ch,  75, MASK_8BIT <<  0,    tckesr  <<  0);
+    mcu_ctl_clrsetbits(ch, 200, MASK_5BIT <<  0,    tckelpd <<  0);
+    mcu_ctl_clrsetbits(ch,  60, MASK_5BIT <<  8,    tccd    <<  8);
+    mcu_ctl_clrsetbits(ch,  60, MASK_5BIT << 16,    tccd_l  << 16);
+    mcu_pi_clrsetbits(ch,  112, MASK_5BIT <<  8,    tccd    <<  8);
+    mcu_pi_clrsetbits(ch,  310, MASK_5BIT <<  0,    tccd_l  <<  0);
+    
+    mcu_ctl_clrsetbits(ch,  60, MASK_8BIT << 24,    trrd       << 24);
+    mcu_ctl_clrsetbits(ch,  61, MASK_8BIT <<  0,    trrd_l     <<  0);
+    mcu_ctl_clrsetbits(ch,  61, MASK_8BIT <<  8,    trrd_dlr   <<  8);
+    
+    mcu_ctl_clrsetbits(ch,  61, MASK_9BIT << 16,    trc        << 16);
+    
+    mcu_ctl_clrsetbits(ch,  62, MASK_9BIT <<  0,    tras_min   <<  0);
+    mcu_pi_clrsetbits(ch,  312, MASK_9BIT <<  0,    tras_min   <<  0);
+    
+    mcu_ctl_clrsetbits(ch,  82, MASK_8BIT << 24,    twr        << 24);
+    mcu_pi_clrsetbits(ch,  310, MASK_8BIT << 16,    twr        << 16);
+    mcu_ctl_clrsetbits(ch,  62, MASK_6BIT << 16,    twtr       << 16);
+    
+    mcu_ctl_clrsetbits(ch,  62, MASK_6BIT << 24,    twtr_l     << 24);
+    mcu_pi_clrsetbits(ch,  310, MASK_6BIT <<  8,    twtr_l     <<  8);
+    mcu_ctl_clrsetbits(ch,  63, MASK_8BIT <<  0,    trp        <<  0);
+    mcu_pi_clrsetbits(ch,  309, MASK_8BIT << 16,    trp        << 16);
+    mcu_ctl_clrsetbits(ch,  72, MASK_8BIT << 24,    trtp       << 24);
+    mcu_pi_clrsetbits(ch,  309, MASK_8BIT <<  8,    trtp       <<  8);
+    
+    mcu_ctl_clrsetbits(ch,  86, MASK_8BIT <<  0,    trp           <<  0);
+    mcu_ctl_clrsetbits(ch,  86, MASK_8BIT << 24,    trp           << 24);
+    mcu_ctl_clrsetbits(ch,  87, MASK_8BIT << 16,    trp           << 16);
+    mcu_ctl_clrsetbits(ch,  88, MASK_8BIT <<  8,    trp           <<  8);
+    
+    mcu_ctl_clrsetbits(ch,  73, MASK_8BIT <<  0,    trtp_ap    <<  0);
+    
+    mcu_ctl_clrsetbits(ch,  82, MASK_8BIT << 16,    trcd       << 16);
+    mcu_pi_clrsetbits(ch,  309, MASK_8BIT << 24,    trcd       << 24);
+    
+    mcu_ctl_clrsetbits(ch,  85, MASK_8BIT <<  0,    tdal       <<  0);
+ 
+    mcu_ctl_clrsetbits(ch, 187,MASK_16BIT <<  0,    tpdex      <<  0);
+    
+    mcu_pi_clrsetbits(ch, 232,MASK_16BIT <<  0,    tvref  <<  0);
+    mcu_pi_clrsetbits(ch, 243, MASK_8BIT <<  0,    tsdo   <<  0);
+    mcu_pi_clrsetbits(ch, 287, MASK_5BIT << 16,    txp    << 16);
+    
+    mcu_ctl_clrsetbits(ch,197,MASK_16BIT <<  0,     txsnr  <<  0);
+    mcu_ctl_clrsetbits(ch, 194,MASK_16BIT << 16,    txsnr  << 16);
+    mcu_pi_clrsetbits(ch,  341,MASK_16BIT <<  0,    txsnr  <<  0);
+    
+ 	mcu_ctl_clrsetbits(ch, 160,MASK_24BIT <<  8,  tstab <<  8);
+ 	mcu_pi_clrsetbits(ch,  234,MASK_24BIT <<  0,  tstab <<  0);
+    
+    
+}
+static void recfg_mr(uint8_t ch)
+{
+
+    uint16_t set_rtt_nom = RTT_NOM_48OHM;//RTT_NOM_80OHM
+    uint16_t set_drv = DRV_IMP_34OHM;//DRV_IMP_48OHM
+    uint16_t set_park = RTT_PARK_120OHM; //RTT_PARK_DIS;  //RTT_PARK_120OHM; 
+    uint16_t set_vref = 0x14;//0x1F
+	uint16_t mr0_cl;
+	uint16_t mr0_twr;
+	uint16_t mr2_cwl;
+	uint32_t cwl_v = 0;
+	uint32_t cl_v = 0;
+	uint32_t twr_v = 0;
+    
+//    const timing_t speed[] = {
+//	    {22, 16, 22 },    //SPEED_3200
+//	    {22, 16, 22 },    //SPEED_2933
+//	    {20, 18, 20 },    //SPEED_2666
+//	    {18, 16, 18},    //SPEED_2400
+//	    {16, 14, 14},    //SPEED_2133
+//	    {14, 10, 16},    //SPEED_1866
+//	    {12, 9, 12},    //SPEED_1600
+//	    {22, 16, 22 }     //SPEED_OTHERS //3200 MT/s
+//    };
+//    
+    
+    
+    
+
+    //MR0
+    /*
+     * bit[13, A11:A9]  : WR and RTP
+     * bit[12, A6:A4,A2]: CAS Latency
+     * bit[1:0]         : Burst Length  00 = 8(Fixed)
+     */
+     
+     
+     
+     
+	dimm_info->spd_info[ch].mr0 = TWR_22 | CL_22 | 0x1;
+	
+//	dimm_info->spd_info[ch].mr0 = TWR_18 | CL_17 | 0x1;
+
+    //MR1
+    /*
+     * bit[10,9,8]  : RTT_NOM
+     * bit[4,3]     : AL
+     * bit[2,1]     : Output Driver Impedance
+     * bit[0]       : DLL enable
+     */
+    dimm_info->spd_info[ch].mr1 = set_rtt_nom | set_drv | 0x1; 
+//	mprintf("MR1 = 0x%x, MR1 =  %d\r\n", dimm_info->spd_info[ch].mr1, dimm_info->spd_info[ch].mr1 );
+
+    //MR2
+    /*
+     * bit[11,10,9] : RTT_WR  : Dynamic ODT off
+     * bit[5:3]     : CWL
+     *
+     */
+	dimm_info->spd_info[ch].mr2 = CWL_16;
+    //MR5
+    /*
+     * bit[10]    : DM , already cfg recfg_dm()
+     * bit[8:6]   : RTT_PARK
+     *
+     */
+     if(dimm_info->spd_info[ch].dm_cfg == DM_1)
+        dimm_info->spd_info[ch].mr5 = DM_ENA | set_park;
+     else
+        dimm_info->spd_info[ch].mr5 = set_park;
+
+
+    //MR6
+    /*
+     * bit[12,11,10]  : tCCD_L, 4 means tCCD_L=0x8
+     * bit[5:0]       : VrefDQ Training Value
+     *
+     */
+     dimm_info->spd_info[ch].mr6 = (0x4 << 10) | set_vref;//0x4
+
+     //MR0 not modified
+     mcu_ctl_clrsetbits(ch, 318, MASK_17BIT << 8, dimm_info->spd_info[ch].mr0 << 8);  
+     mcu_pi_clrsetbits(ch, 696, MASK_17BIT, dimm_info->spd_info[ch].mr0);
+
+     //MR1
+     mcu_ctl_write32(ch, 319, dimm_info->spd_info[ch].mr1 );  
+     mcu_pi_write32(ch, 697, dimm_info->spd_info[ch].mr1);
+
+     //MR2 not modified
+     mcu_ctl_write32(ch, 320, dimm_info->spd_info[ch].mr2 );  
+     mcu_pi_write32(ch, 698, dimm_info->spd_info[ch].mr2);
+
+     //MR3 not modified
+     //mcu_ctl_write32(ch, 358, dimm_info->spd_info[ch].mr3 );  
+     //mcu_pi_write32(ch, 699, dimm_info->spd_info[ch].mr3);
+
+     //MR4 not modified
+     //mcu_ctl_write32(ch, 370, dimm_info->spd_info[ch].mr4 );  
+     //mcu_pi_write32(ch, 700, dimm_info->spd_info[ch].mr4);
+
+     //MR5
+     mcu_ctl_write32(ch, 382, dimm_info->spd_info[ch].mr5 );  
+     mcu_pi_write32(ch, 701, dimm_info->spd_info[ch].mr5);
+
+     //MR6
+     mcu_ctl_write32(ch, 394, dimm_info->spd_info[ch].mr6 );  
+     mcu_pi_clrsetbits(ch, 702, MASK_18BIT, dimm_info->spd_info[ch].mr6);
+//     mcu_ctl_write32(ch, 394, 0x800 );
+//     mcu_pi_clrsetbits(ch, 702, MASK_18BIT, 0x818);
+}
+
+
+
+void mcu_init(uint8_t ch)
+{
+   
+    mcu_rst(ch);
+      
+    ctl_pi_phy_cfg(ch);
+    
+   
+    recfg_timing(ch);
+//	basic_dram_timing(ch);
+    signal_intergrity(ch);
+
+    //important, DISABLE_RD_INTERLEAVE
+    mcu_ctl_clrsetbits(ch, 558, MASK_1BIT, 0x1);
+
+    recfg_addressmap(ch);  
+
+    //NOTICE: dm recfg must before mr_recfg, due to ...
+    recfg_dm(ch);  
+
+    recfg_mr(ch);
+
+    recfg_ecc(ch);
+
+    recfg_data_width(ch);
+
+    recfg_performance(ch);
+  
+    lvl_process(ch);
+
+    recfg_dly(ch);
+
+
+#if 0
+
+    display_ctl_reg(ch);
+    display_pi_reg(ch);
+    display_phy_reg(ch);
+
+#endif
+    
+
+}
--- a/pnna/pnna-c6x/c6x_DDR_init/src/mcu_lvl.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/mcu_lvl.c
@ -0,0 +1,380 @@
+
+#include "mcu_config.h"
+
+
+static void lvl_cfg(uint8_t ch)
+{
+
+    uint32_t slice, val;
+    uint32_t lvl_rank = 1;
+
+    uint32_t wdqlvl_en = 1;
+    uint32_t wdqlvl_dm_lvl_en = 1;
+    
+    uint32_t pi_vref_start_point = 0x0;
+    uint32_t pi_vref_end_point = 0x32;
+
+    uint32_t phy_vref_start_point = 0x00; //default: 0x20 0x00
+    uint32_t phy_vref_end_point = 0x7f;   //default: 0x25  0x35
+	uint32_t phy_vref_setting_timing = 0x800;
+	
+    //PI_WDQLVL_VREF_EN default = 1;
+    uint32_t auto_timing_en = 0;
+    uint32_t rdlvl_multi_patt_en = 1;
+    uint32_t vref_pda_en = 1;
+    uint32_t wdqlvl_pda_en = 1;   //default: 0
+
+
+
+ //PHY_FAST_LVL_EN
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 83 + (slice<<8), MASK_3BIT<<24, 0x0<<24);         
+    }
+
+
+    //PHY_PER_CS_TRAINING_EN
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 97 + (slice<<8), MASK_1BIT<<16, 0x1<<16);         
+    }
+
+
+
+    /**************** write leveling **************************/
+
+    ////step size
+    //for(slice = 0; slice < 9; slice++ )
+    //{
+    //    //default: 0xC
+    //    mcu_phy_clrsetbits(ch, 102 + (slice<<8), MASK_8BIT, 0x4);
+    //}
+    ////wrlvl capture cnt
+//    for(slice = 0; slice < 9; slice++ )
+//    {
+//        //default: 0x8
+//        mcu_phy_clrsetbits(ch, 30 + (slice<<8), MASK_6BIT << 24, 0x4 << 24);
+//    }  
+  
+//PHY WDQLVL CLK JITTER TOLERANCE  20231108 
+    for(slice = 0; slice < 9; slice++ )
+    {
+        //default: 0x20
+        mcu_phy_clrsetbits(ch, 34 + (slice<<8), MASK_8BIT, 0x40); //0x40
+    }
+
+
+    //WRLVL_DELAY_EARLY_THRESHOLD
+#if 1
+    mcu_phy_clrsetbits(ch, 131 , MASK_10BIT<<16, 0x100<<16);
+    mcu_phy_clrsetbits(ch, 387 , MASK_10BIT<<16, 0x100<<16);
+    for(slice = 2; slice < 9; slice++ )
+    {
+        //default: 0x1a0
+        mcu_phy_clrsetbits(ch, 131 + (slice<<8), MASK_10BIT<<16, 0x200<<16); //  0x200     0x210 0x100
+    }
+
+#endif
+    //PHY WRLVL DELAY PERIOD THRESHOLD 0
+#if  1
+    for(slice = 0; slice < 9; slice++ )
+    {
+        //default:
+        mcu_phy_clrsetbits(ch, 132 + (slice<<8), MASK_10BIT<<0, 0x0<<0);
+    }
+#endif
+#if  0
+    for(slice = 6; slice < 8; slice++ )
+    {
+        //default:
+        mcu_phy_clrsetbits(ch, 132 + (slice<<8), MASK_10BIT<<0, 0x100<<0);
+    }
+#endif
+
+//  if(dimm_info->lmu_frequency >= 1200){
+//    mcu_phy_clrsetbits(ch, 1667 , MASK_10BIT<<16, 0x200<<16);
+//    mcu_phy_clrsetbits(ch, 1923 , MASK_10BIT<<16, 0x200<<16);
+//    mcu_phy_clrsetbits(ch, 132 , MASK_10BIT<<0, 0x0<<0);
+//    mcu_phy_clrsetbits(ch, 388 , MASK_10BIT<<0, 0x0<<0);
+//  }
+//    mcu_phy_clrsetbits(ch, 132 , MASK_10BIT<<0, 0x0<<0);
+//    mcu_phy_clrsetbits(ch, 388 , MASK_10BIT<<0, 0x0<<0);
+    //PHY_ntp_training_en
+#if 1
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 81 + (slice<<8), MASK_1BIT<<16, 0x0<<16); 
+    }
+#endif
+    //PI_WRLVL_CS
+    mcu_pi_clrsetbits(ch, 52, MASK_4BIT<<16, lvl_rank<<16);
+
+    //WRLVL_THRESHOLD_ADJUST 0
+#if 0
+//    for(slice = 0; slice < 9; slice++ )
+//    {
+        //default: 0x0
+        mcu_phy_clrsetbits(ch, 121 , MASK_2BIT<<0, 0x0<<0); //
+//    }
+#endif
+    ////WRITE_PATH_LAT_ADD
+//    for(slice = 0; slice < 9; slice++ )
+//    {
+//        mcu_phy_clrsetbits(ch, 132 + (slice<<8), MASK_3BIT<<8, 0x1 << 8);         
+//    }
+
+    ////WRLVL_DELAY_PERIOD_THRESHOLD
+    /*
+    for(slice = 0; slice < 9; slice++ )
+    {
+         mcu_phy_clrsetbits(ch, 132 + (slice<<8),  MASK_11BIT, 0x100);         
+    }
+    */
+    //WRLVL_DELAY_PERIOD_THRESHOLD
+//if(dimm_info->lmu_frequency >= 1200){
+//	mcu_phy_clrsetbits(ch, 132 ,  MASK_11BIT, 0x100);//0x100
+//    mcu_phy_clrsetbits(ch, 388 ,  MASK_11BIT, 0x100);//0x100
+//	}
+
+    
+    
+    for(slice = 0; slice < 9; slice++ )
+    {
+         //PHY_USER_PATT0_0
+         mcu_phy_write32(ch, 38 + (slice<<8),  0xaa55aa55);         
+         //PHY_USER_PATT1_0
+         mcu_phy_write32(ch, 39 + (slice<<8),  0x55aa55aa);         
+         //PHY_USER_PATT2_0
+         mcu_phy_write32(ch, 40 + (slice<<8),  0xaa55aa55);         
+         //PHY_USER_PATT3_0
+         mcu_phy_write32(ch, 41 + (slice<<8),  0x55aa55aa);         
+    }
+
+
+
+
+    /**************** gate leveling **************************/
+    //PHY_GTLVL_CAPTUE_CNT
+    //default : 0
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 31 + (slice<<8), MASK_6BIT<<16, 0x8<<16);
+    }
+
+    //PHY_GTLVL_STEP
+    //default : 0xc 
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 102 + (slice<<8), MASK_4BIT<<16, 0x8<<16);
+    }
+
+    //PHY_GTLVL_LAT_ADJ_START
+    //default : 0x1 
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 133 + (slice<<8), MASK_4BIT<<16, 0x2<<16);//0x2
+    }
+
+    //PHY_GTLVL_RDDQS_SLV_DLY_START
+    //default: 0x0
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 133 + (slice<<8), MASK_10BIT, 0x40);//0x20
+    }
+
+
+
+
+    /**************** read leveling **************************/
+    //PI_RDLVL_CS
+    mcu_pi_clrsetbits(ch, 65, MASK_4BIT<<16, lvl_rank<<16);
+    
+    
+    //phy_rdlvl_rddqs_dq_slv_dly_start
+    /*
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 140 + (slice<<8), MASK_10BIT, 0x20); 
+    }  
+    */  
+    //PHY_RDLVL_MULTI_PATT_ENABLE
+    //for(slice = 0; slice < 9; slice++ )
+    //{
+    //    mcu_phy_clrsetbits(ch, 13 + (slice<<8), MASK_1BIT<<16, rdlvl_multi_patt_en<<16 ); 
+    //}
+
+    ////PI_RDLVL_MULTI_EN
+    //mcu_pi_clrsetbits(ch, 270, MASK_1BIT, 0x1);
+
+    /**************** wdq leveling ****************************/
+//	PHY RDDATA EN DLY
+//	for(slice = 0; slice < 9; slice++ )
+//	   {
+//	        mcu_phy_clrsetbits(ch, 113 + (slice<<8), MASK_5BIT<<8, 0x3<<8); 
+//	    } 
+//	PHY MEAS DLY STEP ENABLE
+//	for(slice = 0; slice < 9; slice++ )
+//	   {
+//	        mcu_phy_clrsetbits(ch, 113 + (slice<<8), MASK_7BIT, 0x0); 
+//	    } 
+    //PHY_WDQLVL_DM_DLY_STEP
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 36 + (slice<<8), MASK_4BIT<<8, 0x1<<8); 
+    }
+
+    ////PHY_WDQLVL_DLY_STEP
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 104 + (slice<<8), MASK_8BIT<<16, 0x1<<16); 
+    }
+
+
+    //WDQLVL_CS
+    mcu_pi_clrsetbits(ch, 102, MASK_4BIT, lvl_rank);
+
+    mcu_pi_clrsetbits(ch, 301, MASK_2BIT<<8, wdqlvl_en<<8);
+    
+    mcu_pi_clrsetbits(ch, 108, MASK_1BIT<<16, wdqlvl_dm_lvl_en<<16);
+
+
+    /**************** vref leveling ****************************/
+    
+    //VREF_CS
+    mcu_pi_clrsetbits(ch, 97, MASK_4BIT<<8, lvl_rank<<8);
+    
+    //PHY_VREF_INITIAL_START_POINT_0
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 80 + (slice<<8), MASK_7BIT<<24, phy_vref_start_point<<24); 
+        
+    }    
+
+    //PHY_VREF_INITIAL_STOP_POINT_0
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 81 + (slice<<8), MASK_7BIT, phy_vref_end_point); 
+    }
+     //PHY_VREF_INITIAL_STEPSIZE_0
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 14 + (slice<<8), MASK_6BIT, 0x1); 
+    }
+
+  //PHY_pad_vref_ctl_dq
+//    for(slice = 0; slice < 9; slice++ )
+//    {
+//        mcu_phy_clrsetbits(ch, 96 + (slice<<8), MASK_12BIT<<16, 0x4be<<16); 
+//    }   
+//   PHY VREF SETTING TIME 
+//      for(slice = 0; slice < 9; slice++ )
+//	    {
+//	        mcu_phy_clrsetbits(ch, 96 + (slice<<8), MASK_16BIT, phy_vref_setting_timing); //180
+//	    } 
+    
+/*
+    //PI_WDQLVL_VREF_INITIAL_STOP_POINT   default: 0x1e
+    mcu_pi_clrsetbits(ch, 300, MASK_7BIT<<24, phy_vref_end_point << 24);
+    */
+    //PI_WDQLVL_VREF_INITIAL_STOP_POINT   default: 0x1e
+    mcu_pi_clrsetbits(ch, 300, MASK_7BIT<<24, pi_vref_end_point << 24);
+    mcu_pi_clrsetbits(ch, 300, MASK_7BIT<<16, pi_vref_start_point << 16);
+//    mcu_pi_clrsetbits(ch, 97, MASK_4BIT<<8, 0x1<<8);//105
+//PI WDQLVL VREF EN    
+//	mcu_pi_clrsetbits(ch, 98, MASK_1BIT<<24, 0x1<<24);
+//PI WDQLVL VREF INITIAL STEPSIZE 0x4
+//	mcu_pi_clrsetbits(ch, 100, MASK_5BIT<<24, 0x4 <<24);
+//PI WDQLVL VREF NORMAL STEPSIZE	0x2
+	mcu_pi_clrsetbits(ch, 101, MASK_5BIT , 0x1 );
+//PI_WDQLVL_VREF_INITIAL_start_POINT   default: 0x1a
+//    mcu_pi_clrsetbits(ch, 300, MASK_7BIT<<16, 0x16 << 16);
+//PI_WDQLVL_VREF_INITIAL_STOP_POINT   default: 0x1e
+//    mcu_pi_clrsetbits(ch, 300, MASK_7BIT<<24, 0x1e << 24);
+//PI WDQLVL VREF DELTA F0
+//	mcu_pi_clrsetbits(ch, 301, MASK_4BIT, 0x1);
+    //PI_VREF_PDA_EN
+    mcu_pi_clrsetbits(ch, 97, MASK_1BIT << 16, vref_pda_en << 16); 
+
+    //PI_WDQLVL_PAD_EN
+    mcu_pi_clrsetbits(ch, 110, MASK_1BIT << 8, wdqlvl_pda_en << 8); 
+#if 0
+/****************PHY CLK DC ADJUST********************/
+ 	mcu_phy_clrsetbits(ch, 3120 , MASK_16BIT<<16, 0x1007 <<16);
+  	mcu_phy_clrsetbits(ch, 3121 , MASK_16BIT, 0x1531);
+//PHY ADR DC ADR CLK ADJUST
+	mcu_phy_clrsetbits(ch, 2847 , MASK_32BIT, 0x17132a00);
+	mcu_phy_clrsetbits(ch, 2848 , MASK_32BIT, 0xe0d09);
+//PHY ADR DC ADR0 CLK ADJUST0
+	mcu_phy_clrsetbits(ch, 2335 , MASK_32BIT, 0x3c353700);
+	mcu_phy_clrsetbits(ch, 2336 , MASK_32BIT, 0x352f39);
+//PHY DATA DC DQ0 CLK ADJUST
+	mcu_phy_clrsetbits(ch, 1933 , MASK_32BIT, 0xbf38bf38);
+	mcu_phy_clrsetbits(ch, 1934 , MASK_32BIT, 0x3739bfbf);	
+#endif	
+
+   /**************** phy_auto_timing_margin_control  ****************************/
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 10 + (slice<<8), MASK_1BIT, auto_timing_en ); 
+    }
+
+
+
+}
+
+void lvl_process(uint8_t ch)
+{
+	int slice;
+//PHY_SLICE_PWR_RDC_DISABLE EN 
+//Data slice power reduction disable for slice
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 78 + (slice<<8), MASK_1BIT<<24, 0x1<<24);         
+    }
+    
+    	lvl_cfg(ch);
+//    mcu_phy_clrsetbits(ch, 3202 ,  MASK_32BIT, 0x1142);
+//    mcu_phy_clrsetbits(ch, 3203 ,  MASK_32BIT, 0x1020400);
+//    mcu_phy_clrsetbits(ch, 3204 ,  MASK_32BIT, 0x1);
+//    mcu_phy_clrsetbits(ch, 3210 ,  MASK_32BIT, 0x30000);
+//    mprintf("DENALI_PHY_3202_DATA:  value=%x\r\n",  mcu_phy_read32(ch, 3202));
+//    mprintf("DENALI_PHY_3203_DATA:  value=%x\r\n",  mcu_phy_read32(ch, 3203));
+//    mprintf("DENALI_PHY_3204_DATA:  value=%x\r\n",  mcu_phy_read32(ch, 3204));
+//    mprintf("DENALI_PHY_3210_DATA:  value=%x\r\n",  mcu_phy_read32(ch, 3210));
+//    mprintf("DENALI_PHY_3212_DATA:  value=%x\r\n",  mcu_phy_read32(ch, 3212));
+
+    //PHY_INDEP_TRAIN_MODE
+    mcu_ctl_clrsetbits(ch, 20, MASK_1BIT<<24, 0x1<<24);
+
+    //PHY_INDEP_INIT_MODE
+    mcu_ctl_clrsetbits(ch, 21, MASK_1BIT<<8, 0x1<<8);
+
+    //PI_DRAM_INIT_EN
+    mcu_pi_clrsetbits(ch, 203, MASK_1BIT<<8, 0x1<<8);
+
+    //PI_INIT_LVL_EN
+    mcu_pi_clrsetbits(ch, 4, MASK_1BIT, 0x1);
+//   asm("smfence");
+    //PI_START
+    mcu_pi_clrsetbits(ch, 0, MASK_1BIT, 0x1);
+    //CTL_START
+    mcu_ctl_clrsetbits(ch, 0, MASK_1BIT, 0x1);
+//    asm("smfence");
+    //PI_DLL_LOCK
+    while( !(mcu_pi_read32(ch, 220) & 0x1) );
+//	mprintf("while( !(mcu_pi_read32(ch, 220) & 0x1) )\r\n");
+    //MC init has been completed
+    while( !((mcu_ctl_read32(ch, 598) >> 25) & 0x1) );
+//    mprintf("while( !((mcu_ctl_read32(ch, 598) >> 25) & 0x1) )\r\n");
+    printf("DDR Init Done. \n");
+
+    //clear ACK
+    mcu_ctl_write32(ch, 606, ~0x0);
+
+
+#if 1
+    display_lvl_rlst(ch);
+#endif
+
+
+}
--- a/pnna/pnna-c6x/c6x_DDR_init/src/mcu_phy_cfg.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/mcu_phy_cfg.c
--- a/pnna/pnna-c6x/c6x_DDR_init/src/mcu_signal.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/mcu_signal.c
@ -0,0 +1,654 @@
+
+#include "mcu_config.h"
+
+//PHY_PAD_FDBK_DRIVE
+/*  bit[3:0]:   ENSLICEN_DRV
+ *  bit[7:4]:   ENSLICEP_DRV
+ *  bit[10:8]:  SLEWN
+ *  bit[13:11]: SLEWP
+ *  bit[14]:    TX_LOWSPEED_BYPASS
+ *  bit[17:15]: MODE
+ *  bit[18]:    RPULL 
+ *  bit[19]:    RX_DQ_EN
+ *  bit[21:20]: TX_PULLDWN
+ *  bit[23:22]: SPEED
+ *  bit[26:24]: RX_CTLE
+ *  bit[27]:    TX_NCAS_DIS
+ *  bit[28]:    TX_PCAS_DIS
+ */
+//PHY_PAD_FDBK_DRIVE2
+/*  bit[3:0]:   ENSLICEN_ODT
+ *  bit[7:4]:   ENSLICEP_ODT
+ *  bit[11:8]:  BOOSTN_EN 
+ *  bit[15:12]: BOOSTP_EN 
+ *  bit[17:16]: TX_FFE 
+ */
+//PHY_PAD_CLK_DRIVE
+/*  bit[3:0]:   ENSLICEN_DRV
+ *  bit[7:4]:   ENSLICEP_DRV
+ *  bit[10:8]:  SLEWN
+ *  bit[13:11]: SLEWP
+ *  bit[16:14]: MODE
+ *  bit[18:17]: SPEED
+ *  bit[19]:    RX_DQ_EN
+ *  bit[21:20]: TX_PULLDWN
+ *  bit[25:22]: BOOSTN_EN 
+ *  bit[29:26]: BOOSTP_EN 
+ *  bit[30]:    RPULL 
+ */
+//PHY_PAD_CLK_DRIVE2
+/*  bit[4:0]:   TX_DCD 
+ *  bit[9:5]:   RX_DCD 
+ *  bit[10]:    TX_PCAS_DIS 
+ *  bit[11]:    TX_NCAS_DIS 
+ *  bit[14:12]: RX_CTLE 
+ *  bit[15]:    TX_LOWSPEED_BYPASS 
+ *  bit[17:16]: TX_FFE
+ */
+
+//PHY_PAD_FDBK_TERM
+/*  bit[5:0]:   PVTP 
+ *  bit[11:6]:  PVTN 
+ *  bit[16:12]: PVTR 
+ *  bit[17]:    TSEL 
+ */
+//PHY_PAD_DATA_TERM --DQ/DM/DQS/CLK/ADDR/CS/ODT/CKE
+/*  bit[5:0]:   PVTP 
+ *  bit[11:6]:  PVTN 
+ *  bit[16:12]: PVTR 
+ */
+//PHY_PAD_DATA_DRIVE --Data Pads
+/*  bit[2:0]:   SLEWN 
+ *  bit[5:3]:   SLEWP 
+ *  bit[8:6]:   MODE 
+ *  bit[10:9]:  SPEED 
+ *  bit[11]:    TX_LOWSPEED_BYPASS 
+ *  bit[21:20]: TX_PULLDWN 
+ *  bit[25]:    TX_NCAS_DIS
+ *  bit[26]:    TX_PCAS_DIS
+ *  bit[28:27]: TX_FFE 
+ */
+//PHY_PAD_DATA_DRIVE --DM
+/*  bit[2:0]:   SLEWN 
+ *  bit[5:3]:   SLEWP 
+ *  bit[11]:    TX_LOWSPEED_BYPASS 
+ *  bit[8:6]:   MODE 
+ *  bit[21:20]: TX_PULLDWN 
+ *  bit[22]:    RPULL
+ *  bit[25]:    TX_NCAS_DIS
+ *  bit[26]:    TX_PCAS_DIS
+ *  bit[28:27]: TX_FFE 
+ *  bit[29]:    RX_DQ_EN
+ */
+//PHY_PAD_DQS_DRIVE --DQS 
+/*  bit[2:0]:   SLEWN 
+ *  bit[5:3]:   SLEWP 
+ *  bit[8:6]:   MODE 
+ *  bit[10:9]:  SPEED 
+ *  bit[11]:    RX_DQ_EN
+ *  bit[13:12]: TX_PULLDWN 
+ *  bit[22]:    RPULL
+ *  bit[23]:    TX_LOWSPEED_BYPASS 
+ *  bit[27]:    TX_PCAS_DIS
+ *  bit[28]:    TX_NCAS_DIS
+ *  bit[30:29]: TX_FFE 
+ */
+//PHY_PAD_ADDR_DRIVE --ADDR
+/*  bit[4:0]:   TX_DCD 
+ *  bit[6:5]:   TX_PULLDWN 
+ *  bit[7]:     TX_LOWSPEED_BYPASS 
+ *  bit[10:8]:  SLEWN 
+ *  bit[13:11]: SLEWP 
+ *  bit[16:14]: MODE
+ *  bit[18:17]: SPEED 
+ *  bit[22:19]: BOOSTN_EN 
+ *  bit[26:23]: BOOSTP_EN 
+ *  bit[27]:    TX_PCAS_DIS
+ *  bit[28]:    TX_NCAS_DIS
+ */
+//PHY_PAD_ADDR_DRIVE2 --ADDR   ???
+/*  
+ *  bit[4:0]:   RX_DCD 
+ *  bit[7:5]:   RX_CTLE 
+ *  bit[16:8]:  RX_OFFSET_L 
+ *  bit[20:17]: ENSLICEN_DRV/ENSLICEN_ODT 
+ *  bit[24:21]: ENSLICEP_DRV/ENSLICEP_ODT  ?? 
+ *  bit[26:25]: TX_FFE
+ */
+//PHY_PAD_CS_DRIVE --CS
+/*  bit[4:0]:   TX_DCD 
+ *  bit[6:5]:   TX_PULLDWN 
+ *  bit[10:8]:  SLEWN 
+ *  bit[13:11]: SLEWP 
+ *  bit[16:14]: MODE 
+ *  bit[18:17]: SPEED 
+ *  bit[22:19]: BOOSTN_EN 
+ *  bit[26:23]: BOOSTP_EN 
+ *  bit[27]:    TX_PCAS_DIS 
+ *  bit[28]:    TX_NCAS_DIS 
+ */
+//PHY_PAD_CS_DRIVE2 --CS
+/*  bit[4:0]:   RX_DCD 
+ *  bit[6:5]:   RX_CTLE 
+ *  bit[7]:     TX_LOWSPEED_BYPASS 
+ *  bit[16:8]:  RX_OFFSET_L 
+ *  bit[20:17]: ENSLICEN_DRV/ENSLICEN_ODT 
+ *  bit[24:21]: ENSLICEP_DRV/ENSLICEP_ODT 
+ *  bit[26:25]: TX_FFE 
+ */
+//PHY_PAD_ODT_DRIVE --ODT
+/*  bit[4:0]:   TX_DCD 
+ *  bit[6:5]:   TX_PULLDWN 
+ *  bit[7]:     TX_LOWSPEED_BYPASS
+ *  bit[10:8]:  SLEWN 
+ *  bit[13:11]: SLEWP 
+ *  bit[16:14]: MODE 
+ *  bit[18:17]: SPEED 
+ *  bit[22:19]: BOOSTN_EN 
+ *  bit[26:23]: BOOSTP_EN 
+ *  bit[27]:    TX_PCAS_DIS 
+ *  bit[28]:    TX_NCAS_DIS 
+ */
+//PHY_PAD_ODT_DRIVE2 --ODT
+/*  bit[4:0]:   RX_DCD 
+ *  bit[7:5]:   RX_CTLE 
+ *  bit[16:8]:  RX_OFFSET_L 
+ *  bit[20:17]: ENSLICEN_DRV/ENSLICEN_ODT 
+ *  bit[24:21]: ENSLICEP_DRV/ENSLICEP_ODT 
+ *  bit[26:25]: BOOSTP_EN 
+ */
+//PHY_PAD_CKE_DRIVE --CKE
+/*  bit[4:0]:   TX_DCD 
+ *  bit[6:5]:   TX_PULLDWN 
+ *  bit[7]:     TX_LOWSPEED_BYPASS
+ *  bit[10:8]:  SLEWN 
+ *  bit[13:11]: SLEWP 
+ *  bit[16:14]: MODE 
+ *  bit[18:17]: SPEED 
+ *  bit[22:19]: BOOSTN_EN 
+ *  bit[26:23]: BOOSTP_EN 
+ *  bit[27]:    TX_PCAS_DIS 
+ *  bit[28]:    TX_NCAS_DIS 
+ */
+//PHY_PAD_CKE_DRIVE2 --CKE
+/*  bit[4:0]:   RX_DCD 
+ *  bit[7:5]:   RX_CTLE    // <<DDR PHY User's Manual>> bit[7]: TX_LOWSPEED_BYPASS
+ *  bit[16:8]:  RX_OFFSET_L 
+ *  bit[20:17]: ENSLICEN_DRV/ENSLICEN_ODT 
+ *  bit[24:21]: ENSLICEP_DRV/ENSLICEP_ODT 
+ *  bit[26:25]: TX_FFE 
+ */
+//PHY_PAD_RST_DRIVE --RST
+/*  bit[4:0]:   TX_DCD 
+ *  bit[6:5]:   TX_PULLDWN 
+ *  bit[7]:     TX_LOWSPEED_BYPASS
+ *  bit[10:8]:  SLEWN 
+ *  bit[13:11]: SLEWP 
+ *  bit[16:14]: MODE 
+ *  bit[18:17]: SPEED 
+ *  bit[22:19]: BOOSTN_EN 
+ *  bit[26:23]: BOOSTP_EN 
+ *  bit[27]:    TX_PCAS_DIS 
+ *  bit[28]:    TX_NCAS_DIS 
+ */
+//PHY_PAD_RST_DRIVE2 --RST
+/*  bit[4:0]:   RX_DCD 
+ *  bit[7:5]:   RX_CTLE 
+ *  bit[16:8]:  RX_OFFSET_L 
+ *  bit[20:17]: ENSLICEN_DRV/ENSLICEN_ODT 
+ *  bit[24:21]: ENSLICEP_DRV/ENSLICEP_ODT 
+ *  bit[26:25]: BOOSTP_EN 
+ */
+//PHY_PAD_ERR_DRIVE --ERR
+/*  bit[4:0]:   TX_DCD 
+ *  bit[6:5]:   TX_PULLDWN 
+ *  bit[7]:     TX_LOWSPEED_BYPASS
+ *  bit[10:8]:  SLEWN 
+ *  bit[13:11]: SLEWP 
+ *  bit[16:14]: MODE 
+ *  bit[18:17]: SPEED 
+ *  bit[22:19]: BOOSTN_EN 
+ *  bit[26:23]: BOOSTP_EN 
+ *  bit[27]:    TX_PCAS_DIS 
+ *  bit[28]:    TX_NCAS_DIS 
+ */
+//PHY_PAD_ERR_DRIVE2 --ERR
+/*  bit[4:0]:   RX_DCD 
+ *  bit[7:5]:   RX_CTLE 
+ *  bit[16:8]:  RX_OFFSET_L 
+ *  bit[20:17]: ENSLICEN_DRV/ENSLICEN_ODT 
+ *  bit[24:21]: ENSLICEP_DRV/ENSLICEP_ODT 
+ *  bit[26:25]: BOOSTP_EN 
+ */
+//PHY_PAD_VREF_CTRL_DQ_X --VREF
+/*  bit[6:0]:   VREFSEL 
+ *  bit[7]:     EN 
+ *  bit[11:8]:  MODE 
+ */
+
+/*  odt/drv same val */
+#define  ENSLICE_HIZ       0
+#define  ENSLICE_240_OHM   3 
+#define  ENSLICE_120_OHM   4 
+#define  ENSLICE_80_OHM    7 
+#define  ENSLICE_60_OHM    8 
+#define  ENSLICE_48_OHM    11 
+#define  ENSLICE_40_OHM    12 
+#define  ENSLICE_34_OHM    15  //34.3 
+
+
+#define  SPEED_800Mbps     0
+#define  SPEED_1600Mbps    1
+#define  SPEED_2400Mbps    2
+#define  SPEED_3200Mbps    3
+
+
+static void recfg_io_pad(uint8_t ch)
+{
+
+    uint32_t slice, cnt;
+
+    const uint32_t DDR4_IO_MODE = 4;
+
+    //PULL DOWN RESISTOR
+    uint32_t enslicen_drv = ENSLICE_40_OHM;//ENSLICE_34_OHM
+
+    //PULL UP RESISTOR
+    uint32_t enslicep_drv = ENSLICE_40_OHM;//ENSLICE_34_OHM
+
+    //[2:0], 7-max slew rate, 0-min slew rate;
+    uint32_t slewn = 7;
+    uint32_t slewp = 7;
+    uint32_t tx_lowspeed_bypass = 0;   //NOTICE: refer to waveform
+    uint32_t mode = DDR4_IO_MODE;
+
+    //used for LPDDR3
+    uint32_t rpull = 0;
+    uint32_t rx_dq_en = 0;  
+	uint32_t rx_dq_dm_en = 1;
+    //used for LPDDR4
+    uint32_t tx_pulldwn = 0;
+    uint32_t speed = SPEED_3200Mbps;//SPEED_3200Mbps
+
+    // 7: max boost,  4: medial boost,  1: min boost,  0: no boost
+    //uint32_t rx_ctle = 1;  
+    uint32_t rx_ctle = 0;  
+
+    uint32_t tx_ncas_dis = 0;  //???
+    uint32_t tx_pcas_dis = 0;
+
+    uint32_t enslicen_odt = ENSLICE_HIZ;//ENSLICE_HIZ
+    uint32_t enslicep_odt = ENSLICE_40_OHM;//ENSLICE_48_OHM
+
+    //used to increase the slew rate on the pull up above SLEWN setting
+    uint32_t boostn_en = 0;
+    //used to increase the slew rate on the pull up above SLEWP setting
+    uint32_t boostp_en = 0;
+
+    //[1:0]
+    //2'b11 - max de-emphasis 120ohm
+    //2'b10 - min de-emphasis 240ohm
+    //2'b01 - min de-emphasis 240ohm
+    //2'b00 - no de-emphasis 
+    uint32_t tx_ffe = 0;
+
+    //adjust transmit duty cycle to...
+    //bit[4:0]
+    //0-min duty cycle,  31-max duty cycle
+    uint32_t tx_dcd = 0;
+    uint32_t rx_dcd = 0;
+	
+	uint8_t RX_IE_CAL_ALL = 0x0;
+    //used to correct for offset in the receiver
+    //uint32_t rx_offset_l = 0;
+    uint32_t rx_offset_l = 0x20;
+
+    //[6:0]
+    // 0   ----- 50% VDDQ
+    // 127 ----- 88% VDDQ
+    uint32_t vrefsel = 0x3f;   //???  0x2c
+    uint32_t en = 1;
+
+//	uint32_t  dq_oe_start = 0x2 ;  //0x2
+//	uint32_t  dq_oe_end   = 0x4 ;  //0x4
+	
+
+#if 0
+#ifdef Uart_printf
+    for(cnt = 3225; cnt < 3244; cnt++)
+    {
+	     mprintf("\r\n phy_reg %d: , value=%x \r\n",  cnt, mcu_phy_read32(ch, cnt));
+    }
+#endif
+#endif
+/***********************************************************************************/
+/******************** ft ***********************************************************/
+#if 1
+ 	uint32_t pad_fdbk_drv = enslicen_drv 
+                        | (enslicep_drv<<4) 
+                        | (slewn<<8) 
+                        | (slewp<<11) 
+                        | (tx_lowspeed_bypass<<14) 
+                        | (mode << 15)
+                        | (rpull << 19)
+                        | (rx_dq_en << 20)
+                        | (tx_pulldwn << 21)
+                        | (speed << 23)
+                        | (rx_ctle << 25)
+                        | (tx_ncas_dis << 28)
+                        | (tx_pcas_dis << 29);
+    uint32_t pad_fdbk_drv2 = enslicen_odt
+                        | (enslicep_odt << 4)
+                        | (boostn_en << 8)
+                        | (boostp_en << 12)
+                        | (tx_ffe << 16);
+//    uint32_t pad_x4_fdbk_diver = pad_fdbk_drv;
+//    uint32_t pad_x4_fdbk_diver2 = pad_fdbk_drv2;                                    
+    uint32_t pad_clk_drv =  enslicen_drv
+                        | (enslicep_drv << 4)
+                        | (slewn << 8)
+                        | (slewp << 11)
+                        | (mode << 14)
+                        | (speed << 18)
+                        | (rx_dq_en << 20)
+                        | (tx_pulldwn << 21)
+                        | (boostn_en << 23)
+                        | (boostp_en << 27)
+                        | (rpull << 31);
+     uint32_t pad_clk_drv2 = tx_dcd
+                        | (rx_dcd << 5)
+                        | (tx_pcas_dis << 10)
+                        | (tx_ncas_dis << 11)
+                        | (rx_ctle << 12)
+                        | (tx_lowspeed_bypass << 15)
+                        | (tx_ffe << 16)
+                        | (RX_IE_CAL_ALL << 18);
+                        
+      uint32_t pad_data_drv = slewn
+	                      | (slewp << 3)
+	                      | (mode << 6)
+	                      | (speed << 10)
+	                      | (tx_lowspeed_bypass << 12)
+	                      | (tx_pulldwn << 21)
+	                      | (rpull << 23)//?????
+	                      | (rx_ctle << 25)//?????
+	                      | (tx_ncas_dis << 26)
+	                      | (tx_pcas_dis << 27)
+	                      | (tx_ffe << 28)
+	                      | (rx_dq_dm_en << 30);
+                           
+     uint32_t pad_dqs_drv = slewn
+                          | (slewp << 3)
+                          | (mode << 6)
+                          | (speed << 10)
+                          | (rx_dq_en << 12)
+                          | (tx_pulldwn << 13)
+                          | (rpull << 23)
+                          | (tx_lowspeed_bypass << 24)
+                          | (tx_pcas_dis << 28)
+                          | (tx_ncas_dis << 29)
+                          | (tx_ffe << 30);
+                        
+    uint32_t pad_addr_drv = tx_dcd
+                          | (tx_pulldwn << 5)
+                          | (tx_lowspeed_bypass << 7)
+                          | (slewn << 8)
+                          | (slewp << 11)
+                          | (mode << 14)
+                          | (speed << 18)
+                          | (boostn_en << 20)
+                          | (boostp_en << 24)
+                          | (tx_pcas_dis << 28)
+                          | (tx_ncas_dis << 29);
+     uint32_t pad_addr_drv2 = rx_dcd
+                          | (rx_ctle << 5)
+                          | (rx_offset_l << 8)
+                          | (enslicen_drv << 17)
+                          | (enslicep_drv << 21)
+                          | (tx_ffe << 25)
+                          | (RX_IE_CAL_ALL << 27);                         
+   	uint32_t pad_err_drv  = pad_addr_drv;
+	uint32_t pad_err_drv2 = pad_addr_drv2;
+	uint32_t pad_cke_drv  = pad_addr_drv;
+	uint32_t pad_cke_drv2 = pad_addr_drv2;
+	uint32_t pad_rst_drv  = pad_addr_drv;
+	uint32_t pad_rst_drv2 = pad_addr_drv2; 
+	uint32_t pad_cs_drv   = pad_addr_drv;
+	uint32_t pad_cs_drv2  = pad_addr_drv2;
+	uint32_t pad_odt_drv  = pad_addr_drv;
+	uint32_t pad_odt_drv2 = pad_addr_drv2;   
+	    
+    uint32_t pad_vref_ctl_dq_x = vrefsel
+                      	| (en << 7)
+                      	| (mode << 8);                     
+#endif                          
+                          
+/***********************************************************************************/
+
+#if 0
+    mcu_phy_write32(ch, 3225, 0x1823fff);    //PHY_PAD_FDBK_DRIVE
+    mcu_phy_write32(ch, 3226, 0xb0);         //PHY_PAD_FDBK_DRIVE2
+    mcu_phy_write32(ch, 3227, 0x1823fff);    
+    mcu_phy_write32(ch, 3228, 0xb0);
+    mcu_phy_write32(ch, 3229, 0x40000d3f);   //PHY_PAD_DATA_DRIVE
+    mcu_phy_write32(ch, 3230, 0xd3f);        //PHY_PAD_DQS_DRIVE
+    mcu_phy_write32(ch, 3231, 0xd3f00);      //PHY_PAD_ADDR_DRIVE
+    mcu_phy_write32(ch, 3232, 0x1fe2000);    //PHY_PAD_ADDR_DRIVE2
+    mcu_phy_write32(ch, 3233, 0xd3fff);      //PHY_PAD_CLK_DRIVE
+    mcu_phy_write32(ch, 3234, 0x0);          //PHY_PAD_CLK_DRIVE2
+    mcu_phy_write32(ch, 3235, 0xd3f00);      //PHY_PAD_ERR_DRIVE
+    mcu_phy_write32(ch, 3236, 0x1fe2000);    //PHY_PAD_ERR_DRIVE2
+    mcu_phy_write32(ch, 3237, 0xd3f00);      //PHY_PAD_CKE_DRIVE
+    mcu_phy_write32(ch, 3238, 0x1fe2000);    //PHY_PAD_CKE_DRIVE2
+    mcu_phy_write32(ch, 3239, 0xd3f00);      //PHY_PAD_RST_DRIVE
+    mcu_phy_write32(ch, 3240, 0x1fe2000);    //PHY_PAD_RST_DRIVE2
+    mcu_phy_write32(ch, 3241, 0xd3f00);      //PHY_PAD_CS_DRIVE
+    mcu_phy_write32(ch, 3242, 0x1fe2000);    //PHY_PAD_CS_DRIVE2
+    mcu_phy_write32(ch, 3243, 0xd3f00);      //PHY_PAD_ODT_DRIVE
+    mcu_phy_write32(ch, 3244, 0x1fe2000);    //PHY_PAD_ODT_DRIVE2
+    mcu_phy_write32(ch, 3245, 0x20040005);   //PHY_CAL_CLK_SELECT_0
+#else
+
+/***********************************************************************************/
+    //PAD_FDBK_DRIVE 
+    mcu_phy_clrsetbits(ch ,3225, ~0x0, pad_fdbk_drv);
+    //PHY_PAD_FDBK_DRIVE2 
+    mcu_phy_clrsetbits(ch ,3226, ~0x0, pad_fdbk_drv2);
+    //PHY_PAD_DATA_DRIVE
+    mcu_phy_clrsetbits(ch, 3229, ~0x0, pad_data_drv);
+    //PHY_PAD_DQS_DRIVE
+    mcu_phy_clrsetbits(ch, 3230, ~0x0, pad_dqs_drv); 
+    //PHY_PAD_ADDR_DRIVE
+    mcu_phy_clrsetbits(ch, 3231, ~0x0, pad_addr_drv);
+
+    //default: 1ffff00
+    //after cfg: 2020
+    //NOTICE
+    //PHY_PAD_ADDR_DRIVE2
+    mcu_phy_clrsetbits(ch, 3232, ~0x0, pad_addr_drv2);   //NO WAVEFORM   
+    //PHY_PAD_CLK_DRIVE
+    mcu_phy_clrsetbits(ch, 3233, ~0x0, pad_clk_drv);
+    //PHY_PAD_CLK_DRIVE2
+    mcu_phy_clrsetbits(ch, 3234, ~0x0, pad_clk_drv2);
+    //PHY_PAD_ERR_DRIVE
+    mcu_phy_clrsetbits(ch, 3235, ~0x0, pad_err_drv);
+    //PHY_PAD_ERR_DRIVE2
+    mcu_phy_clrsetbits(ch, 3236, ~0x0, pad_err_drv2);
+    //PHY_PAD_CKE_DRIVE
+    mcu_phy_clrsetbits(ch, 3237, ~0x0, pad_cke_drv);
+    //PHY_PAD_CKE_DRIVE2
+    mcu_phy_clrsetbits(ch, 3238, ~0x0, pad_cke_drv2);
+    //PHY_PAD_RST_DRIVE
+    mcu_phy_clrsetbits(ch, 3239, ~0x0, pad_rst_drv);
+    //PHY_PAD_RST_DRIVE2
+    mcu_phy_clrsetbits(ch, 3240, ~0x0, pad_rst_drv2);
+    //PHY_PAD_CS_DRIVE
+    mcu_phy_clrsetbits(ch, 3241, ~0x0, pad_cs_drv);
+    //PHY_PAD_CS_DRIVE2
+    mcu_phy_clrsetbits(ch, 3242, ~0x0, pad_cs_drv2);
+    //PHY_PAD_ODT_DRIVE
+    mcu_phy_clrsetbits(ch, 3243, ~0x0, pad_odt_drv);
+    //PHY_PAD_ODT_DRIVE2
+    mcu_phy_clrsetbits(ch, 3244, ~0x0, pad_odt_drv2);
+
+
+    //PHY_PAD_VREF_CTRL_DQ_x
+    for(slice = 0; slice < 9; slice++ )
+    {
+        mcu_phy_clrsetbits(ch, 96 + (slice<<8), MASK_12BIT<<16, pad_vref_ctl_dq_x << 16); 
+    }
+#endif 
+
+
+    //PHY_PAD_ADR_IO_CFG_0
+    mcu_phy_clrsetbits(ch, 2340, MASK_11BIT << 16, 0x3 << 16);   //??? 0x5  qf 0x3
+    //PHY_PAD_ADR_IO_CFG_1
+    mcu_phy_clrsetbits(ch, 2596, MASK_11BIT << 16, 0x3 << 16);   //??? 0x5
+    //PHY_PAD_ADR_IO_CFG_2
+    mcu_phy_clrsetbits(ch, 2852, MASK_11BIT << 16, 0x3 << 16);   //??? 0x5
+
+    //PHY_PAD_DSLICE_IO_CFG_X
+    for(slice = 0; slice < 9; slice ++)
+    {
+        mcu_phy_clrsetbits(ch, 87 + (slice << 8), MASK_7BIT<<16, 0x5<<16); //??? 0x5 
+    }
+
+    //PHY_PAD_FDBK_RX_DCD_0
+//    for(slice = 0; slice < 9; slice ++)
+//    {
+//        mcu_phy_clrsetbits(ch, 87 + (slice << 8), MASK_10BIT, 0x5);  //????
+//    }
+
+
+#if 0
+   
+//RX_OFFSET_L
+//phy_adrctl_rx_cal[9:1]
+//	mcu_phy_clrsetbits(ch, 3148, MASK_9BIT<< 1 , rx_offset_l << 1);
+//phy_tst_clk_pad_ctrl4
+//	mcu_phy_clrsetbits(ch, 3151, MASK_9BIT , rx_offset_l );
+#endif
+#if 0
+    for(cnt = 3225; cnt < 3244; cnt++)
+    {
+	     mprintf("DSP After CFG phy_reg %d: , value=%x\r\n",  cnt, mcu_phy_read32(ch, cnt));
+    }
+#endif
+
+/****************phy_dq_oe_timing_X*******************/
+//    for(slice = 0; slice < 9; slice++)
+//    {
+//        mcu_phy_clrsetbits(ch, 94 + (slice<<8), MASK_4BIT,  dq_oe_start);
+//        mcu_phy_clrsetbits(ch, 94 + (slice<<8), MASK_4BIT << 4,  dq_oe_end << 4);
+//    
+//    }
+
+#if 0
+ //TERM   
+  	mcu_phy_write32(ch, 3137, 0x1378a);    
+    mcu_phy_write32(ch, 3138, 0x1378a);       
+    mcu_phy_write32(ch, 3139, 0x1378a);    
+    mcu_phy_write32(ch, 3140, 0x1378a);
+    mcu_phy_write32(ch, 3141, 0x13818);
+    mcu_phy_write32(ch, 3142, 0x13818);  
+    mcu_phy_write32(ch, 3143, 0x1378a); 
+    mcu_phy_write32(ch, 3144, 0x1378a);
+    mcu_phy_write32(ch, 3145, 0x13818);
+    mcu_phy_write32(ch, 3146, 0x1378a);
+    mcu_phy_write32(ch, 3147, 0x13818);     
+#endif             
+    
+}
+
+
+
+void signal_intergrity(uint8_t ch)
+{
+
+    uint32_t slice;
+
+    recfg_io_pad(ch);
+
+    //PI_POWER_REDUC_EN = 0
+    mcu_pi_clrsetbits(ch, 221, MASK_1BIT << 16, 0x0<< 16);
+
+    //PHY_PAD_CAL_IO_CFG  
+    /*
+     *  'b000 = clk_ctlr/2
+     *  'b001 = clk_ctlr/2
+     *  'b010 = clk_ctlr/4
+     *  'b011 = clk_ctlr/8
+     *  'b100 = clk_ctlr/16
+     *  'b101 = clk_ctlr/32
+     *
+     */
+    mcu_phy_write32(ch, 3198, 0x5);//0x3);  0x4
+
+    //PHY_CAL_CLK_SELECT_0   PHY_3245  default:3 
+// 	mcu_phy_write32(ch, 3245, 0x20040005);   //PHY_CAL_CLK_SELECT_0
+ 	mcu_phy_clrsetbits(ch, 3245, MASK_3BIT, 0x3); 
+    //PHY_PAD_ACS_IO_CFG ???
+    mcu_phy_write32(ch, 3199, 0x5); //0x3);
+
+    //PHY_PAD_DSLICE_IO_CFG_0  defalut:0
+//    for(slice = 0; slice < 9; slice++)
+//    {
+//        mcu_phy_clrsetbits(ch, 87 + (slice<<8), MASK_7BIT<<16, 0x5<<16);
+//    
+//    }
+
+//DRAM TCKELPD 
+//		mcu_ctl_write32(ch, 200, 0x6);
+//phy_dq/dqs_tsel_enable
+    //bit[2] = tsel_idle_en, bit[1] = tsel_wr_en, bit[0] = tsel_rd_en
+    const uint32_t TSEL_EN_RD = 1;
+    const uint32_t TSEL_EN_WR = (1 << 1);
+    const uint32_t TSEL_EN_IDLE = (1 << 2);
+    
+    //PHY_DQ_TSEL_ENABLE
+    for( slice = 0; slice < 9; slice++)
+    {
+        mcu_phy_clrsetbits(ch, 79 + (slice << 8), MASK_3BIT,  TSEL_EN_IDLE | TSEL_EN_RD);
+    }
+
+     //PHY_DQS_TSEL_ENABLE
+    for( slice = 0; slice < 9; slice++)
+    {
+        mcu_phy_clrsetbits(ch, 79 + (slice << 8), MASK_3BIT<<24,  (TSEL_EN_IDLE | TSEL_EN_RD) << 24);
+    }
+    
+
+    //phy_dqs/dq_tsel_select_X
+    //bit[15:8] = tsel_wr_select
+    //bit[7:0] = tsel_rd_select
+    //low four bits for ENSLICEN, upper four bits for ENSLICEP
+    /*
+       ENSLICEP_ODT/DRV  units: ohm
+       0   : Hi-Z
+       3   : 240 
+       4   : 120 
+       7   : 80 
+       8   : 60 
+       b   : 48 
+       c   : 40 
+       f   : 34.3 
+    */
+    //PHY_DQ_TSEL_SELECT
+    uint32_t tsel_wr_select = (ENSLICE_40_OHM << 4) | ENSLICE_40_OHM;  //ENSLICE_34_OHM
+    uint32_t tsel_rd_select = (ENSLICE_40_OHM << 4);//ENSLICE_48_OHM
+    for( slice = 0; slice < 9; slice++)
+    {
+        mcu_phy_clrsetbits(ch, 79 + (slice << 8), MASK_16BIT<<8,  
+                     ((tsel_wr_select << 8) | tsel_rd_select)<< 8);
+    }
+ 
+
+    //PHY_DQS_TSEL_SELECT
+    for( slice = 0; slice < 9; slice++)
+    {
+        mcu_phy_clrsetbits(ch, 80 + (slice << 8), MASK_16BIT,  
+                     (tsel_wr_select << 8) | tsel_rd_select );
+    }
+ 
+
+}
--- a/pnna/pnna-c6x/c6x_DDR_init/src/mcu_spd.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/mcu_spd.c
@ -0,0 +1,59 @@
+
+#include "mcu_config.h"
+
+
+void print_spd_info(uint8_t ch)
+{   
+
+    printf("/%d Bank Groups", dimm_info->spd_info[ch].bg_num);
+
+    printf("/%d Banks", dimm_info->spd_info[ch].bank_num); 
+
+    printf("/%d Column", dimm_info->spd_info[ch].col_num); 
+
+    printf("/%d Row", dimm_info->spd_info[ch].row_num); 
+
+    switch(dimm_info->spd_info[ch].data_width){
+        case DIMM_x8:
+            printf("/X8");
+            break;
+        case DIMM_x16:
+            printf("/X16");
+            break;
+        default:
+            break;
+    }
+
+    printf("/%d Ranks", dimm_info->spd_info[ch].rank_num); 
+
+    switch(dimm_info->spd_info[ch].ecc_type){
+        case NO_ECC_TYPE:
+            printf("/NO ECC");
+            break;
+        case ECC_TYPE:
+            printf("/ECC");
+            break;
+        default:
+            break;
+    }
+
+    if(dimm_info->spd_info[ch].mirror_type == NO_MIRROR)
+        printf("/Standard");
+    else
+        printf("/Mirror");
+
+    printf("\n");
+
+#if 0
+    printf("tRCDmin = %dps\n", dimm_info->spd_info[ch].tRCDmin);
+    printf("tRPmin = %dps\n", dimm_info->spd_info[ch].tRPmin);
+    printf("tRASmin = %dps\n", dimm_info->spd_info[ch].tRASmin);
+    printf("tRCmin = %dps\n", dimm_info->spd_info[ch].tRCmin);
+    printf("tFAWmin = %dps\n", dimm_info->spd_info[ch].tFAWmin);
+    printf("tRRD_Smin = %dps\n", dimm_info->spd_info[ch].tRRD_Smin);
+    printf("tRRD_Lmin = %dps\n", dimm_info->spd_info[ch].tRRD_Lmin);
+    printf("tWRmin = %dps\n", dimm_info->spd_info[ch].tWRmin);
+    printf("tWTRmin = %dps\n", dimm_info->spd_info[ch].tWTRmin);
+#endif
+}
+
--- a/pnna/pnna-c6x/c6x_DDR_init/src/mcu_test.c
+++ b/pnna/pnna-c6x/c6x_DDR_init/src/mcu_test.c
@ -0,0 +1,402 @@
+#include "mcu_config.h"
+
+
+
+void dram_ddr_test(void)
+{
+
+	unsigned int addr, val;
+	unsigned int start = 0x80000000;
+	unsigned int end = 0x80010000;
+
+
+	printf("dram test start \n");
+	printf("test start area 0x%8x to 0x%8x \n", start, end);
+	printf("dram test start \r\n");
+	printf("test start area from 0x%8x to 0x%8x \r\n", start, end);
+	for(addr = start; addr <= end; addr += 0x4)
+	{   
+//		writel(addr, addr); 
+ 	*(unsigned int *)(addr) = addr;       
+		//if(!(addr % 0x80000))
+		//	console_putc('*');
+	}   
+     printf("dram write done \n");
+
+     
+	for(addr = start; addr < end; addr += 0x4)
+	{   
+//		val = readl(addr);
+		val = *(unsigned int *)(addr);
+		//if(!(addr % 0x80000))
+		//	console_putc('#');
+		
+		if(val != addr)
+		{   
+			printf("error addr write_val = 0x%8x, read_val = 0x%8x \n", addr, val );
+
+		}  
+		
+	}   
+	printf("dram read done\n");
+
+
+
+
+}
+static void population(unsigned int addr, unsigned int size)
+{
+    unsigned int i;
+    for(i = 0; i <= size; i+= 0x4)
+        writeq(0x55555555, addr + i); //0x55555555  0xaaaaaaaa
+}
+void DMA_ddr_test(void)
+{
+	printf("\r\nDAM TEST Begin \r\n" );
+
+	unsigned int i=0;
+    unsigned int val=0;
+//    for(i = 0x70600000; i <= 0x70601000; i+= 0x4){
+//        writeq(0x12345678, 0x70600000 + i); 
+//        }
+    population(0x70600000, 0xFFFF);
+//	M7004_datatrans( 0x70600000, 0x80000000, 0xFFFF);
+
+//    for(i = 0; i <= 32768; i++){
+//        M7004_datatrans( 0x70600000, 0x80000000+i*0xFFFF, 0xFFFF);
+//        }
+	i=0;		
+	for(i = 0x80000000; i < 0x80001000; i += 0x4)
+//	for(i = 0x80000000; i < 0xffffffff; i += 0x1fffffff)
+	{   
+		val = readl(i);
+		//if(!(addr % 0x80000))
+		//	console_putc('#');
+		
+		if(val != 0x55555555)
+		{   
+			printf("DAM TEST error \r\n" );
+			printf("error addr = 0x%x, read_val = 0x%\r\n", i, val );
+		}
+	}
+	printf("DAM TEST DONE \r\n" );
+//	for(i=0; i<20;i++){
+//	 	M7004_datatrans( 0x80000000, 0x70700000+i*0xFFFF, 0xFFFF);
+//
+//	}
+	
+}
+static void population1(unsigned int addr, unsigned int size)
+{
+    unsigned int i;
+    for(i = 0; i <= size; i+= 0x4)
+        writeq(0xaaaaaaaa, addr + i);
+}
+static void population2(unsigned int addr, unsigned int size)
+{
+    unsigned int i;
+    for(i = 0; i <= size; i+= 0x4)
+        writeq(0x55555555, addr + i);
+}
+static void population3(unsigned int addr, unsigned int size)
+{
+    unsigned int i;
+    for(i = 0; i <= size; i+= 0x4)
+        writeq(0x11111111, addr + i);
+}
+static void population4(unsigned int addr, unsigned int size)
+{
+    unsigned int i;
+    for(i = 0; i <= size; i+= 0x4)
+        writeq(0x22222222, addr + i);
+}
+
+//uint64_t get_crt_time()
+//{
+//	int temp_time_base = 0;
+//	temp_time_base = Timer_Get_Counter(0,0);//为0表示核内Timer，需要进行20分频
+//	return temp_time_base;
+//}
+
+void DDR_Bandwidth_Test(void)
+{
+
+	uint32_t use_time;
+	uint32_t use_time0 = 0;
+	uint32_t use_time1 = 0;
+	uint32_t use_time2 = 0;
+	uint32_t use_time3 = 0;
+	uint32_t a = 0,b = 0;
+	uint32_t cnt0 = 0 ,cnt1 = 0 ;
+	unsigned int begin_time ,end_time, begin_time1;
+	double Band = 0.0;
+
+	GPIO_DirectionSet(0); //GPIO 0输出设置
+	GPIO_DataOutWrite(1);
+	
+//    population1(0x70610000, 0xFFFF);
+//    population1(0x70100000, 0xFFFF);
+//	population2(0x70630000, 0xFFFF);
+//	population3(0x70650000, 0xFFFF);
+//	population4(0x70670000, 0xFFFF);
+	//AM
+	population1(0x20000000, 0xFFFF);
+	population2(0x20030000, 0xFFFF);
+	
+//	population1(0x21000000, 0xFFFF);
+	//SM
+//	population1(0x20100000, 0x7FFF);
+//	population1(0x21100000, 0x7FFF);	
+//GSM
+	population1(0x70630000, 0xFFFF);
+	population2(0x70650000, 0xFFFF);
+/**********************************************/
+ //持续性计数，定时器当计数等于周期后一个时钟周期，计数重置为0再重新计数
+//	configTimer(0x80);
+//	//配置定时器周期0xffffffff
+//	setTimerPeriod(0xffffffff);
+//    //32位非链接模式启动
+//	timerStart(0);
+//		
+//	write_PRIR(1);
+
+#if 0
+/******************DDR WRITE****************************/
+	CONFIG_DMA(0,0x5006,0,0x20000000,0xffff,0x80100000,0xffff,0,0);//0x80100000
+//	CONFIG_DMA(0,0x5006,0,0x70610000,0xffff,0x80100000,0xffff,0,0);
+//	CONFIG_DMA(1,0x500e,0,0x70630000,0xf000,0x80500000,0xf000,0,0);
+	
+	clear_CIPR();
+	Timer_End(0, 0);
+	Timer64_Config(0, 0, (long long)0xffffffffffffffff , 1);
+	Timer_Clear_Counter(0, 0);
+	Timer_Start(0, 0);
+	begin_time = Timer_Get_Counter(0,0);//计时开始
+//	GPIO_DataOutWrite(0);
+	*(unsigned long*)ESR = 0x1;//DMA启动传输标志
+	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);//DMA传输完成判断语句
+//	while (((*(volatile unsigned long*)CIPR)&(1<<1))==0);
+//	GPIO_DataOutWrite(1);
+	end_time = Timer_Get_Counter(0,0);//结束计时
+
+	use_time = end_time - begin_time;
+	printf("WRITE use time = %d \n", use_time);
+//	Band = (double)0x800000*1000/use_time/20/1000 ;
+//	Band = (double)0x4000*1000/use_time/20/1000 ;
+	Band = (double)0xffff*1000/use_time/20/1000 ;
+	printf("AM write data to DDR Band = %.2llf GBps\n",Band);
+
+/**********************************************/
+#endif
+#if 0
+/******************DDR read****************************/
+	CONFIG_DMA(0,0x5006,0,0x80100000,0xffff,0x20030000,0xffff,0,0);
+//	CONFIG_DMA(0,0x5006,0,0x80100000,0xffff,0x70620000,0xffff,0,0);
+//	CONFIG_DMA(1,0x500e,0,0x70630000,0xf000,0x80500000,0xf000,0,0);
+	clear_CIPR();
+	Timer_End(0, 0);
+	Timer64_Config(0, 0, (long long)0xffffffffffffffff , 1);
+	Timer_Clear_Counter(0, 0);
+	Timer_Start(0, 0);
+	begin_time = Timer_Get_Counter(0,0);//计时开始
+//	GPIO_DataOutWrite(0);
+	*(unsigned long*)ESR = 0x1;//DMA启动传输标志
+	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);//DMA传输完成判断语句
+//	while (((*(volatile unsigned long*)CIPR)&(1<<1))==0);
+//	GPIO_DataOutWrite(1);
+	end_time = Timer_Get_Counter(0,0);//结束计时
+
+	use_time = end_time - begin_time;
+	printf("READ use time = %d \n", use_time);
+//	Band = (double)0x800000*1000/use_time/20/1000 ;
+//	Band = (double)0x4000*1000/use_time/20/1000 ;
+	Band = (double)0xffff*1000/use_time/20/1000 ;
+	printf("AM read data from DDR Band = %.2llf GBps\n",Band);
+
+/******************data1 verify****************************/
+
+	unsigned int addr;
+	 int *S;
+	unsigned int start = 0x80100000;
+	unsigned int end = 0x8010fff0;
+
+	for(addr = start; addr < end; addr += 0x4)
+	{
+		S = ( int *)(addr) ;
+		if(*S != 0xaaaaaaaa)
+					{
+						printf("error\n");
+						printf("error addr: %8x ,error data : %8x \n",addr,S);
+						break;
+					}
+
+	}
+	printf("write data verify  pass\n");
+/******************data2 verify****************************/
+
+		unsigned int addr1;
+		 int *S1;
+		unsigned int start1 = 0x20030000;//0x20030000  0x70620000
+		unsigned int end1 = 0x2003fff0;//0x2003fff0  0x7062fff0
+
+		for(addr1 = start1; addr1 < end1; addr1 += 0x4)
+		{
+			S1 = ( int *)(addr1) ;
+			if(*S1 != 0xaaaaaaaa)
+						{
+							printf("error\n");
+							printf("error addr: %8x ,error data : %8x \n",addr1,S1);
+							break;
+						}
+
+		}
+		printf("read  data verify  pass\n");
+/**********************************************/
+#endif
+
+		printf("Bandwidth test Done\n");
+		
+		
+		
+#if 0
+//	population1(0x80100000, 0xFFFF);
+	unsigned int addr6;
+	unsigned int start_addr = 0x20000000;//0x80100000 0x21000000 0x70100000
+	unsigned int end_addr 	 = 0x80100000;//0x21000000  0x20100000 0x21100000
+	int *S6;
+	use_time = 0;
+	end_time = 0;
+	begin_time = 0;
+	Band = 0;
+/******************DDR WRITE****************************/
+	CONFIG_DMA(0,0x5006,0,start_addr,0x8000,end_addr,0x8000,0,0);//0x80100000
+//	CONFIG_DMA(0,0x5006,0,end_addr+0x20,0x8000,start_addr,0x8000,0,0);
+//	CONFIG_DMA(1,0x500e,0,start_addr,0x8000,end_addr,0x8000,0,0);	
+	clear_CIPR();
+	Timer_End(0, 0);
+	Timer64_Config(0, 0, (long long)0xffffffffffffffff , 1);
+	Timer_Clear_Counter(0, 0);
+	Timer_Start(0, 0);
+	begin_time = Timer_Get_Counter(0,0);//计时开始
+//	GPIO_DataOutWrite(0);
+	*(unsigned long*)ESR = 0x1;//DMA启动传输标志
+//	*(unsigned long*)ESR = 0x2;
+	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);//DMA传输完成判断语句
+//	while (((*(volatile unsigned long*)CIPR)&(1<<1))==0);
+//	GPIO_DataOutWrite(1);
+	end_time = Timer_Get_Counter(0,0);//结束计时
+	use_time = end_time - begin_time;
+	printf(" use time = %d \n", use_time);
+	Band = (double)0x8000*1000/use_time/20/1000 ;
+	printf("write data to DDR Band = %.2llf GBps\n",Band);
+//	for(addr6 = start_addr; addr6 < (start_addr+0x4000); addr6 += 0x4)
+	for(addr6 = end_addr+0x100; addr6 < (end_addr+0x7000); addr6 += 0x4)
+		{
+			S6 = ( int *)(addr6) ;
+			if(*S6 != 0xaaaaaaaa)//0xaaaaaaaa
+				{
+					printf("error\n");
+					printf("error addr: %8x ,error data : %8x \n",addr6,S6);
+					break;
+				}
+
+		}
+	printf("data verify  pass\n");
+
+/******************DDR read****************************/
+	use_time = 0;
+	end_time = 0;
+	begin_time = 0;
+	Band = 0;
+	int i;
+	population2(0x80100000, 0xFFFF);
+	Timer_End(0, 0);
+	Timer64_Config(0, 0, (long long)0xffffffffffffffff , 1);
+	Timer_Clear_Counter(0, 0);
+	Timer_Start(0, 0); 
+	begin_time = Timer_Get_Counter(0,0);//计时开始
+	for(i=0; i <= 99; i++)
+	{
+	CONFIG_DMA(0,0x5006,0,start_addr,0x8000,end_addr,0x8000,0,0);//0x80100000
+//	CONFIG_DMA(0,0x5006,0,end_addr+0x20,0x8000,start_addr+0x20,0x8000,0,0);
+//	CONFIG_DMA(1,0x500e,0,0x70630000,0xf000,0x80500000,0xf000,0,0);	
+	clear_CIPR();
+//	Timer_End(0, 0);
+//	Timer64_Config(0, 0, (long long)0xffffffffffffffff , 1);
+//	Timer_Clear_Counter(0, 0);
+//	Timer_Start(0, 0); 
+//	begin_time = Timer_Get_Counter(0,0);//计时开始
+//	GPIO_DataOutWrite(0);
+	*(unsigned long*)ESR = 0x1;//DMA启动传输标志
+	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);//DMA传输完成判断语句
+	
+	}
+//	while (((*(volatile unsigned long*)CIPR)&(1<<1))==0);
+//	GPIO_DataOutWrite(1);
+	end_time = Timer_Get_Counter(0,0);//结束计时
+	use_time = end_time - begin_time;
+	printf(" use time x = %d \n", i);
+	printf(" use time = %d \n", use_time);
+	Band = (double)0x8000*1000*100/use_time/20/1000 ;
+	printf("DDR Band = %.2llf GBps\n",Band);
+
+
+
+
+/**********************************************/
+#endif
+		
+}
+/**********Qualiphy test****************/
+#if 0
+void qualiphy_test(void)
+{
+	int i;
+	for(i=0; i<0x1000000000; i ++ ){
+//while(1){	
+		CONFIG_DMA(0,0x5006,0,0x70650000,0xf000,0x80600000,0xf000,0,0);
+		CONFIG_DMA(1,0x500e,0,0x70300000,0xf000,0x80500000,0xf000,0,0);
+//	clear_CIPR();
+//	*(unsigned long*)ESR = 0x3;//DMA启动传输标志
+//	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);
+//	while (((*(volatile unsigned long*)CIPR)&(1<<1))==0);
+		CONFIG_DMA(0,0x5006,0,0x80500000,0xf000,0x90500000,0xf000,0,0);
+		CONFIG_DMA(1,0x500e,0,0x80600000,0xf000,0x90600000,0xf000,0,0);
+//	clear_CIPR();
+//	*(unsigned long*)ESR = 0x3;//DMA启动传输标志
+//	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);
+//	while (((*(volatile unsigned long*)CIPR)&(1<<1))==0);
+	
+		CONFIG_DMA(0,0x5006,0,0x70610000,0xf000,0x80500000,0xf000,0,0);
+		CONFIG_DMA(1,0x500e,0,0x70630000,0xf000,0x80600000,0xf000,0,0);
+		CONFIG_DMA(0,0x5006,0,0x70300000,0xf000,0x80500000,0xf000,0,0);
+		CONFIG_DMA(1,0x500e,0,0x70500000,0xf000,0x80600000,0xf000,0,0);
+			
+		CONFIG_DMA(0,0x5006,0,0xf0500000,0xf000,0x80500000,0xf000,0,0);
+		CONFIG_DMA(1,0x500e,0,0xc0500000,0xf000,0x80600000,0xf000,0,0);
+		
+		
+		CONFIG_DMA(0,0x5006,0,0xf0500000,0xf000,0x70610000,0xf000,0,0);
+		CONFIG_DMA(1,0x500e,0,0xc0500000,0xf000,0x70620000,0xf000,0,0);
+//	CONFIG_DMA(0,0x5006,0,0x80500000,0xf000,0x70630000,0xf000,0,0);
+//	CONFIG_DMA(1,0x500e,0,0x90500000,0xf000,0x70640000,0xf000,0,0);
+//	CONFIG_DMA(0,0x5006,0,0xa0500000,0xf000,0x70650000,0xf000,0,0);
+//	CONFIG_DMA(1,0x500e,0,0xb0500000,0xf000,0x70660000,0xf000,0,0);
+//	CONFIG_DMA(0,0x5006,0,0x80100000,0xf000,0x70670000,0xf000,0,0);
+//	CONFIG_DMA(1,0x500e,0,0x90100000,0xf000,0x70680000,0xf000,0,0);		
+//	clear_CIPR();
+		*(unsigned long*)ESR = 0x3;//DMA启动传输标志
+//	while (((*(volatile unsigned long*)CIPR)&(1<<0))==0);
+//	while (((*(volatile unsigned long*)CIPR)&(1<<1))==0);
+//	 M7004_datatrans( 0x70610000, 0x80100000, 0xF000);
+//	 M7004_datatrans( 0x70630000, 0x80000000, 0xF000);
+//	 M7004_datatrans( 0x80100000, 0x90100000, 0xF000);
+//	 M7004_datatrans( 0x80200000, 0x70640000, 0xF000);
+//	 M7004_datatrans( 0x70650000, 0x80300000, 0xF000);
+//	 M7004_datatrans( 0x70670000, 0x80400000, 0xF000);
+
+}
+
+	
+}
+#endif
--- a/pnna/pnna-c6x/emulation-drivers/FT-EMU560_Config.txt
+++ b/pnna/pnna-c6x/emulation-drivers/FT-EMU560_Config.txt
@ -0,0 +1,10 @@
+Version_1.0
+1>FT-EMU560_TCK=(3)
+2>Reset_or_Noreset_CPU=(1)
+3>Enable_or_disable_CIO=(0)
+4>Enable_or_disable_print_log=(1)
+5>Enable_or_disable_Test_JTAG=(0)
+6>Enable_or_disable_printf_function=(0)
+7>Disable_Interrupt_Run=(0)
+8>Enable_Interrupt_Step=(0)
+9>Enable_or_disable_Cache=(0)
--- a/pnna/pnna-c6x/emulation-drivers/tixds560arm9.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560arm9.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560c64x_11.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560c64x_11.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560c64x_plus.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560c64x_plus.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560c6x.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560c6x.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560cortexA15.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560cortexA15.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560cs_dap.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560cs_dap.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560csstm.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560csstm.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560etbcs.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560etbcs.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560icepick_c.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560icepick_c.dvr
--- a/pnna/pnna-c6x/emulation-drivers/tixds560icepick_d.dvr
+++ b/pnna/pnna-c6x/emulation-drivers/tixds560icepick_d.dvr
--- a/pnna/pnna-c6x/pnna-drivers/include/M6678V4_PLL.h
+++ b/pnna/pnna-c6x/pnna-drivers/include/M6678V4_PLL.h
@ -0,0 +1,79 @@
+/**
+********************************************************************************
+* @file       M6678V4_PLL.h
+* @brief      用于实现M6678V4 PLL设置的各种接口函数的声明和寄存器宏定义。
+* @version    V1.0
+* @date       2023.12.22
+* @attention
+* \par
+* ============================================================================
+* @n   (C) 飞腾DSP技术支持团队.
+********************************************************************************
+*/
+#ifndef __M6678V4_PLL_H_
+#define __M6678V4_PLL_H_
+#include <stdint.h>
+
+#define	KICK0 			*(volatile	unsigned int *)0x09000038
+#define	KICK1			*(volatile	unsigned int *)0x0900003C
+
+/********************* DSP_PLL 寄存器 ************************************************/
+#define	DSP_PLLCTL		*(volatile	unsigned int *)0x09020100
+#define	DSP_PLLCMD		*(volatile	unsigned int *)0x09020104
+#define	DSP_PLLDIV		*(volatile	unsigned int *)0x09020108
+
+/********************* NOC_PLL 寄存器 ************************************************/
+#define	NOC_PLLCTL		*(volatile	unsigned int *)0x09020110
+#define	NOC_PLLCMD		*(volatile	unsigned int *)0x09020114
+
+/********************* SYS_PLL 寄存器 ************************************************/
+#define	SYS_PLLCTL		*(volatile	unsigned int *)0x09020120
+#define	SYS_PLLCMD		*(volatile	unsigned int *)0x09020124
+#define	SYS_PLLDIV1		*(volatile	unsigned int *)0x09020128
+
+/********************* PCIE_PLL 寄存器 ************************************************/
+#define	PCIE_PLLCTL		*(volatile	unsigned int *)0x09020130
+#define	PCIE_PLLCMD		*(volatile	unsigned int *)0x09020134
+
+/********************* DDR_PLL 寄存器 ************************************************/
+#define	DDR_PLLCTL		*(volatile	unsigned int *)0x09020140
+#define	DDR_PLLCMD		*(volatile	unsigned int *)0x09020144
+
+/********************* ACC_PLL 寄存器 ************************************************/
+#define	ACC_PLLCTL		*(volatile	unsigned int *)0x09020150
+#define	ACC_PLLCMD		*(volatile	unsigned int *)0x09020154
+#define	ACC_PLLDIV1		*(volatile	unsigned int *)0x09020158
+#define	ACC_PLLDIV2		*(volatile	unsigned int *)0x0902015C
+
+
+/********************* SRIO_PLL 寄存器 ************************************************/
+#define	SRIO_PLLCTL	*(volatile	unsigned int *)0x09020160
+#define	SRIO_PLLCMD	*(volatile	unsigned int *)0x09020164
+
+/********************* SRIO_PLL 寄存器 ************************************************/
+#define	ARM_PLLCTL		*(volatile	unsigned int *)0x09020170
+#define	ARM_PLLCMD		*(volatile	unsigned int *)0x09020174
+#define	ARM_PLLDIV		*(volatile	unsigned int *)0x09020178
+
+/********************* SRIO2_PLL 寄存器 ************************************************/
+#define	SRIO2_PLLCTL	*(volatile	unsigned int *)0x09020180
+#define	SRIO2_PLLCMD	*(volatile	unsigned int *)0x09020184
+
+// 函数声明
+void DSP_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void NOC_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void SYS_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void PCIE_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void DDR_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void ACC_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void SRIO_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void ARM_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void SRIO2_PLL_Init	(uint16_t FBDIV, uint8_t REFDIV,  uint8_t POSTDIV1, uint8_t POSTDIV2);
+void DSPCLKV_PLL	(uint8_t RATIO);
+void ARMCLKV_PLL	(uint8_t RATIO_arm);
+void ACC_FFT_PLL	(uint8_t RATIO1);
+void ACC_VIP_PLL	(uint8_t RATIO2);
+
+
+
+#endif /* __M6678V4_PLL_H_ */
--- a/pnna/pnna-c6x/pnna-drivers/include/M6678V4_PSC.h
+++ b/pnna/pnna-c6x/pnna-drivers/include/M6678V4_PSC.h
@ -0,0 +1,75 @@
+/** 
+********************************************************************************
+* @file       M6678V4_PSC.h
+* @brief      用于声明M6678V4开时钟接口函数和寄存器宏定义。
+* @version    V1.0
+* @date       2022.8.20
+* @attention  
+* \par
+* ============================================================================
+* @n   (C) 飞腾DSP技术支持团队.
+********************************************************************************
+*/
+#ifndef   _M6678V4_PSC_H_
+#define   _M6678V4_PSC_H_
+
+/***************PSC 接口函数声明***************************************************/
+extern void PSC_Open_Clk(const char *string , unsigned int Power_Domain);
+extern void PSC_Close_Clk(const char *string , unsigned int Power_Domain);
+
+/***************PSC 寄存器*******************************************************/
+#define PSC_BASE            0x09080000
+#define PTCMD_REG           0x09080120
+#define PTSTAT_REG	        0x09080128
+
+/***************PSC 模块时钟寄存器**************************************************/
+
+#define	DSP0CORE_offset		0xA04
+#define DSP1CORE_offset    	0xA08
+#define DSP2CORE_offset     0xA0C
+#define DSP3CORE_offset     0xA10
+#define DSP4CORE_offset     0xA14
+#define DSP5CORE_offset    	0xA18
+#define DSP6CORE_offset   	0xA1C
+#define DSP7CORE_offset    	0xA20
+//#define	ARMA15CORE_offset	0xA24
+
+#define DSP0_offset    		0xA28
+#define DSP1_offset    		0xA2C
+#define DSP2_offset    		0xA30
+#define DSP3_offset    		0xA34
+#define DSP4_offset    		0xA38
+#define DSP5_offset    		0xA3C
+#define DSP6_offset    		0xA40
+#define DSP7_offset    		0xA44
+#define ARMA15_offset    	0xA48
+
+#define	FFT_offset			0xA4C
+#define	FFT1_offset			0xAA4
+#define	VIP_offset			0xA50
+#define	RGMII_offset		0xA54
+#define	PCIE_offset			0xA58
+
+#define	SRIO0_offset		0xA5C
+#define	SRIO1_offset		0xA60
+#define	SRIO2_offset		0xA64
+#define	TP_offset			0xA68
+
+#define	SMC_offset			0xA6C
+#define	EMIF_offset			0xA70
+#define	DDR_offset			0xA74
+#define	DMA0_offset			0xA78
+#define	DMA1_offset			0xA7C
+#define	DMA2_offset			0xA80
+#define	DMA3_offset			0xA84
+#define	DMA4_offset			0xA88
+#define	GPIO_offset			0xA8C
+#define	I2C_offset			0xA90
+#define	SPI_offset			0xA94
+#define	UART_offset			0xA98
+#define	TIMER_offset		0xA9C
+#define	M1553B_offset		0xAA0
+
+
+
+#endif
--- a/pnna/pnna-c6x/pnna-drivers/include/pnna_lite.h
+++ b/pnna/pnna-c6x/pnna-drivers/include/pnna_lite.h
--- a/pnna/pnna-c6x/pnna-drivers/include/pnna_lite_common.h
+++ b/pnna/pnna-c6x/pnna-drivers/include/pnna_lite_common.h
@ -0,0 +1,240 @@
+/****************************************************************************
+*
+*    The MIT License (MIT)
+*
+*    Copyright (c) 2017 - 2023 Vivante Corporation
+*
+*    Permission is hereby granted, free of charge, to any person obtaining a
+*    copy of this software and associated documentation files (the "Software"),
+*    to deal in the Software without restriction, including without limitation
+*    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+*    and/or sell copies of the Software, and to permit persons to whom the
+*    Software is furnished to do so, subject to the following conditions:
+*
+*    The above copyright notice and this permission notice shall be included in
+*    all copies or substantial portions of the Software.
+*
+*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+*    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+*    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+*    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+*    DEALINGS IN THE SOFTWARE.
+*
+*****************************************************************************
+*
+*    The GPL License (GPL)
+*
+*    Copyright (C) 2017 - 2023 Vivante Corporation
+*
+*    This program is free software; you can redistribute it and/or
+*    modify it under the terms of the GNU General Public License
+*    as published by the Free Software Foundation; either version 2
+*    of the License, or (at your option) any later version.
+*
+*    This program is distributed in the hope that it will be useful,
+*    but WITHOUT ANY WARRANTY; without even the implied warranty of
+*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*    GNU General Public License for more details.
+*
+*    You should have received a copy of the GNU General Public License
+*    along with this program; if not, write to the Free Software Foundation,
+*    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*
+*****************************************************************************
+*
+*    Note: This software is released under dual MIT and GPL licenses. A
+*    recipient may use this file under the terms of either the MIT license or
+*    GPL License. If you wish to use only one license not the other, you can
+*    indicate your decision by deleting one of the above license notices in your
+*    version of this file.
+*
+*****************************************************************************/
+
+#ifndef _PNNA_LITE_COMMON_H
+#define _PNNA_LITE_COMMON_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*!
+ *\brief The PNNA lite API for Convolution Neural Network application on CPU/MCU/DSP type of embedded environment.
+ *\details This PNNA lite APIs is not thread-safe if vpmdENABLE_MULTIPLE_TASK is set to 0,
+           user must guarantee to call these APIs in a proper way.
+           But defines vpmdENABLE_MULTIPLE_TASK 1, PNNALite can support multiple task(multiple thread/process).
+           and it's thread-safe.
+ *Memory allocation and file io functions used inside driver internal would depend on working enviroment.
+ *\defgroup group_global Data Type Definitions and Global APIs
+ *\brief Data type definition and global APIs that are used in the PNNA lite
+ *\defgroup group_buffer Buffer API
+ *\brief The API to manage input/output buffers
+ *\defgroup group_network  Network API
+ *\brief The API to manage networks
+ */
+
+/*! \brief An 8-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned char       pnna_uint8_t;
+
+/*! \brief An 16-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned short      pnna_uint16_t;
+
+/*! \brief An 32-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned int        pnna_uint32_t;
+
+/*! \brief An 64-bit unsigned value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned long long  pnna_uint64_t;
+
+/*! \brief An 8-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed char         pnna_int8_t;
+
+/*! \brief An 16-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed short        pnna_int16_t;
+
+/*! \brief An 32-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed int          pnna_int32_t;
+
+/*! \brief An 64-bit signed value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef signed long long    pnna_int64_t;
+
+/*! \brief An 8 bit ASCII character.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef char                pnna_char_t;
+
+/*! \brief An 32 bit float value.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef float               pnna_float_t;
+
+/*! \brief Sets the standard enumeration type size to be a fixed quantity.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef pnna_int32_t         pnna_enum;
+
+/*! \brief a void pointer.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef void*               pnna_ptr;
+
+/*! \brief A 64-bit float value (aka double).
+ * \ingroup group_basic_features
+ */
+typedef double              pnna_float64_t;
+
+/*! \brief address type.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef unsigned long long  pnna_address_t;
+
+/*! \brief A zero value for pointer
+ *\ingroup group_global
+ *\version 1.0
+ */
+#ifndef PNNA_NULL
+#define PNNA_NULL 0
+#endif
+
+/***** Helper Macros. *****/
+#define PNNA_API
+
+#define IN
+#define OUT
+
+/*! \brief A invalid value if a property is not avaialbe for the query.
+ *\ingroup group_global
+ *\version 1.0
+ */
+#define PNNA_INVALID_VALUE       ~0UL
+
+/*! \brief  A Boolean value.
+ *\details  This allows 0 to be FALSE, as it is in C, and any non-zero to be TRUE.
+ *\ingroup group_global
+ *\version 1.0
+ */
+typedef enum _pnna_bool_e {
+    /*! \brief The "false" value. */
+    pnna_false_e = 0,
+    /*! \brief The "true" value. */
+    pnna_true_e,
+} pnna_bool_e;
+
+/*! \brief The enumeration of all status codes.
+ * \ingroup group_global
+ * \version 1.0
+ */
+typedef enum _pnna_status
+{
+    /*!< \brief Indicates a FUSA error occurs */
+    PNNA_ERROR_FUSA                  = -17,
+    /*!< \brief Indicates the network hit Not A Number or Infinite error */
+    PNNA_ERROR_NAN_INF               = -16,
+    /*!< \brief Indicates the network is canceld */
+    PNNA_ERROR_CANCELED              = -15,
+    /*!< \brief Indicates the hardware is recovery done after hang */
+    PNNA_ERROR_RECOVERY              = -14,
+    /*!< \brief Indicates the hardware is stoed */
+    PNNA_ERROR_POWER_STOP            = -13,
+    /*!< \brief Indicates the hardware is in power off status */
+    PNNA_ERROR_POWER_OFF             = -12,
+    /*!< \brief Indicates the failure */
+    PNNA_ERROR_FAILURE               = -11,
+    /*!< \brief Indicates the binary is not compatible with the current runtime hardware */
+    PNNA_ERROR_NETWORK_INCOMPATIBLE  = -10,
+    /*!< \brief Indicates the network is not prepared so current function call can't go through */
+    PNNA_ERROR_NETWORK_NOT_PREPARED  = -9,
+    /*!< \brief Indicates the network misses either input or output when running the network */
+    PNNA_ERROR_MISSING_INPUT_OUTPUT  = -8,
+    /*!< \brief Indicates the network binary is invalid */
+    PNNA_ERROR_INVALID_NETWORK       = -7,
+    /*!< \brief Indicates driver is running out of memory of video memory */
+    PNNA_ERROR_OUT_OF_MEMORY         = -6,
+    /*!< \brief Indicates there is no enough resource */
+    PNNA_ERROR_OUT_OF_RESOURCE       = -5,
+    /*!< \brief Indicates it's supported by driver implementation */
+    PNNA_ERROR_NOT_SUPPORTED         = -4,
+    /*!< \brief Indicates some arguments are not valid */
+    PNNA_ERROR_INVALID_ARGUMENTS     = -3,
+    /*!< \brief Indicates there are some IO related error */
+    PNNA_ERROR_IO                    = -2,
+    /*!< \brief Indicates PNNA timeout, could be PNNA stuck somewhere */
+    PNNA_ERROR_TIMEOUT               = -1,
+    /*!< \brief Indicates the execution is successfuly */
+    PNNA_SUCCESS                     =  0,
+} pnna_status_e;
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
--- a/pnna/pnna-c6x/pnna-drivers/lib/libc66x_psc.lib
+++ b/pnna/pnna-c6x/pnna-drivers/lib/libc66x_psc.lib
--- a/pnna/pnna-c6x/pnna-drivers/lib/libpnna.lib
+++ b/pnna/pnna-c6x/pnna-drivers/lib/libpnna.lib
--- a/pnna/pnna-c6x/pnna-drivers/lib/libpnnalite1.15.0.lib
+++ b/pnna/pnna-c6x/pnna-drivers/lib/libpnnalite1.15.0.lib
--- a/pnna/pnna-c6x/project/.ccsproject
+++ b/pnna/pnna-c6x/project/.ccsproject
@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<?ccsproject version="1.0"?>
+<projectOptions>
+	<deviceFamily value="C6000"/>
+	<isTargetManual value="false"/>
+	<origin value="D:/workspace_v7/LiteDemoTest134lenet_int8_ptr_custom_vivante_v1_15_0_20240104"/>
+</projectOptions>
--- a/pnna/pnna-c6x/project/.cproject
+++ b/pnna/pnna-c6x/project/.cproject
@ -0,0 +1,163 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
+	<storageModule configRelations="2" moduleId="org.eclipse.cdt.core.settings">
+		<cconfiguration id="com.ti.ccstudio.buildDefinitions.C6000.Debug.10606160">
+			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="com.ti.ccstudio.buildDefinitions.C6000.Debug.10606160" moduleId="org.eclipse.cdt.core.settings" name="Debug">
+				<externalSettings/>
+				<extensions>
+					<extension id="com.ti.ccstudio.binaryparser.CoffParser" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="com.ti.ccstudio.errorparser.CoffErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.LinkErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.AsmErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+				</extensions>
+			</storageModule>
+			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+				<configuration artifactExtension="out" artifactName="${ProjName}" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.C6000.Debug.10606160" name="Debug" parent="com.ti.ccstudio.buildDefinitions.C6000.Debug">
+					<folderInfo id="com.ti.ccstudio.buildDefinitions.C6000.Debug.10606160." name="/" resourcePath="">
+						<toolChain id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.DebugToolchain.821019085" name="TI Build Tools" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.DebugToolchain" targetTool="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.linkerDebug.1156092720">
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS.1216276418" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS" valueType="stringList">
+								<listOptionValue builtIn="false" value="DEVICE_CONFIGURATION_ID=com.ti.ccstudio.deviceModel.C6000.GenericC66xxDevice"/>
+								<listOptionValue builtIn="false" value="DEVICE_ENDIANNESS=little"/>
+								<listOptionValue builtIn="false" value="OUTPUT_FORMAT=ELF"/>
+								<listOptionValue builtIn="false" value="LINKER_COMMAND_FILE=C6678.cmd"/>
+								<listOptionValue builtIn="false" value="RUNTIME_SUPPORT_LIBRARY=libc.a"/>
+								<listOptionValue builtIn="false" value="CCS_MBS_VERSION=5.5.0"/>
+								<listOptionValue builtIn="false" value="OUTPUT_TYPE=executable"/>
+							</option>
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION.1765090120" name="Compiler version" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION" value="8.2.2" valueType="string"/>
+							<targetPlatform id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.targetPlatformDebug.629067559" name="Platform" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.targetPlatformDebug"/>
+							<builder buildPath="${BuildDirectory}" id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.builderDebug.1216569542" keepEnvironmentInBuildfile="false" name="GNU Make" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.builderDebug"/>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.compilerDebug.1853887318" name="C6000 Compiler" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.compilerDebug">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.SILICON_VERSION.516178010" name="Target processor version (--silicon_version, -mv)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.SILICON_VERSION" value="6600" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.ABI.1829426615" name="Application binary interface (coffabi not supported) (--abi)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.ABI" value="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.ABI.eabi" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.INCLUDE_PATH.111156747" name="Add dir to #include search path (--include_path, -I)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.INCLUDE_PATH" valueType="includePath">
+									<listOptionValue builtIn="false" value="${workspace_loc:/${ProjName}/example/include}"/>
+									<listOptionValue builtIn="false" value="E:\work_space\ccs\78V4\pnna-drivers\include"/>
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DEFINE.391132314" name="Pre-define NAME (--define, -D)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DEFINE" valueType="definedSymbols">
+									<listOptionValue builtIn="false" value="C66"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DEBUGGING_MODEL.374239947" name="Debugging model" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DEBUGGING_MODEL" value="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DEBUGGING_MODEL.SYMDEBUG__DWARF" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.GCC.1260575276" name="Enable support for GCC extensions (DEPRECATED) (--gcc)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.GCC" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DIAG_WARNING.775249369" name="Treat diagnostic &lt;id&gt; as warning (--diag_warning, -pdsw)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DIAG_WARNING" valueType="stringList">
+									<listOptionValue builtIn="false" value="225"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DIAG_WRAP.109365110" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DISPLAY_ERROR_NUMBER.1313102585" name="Emit diagnostic identifier numbers (--display_error_number, -pden)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compilerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__C_SRCS.289573689" name="C Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__C_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__CPP_SRCS.215602121" name="C++ Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__CPP_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__ASM_SRCS.2072164486" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__ASM_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__ASM2_SRCS.548969358" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.compiler.inputType__ASM2_SRCS"/>
+							</tool>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.linkerDebug.1156092720" name="C6000 Linker" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exe.linkerDebug">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.MAP_FILE.2060335771" name="Link information (map) listed into &lt;file&gt; (--map_file, -m)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.MAP_FILE" value="&quot;${ProjName}.map&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.OUTPUT_FILE.1662875672" name="Specify output file name (--output_file, -o)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.OUTPUT_FILE" value="${ProjName}.out" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.LIBRARY.1730547934" name="Include library file or command file as input (--library, -l)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.LIBRARY" valueType="libs">
+									<listOptionValue builtIn="false" value="libc.a"/>
+									<listOptionValue builtIn="false" value="libpnna.lib"/>
+									<listOptionValue builtIn="false" value="libc66x_psc.lib"/>
+									<listOptionValue builtIn="false" value="libpnnalite1.15.0.lib"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.SEARCH_PATH.2087837134" name="Add &lt;dir&gt; to library search path (--search_path, -i)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.SEARCH_PATH" valueType="libPaths">
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/lib&quot;"/>
+									<listOptionValue builtIn="false" value="E:\work_space\ccs\78V4\pnna-drivers\lib"/>
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.DIAG_WRAP.855090694" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.DISPLAY_ERROR_NUMBER.206507187" name="Emit diagnostic identifier numbers (--display_error_number)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.XML_LINK_INFO.476774175" name="Detailed link information data-base into &lt;file&gt; (--xml_link_info, -xml_link_info)" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.linkerID.XML_LINK_INFO" value="&quot;${ProjName}_linkInfo.xml&quot;" valueType="string"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exeLinker.inputType__CMD_SRCS.2109512569" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exeLinker.inputType__CMD_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exeLinker.inputType__CMD2_SRCS.280609007" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exeLinker.inputType__CMD2_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_8.2.exeLinker.inputType__GEN_CMDS.269138368" name="Generated Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.exeLinker.inputType__GEN_CMDS"/>
+							</tool>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_8.2.hex.137601297" name="C6000 Hex Utility" superClass="com.ti.ccstudio.buildDefinitions.C6000_8.2.hex"/>
+						</toolChain>
+					</folderInfo>
+				</configuration>
+			</storageModule>
+			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+		</cconfiguration>
+		<cconfiguration id="com.ti.ccstudio.buildDefinitions.C6000.Release.1523313324">
+			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="com.ti.ccstudio.buildDefinitions.C6000.Release.1523313324" moduleId="org.eclipse.cdt.core.settings" name="Release">
+				<externalSettings/>
+				<extensions>
+					<extension id="com.ti.ccstudio.binaryparser.CoffParser" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="com.ti.ccstudio.errorparser.CoffErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.LinkErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="com.ti.ccstudio.errorparser.AsmErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+				</extensions>
+			</storageModule>
+			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+				<configuration artifactExtension="out" artifactName="${ProjName}" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.C6000.Release.1523313324" name="Release" parent="com.ti.ccstudio.buildDefinitions.C6000.Release">
+					<folderInfo id="com.ti.ccstudio.buildDefinitions.C6000.Release.1523313324." name="/" resourcePath="">
+						<toolChain id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.ReleaseToolchain.803878491" name="TI Build Tools" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.ReleaseToolchain" targetTool="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerRelease.1237800372">
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS.1127627173" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS" valueType="stringList">
+								<listOptionValue builtIn="false" value="DEVICE_CONFIGURATION_ID=com.ti.ccstudio.deviceModel.C6000.GenericC66xxDevice"/>
+								<listOptionValue builtIn="false" value="DEVICE_ENDIANNESS=little"/>
+								<listOptionValue builtIn="false" value="OUTPUT_FORMAT=ELF"/>
+								<listOptionValue builtIn="false" value="CCS_MBS_VERSION=5.5.0"/>
+								<listOptionValue builtIn="false" value="LINKER_COMMAND_FILE=C6678.cmd"/>
+								<listOptionValue builtIn="false" value="RUNTIME_SUPPORT_LIBRARY=rts6600_elf_mt.lib"/>
+								<listOptionValue builtIn="false" value="OUTPUT_TYPE=executable"/>
+							</option>
+							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION.2113219224" name="Compiler version" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_CODEGEN_VERSION" value="7.4.4" valueType="string"/>
+							<targetPlatform id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.targetPlatformRelease.1038197571" name="Platform" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.targetPlatformRelease"/>
+							<builder buildPath="${BuildDirectory}" id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.builderRelease.391292655" keepEnvironmentInBuildfile="false" name="GNU Make" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.builderRelease"/>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.compilerRelease.1095527560" name="C6000 Compiler" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.compilerRelease">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.SILICON_VERSION.276125784" name="Target processor version (--silicon_version, -mv)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.SILICON_VERSION" value="6600" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WARNING.1902121248" name="Treat diagnostic &lt;id&gt; as warning (--diag_warning, -pdsw)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WARNING" valueType="stringList">
+									<listOptionValue builtIn="false" value="225"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DISPLAY_ERROR_NUMBER.54474043" name="Emit diagnostic identifier numbers (--display_error_number, -pden)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP.1214479202" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.INCLUDE_PATH.1777244211" name="Add dir to #include search path (--include_path, -I)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.INCLUDE_PATH" valueType="includePath">
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI.204980436" name="Application binary interface (coffabi, eabi) [See 'General' page to edit] (--abi)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.compilerID.ABI.eabi" valueType="enumerated"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__C_SRCS.1536823115" name="C Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__C_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__CPP_SRCS.2029429197" name="C++ Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__CPP_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM_SRCS.1337726292" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM2_SRCS.1746407450" name="Assembly Sources" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.compiler.inputType__ASM2_SRCS"/>
+							</tool>
+							<tool id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerRelease.1237800372" name="C6000 Linker" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exe.linkerRelease">
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.OUTPUT_FILE.279349198" name="Specify output file name (--output_file, -o)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.OUTPUT_FILE" useByScannerDiscovery="false" value="${ProjName}.out" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.MAP_FILE.924667323" name="Input and output sections listed into &lt;file&gt; (--map_file, -m)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.MAP_FILE" value="&quot;${ProjName}.map&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.XML_LINK_INFO.172968405" name="Detailed link information data-base into &lt;file&gt; (--xml_link_info, -xml_link_info)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.XML_LINK_INFO" value="&quot;${ProjName}_linkInfo.xml&quot;" valueType="string"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DISPLAY_ERROR_NUMBER.1809650745" name="Emit diagnostic identifier numbers (--display_error_number)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DISPLAY_ERROR_NUMBER" value="true" valueType="boolean"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP.348638970" name="Wrap diagnostic messages (--diag_wrap)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP" value="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.DIAG_WRAP.off" valueType="enumerated"/>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.SEARCH_PATH.1986386332" name="Add &lt;dir&gt; to library search path (--search_path, -i)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.SEARCH_PATH" valueType="libPaths">
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/lib&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${CG_TOOL_ROOT}/include&quot;"/>
+								</option>
+								<option id="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.LIBRARY.1327881894" name="Include library file or command file as input (--library, -l)" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.linkerID.LIBRARY" valueType="libs">
+									<listOptionValue builtIn="false" value="&quot;rts6600_elf_mt.lib&quot;"/>
+								</option>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD_SRCS.986609065" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD2_SRCS.490802054" name="Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__CMD2_SRCS"/>
+								<inputType id="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__GEN_CMDS.597782436" name="Generated Linker Command Files" superClass="com.ti.ccstudio.buildDefinitions.C6000_7.4.exeLinker.inputType__GEN_CMDS"/>
+							</tool>
+						</toolChain>
+					</folderInfo>
+				</configuration>
+			</storageModule>
+			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+		</cconfiguration>
+	</storageModule>
+	<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
+	<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+		<project id="LiteDemoTest.com.ti.ccstudio.buildDefinitions.C6000.ProjectType.665774709" name="C6000" projectType="com.ti.ccstudio.buildDefinitions.C6000.ProjectType"/>
+	</storageModule>
+	<storageModule moduleId="scannerConfiguration"/>
+	<storageModule moduleId="org.eclipse.cdt.core.language.mapping">
+		<project-mappings>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.asmSource" language="com.ti.ccstudio.core.TIASMLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cHeader" language="com.ti.ccstudio.core.TIGCCLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cSource" language="com.ti.ccstudio.core.TIGCCLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cxxHeader" language="com.ti.ccstudio.core.TIGPPLanguage"/>
+			<content-type-mapping configuration="" content-type="org.eclipse.cdt.core.cxxSource" language="com.ti.ccstudio.core.TIGPPLanguage"/>
+		</project-mappings>
+	</storageModule>
+</cproject>
--- a/pnna/pnna-c6x/project/.launches/LiteDemoTest.launch
+++ b/pnna/pnna-c6x/project/.launches/LiteDemoTest.launch
@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="com.ti.ccstudio.debug.launchType.device.debugging">
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_CPUS_WITH_PROJECT" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;&#10;&lt;cpus_with_project&gt;&#10;&lt;id id=&quot;C6678 Device Functional Simulator, Little Endian_0/TMS320C66x_0&quot; isa=&quot;TMS320C66XX&quot;/&gt;&#10;&lt;/cpus_with_project&gt;"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_DEBUGGER_PROPERTIES.C6678 Device Cycle Approximate Simulator, Little Endian_0/TMS320C66x_0" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot; ?&gt;&#10;&lt;PropertyValues&gt;&#10;&#10;  &lt;property id=&quot;ConnectOnStartup&quot;&gt;&#10;    &lt;curValue&gt;1&lt;/curValue&gt;&#10;  &lt;/property&gt;&#10;&#10;  &lt;property id=&quot;EnableInstalledBreakpoint&quot;&gt;&#10;    &lt;curValue&gt;1&lt;/curValue&gt;&#10;  &lt;/property&gt;&#10;&#10;  &lt;property id=&quot;IgnoreSoftLaunchFailures&quot;&gt;&#10;    &lt;curValue&gt;0&lt;/curValue&gt;&#10;  &lt;/property&gt;&#10;&#10;&lt;/PropertyValues&gt;&#10;"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_DEBUGGER_PROPERTIES.C6678 Device Functional Simulator, Little Endian_0/TMS320C66x_0" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot; ?&gt;&#10;&lt;PropertyValues&gt;&#10;&#10;  &lt;property id=&quot;ConnectOnStartup&quot;&gt;&#10;    &lt;curValue&gt;1&lt;/curValue&gt;&#10;  &lt;/property&gt;&#10;&#10;  &lt;property id=&quot;EnableInstalledBreakpoint&quot;&gt;&#10;    &lt;curValue&gt;1&lt;/curValue&gt;&#10;  &lt;/property&gt;&#10;&#10;  &lt;property id=&quot;IgnoreSoftLaunchFailures&quot;&gt;&#10;    &lt;curValue&gt;0&lt;/curValue&gt;&#10;  &lt;/property&gt;&#10;&#10;&lt;/PropertyValues&gt;&#10;"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_PROGRAM.C6678 Device Cycle Approximate Simulator, Little Endian_0/TMS320C66x_0" value="${build_artifact:LiteDemoTest}"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_PROGRAM.C6678 Device Functional Simulator, Little Endian_0/TMS320C66x_0" value="${build_artifact:LiteDemoTest}"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_PROJECT.C6678 Device Cycle Approximate Simulator, Little Endian_0/TMS320C66x_0" value="LiteDemoTest"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_PROJECT.C6678 Device Functional Simulator, Little Endian_0/TMS320C66x_0" value="LiteDemoTest"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.ATTR_TARGET_CONFIG" value="${target_config_active_default:LiteDemoTest}"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.MRU_PROGRAM.C6678 Device Cycle Approximate Simulator, Little Endian_0/TMS320C66x_0" value="/home/as/workspace_v5_5/LiteDemoTest/Debug/LiteDemoTest.out"/>
+<stringAttribute key="com.ti.ccstudio.debug.debugModel.MRU_PROGRAM.C6678 Device Functional Simulator, Little Endian_0/TMS320C66x_0" value="/home/as/workspace_v5_5/LiteDemoTest/Debug/LiteDemoTest.out"/>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/LiteDemoTest"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="4"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.debug.core.source_locator_id" value="com.ti.ccstudio.debug.sourceLocator"/>
+<stringAttribute key="org.eclipse.debug.core.source_locator_memento" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;sourceLookupDirector&gt;&#10;&lt;sourceContainers duplicates=&quot;false&quot;&gt;&#10;&lt;container memento=&quot;&amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot; standalone=&amp;quot;no&amp;quot;?&amp;gt;&amp;#10;&amp;lt;default/&amp;gt;&amp;#10;&quot; typeId=&quot;org.eclipse.debug.core.containerType.default&quot;/&gt;&#10;&lt;container memento=&quot;&amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot; standalone=&amp;quot;no&amp;quot;?&amp;gt;&amp;#10;&amp;lt;cpuSpecificContainer cpuName=&amp;quot;C6678 Device Cycle Approximate Simulator, Little Endian_0/TMS320C66x_0&amp;quot;&amp;gt;&amp;#10;&amp;lt;childContainerEntry childMemento=&amp;quot;&amp;amp;lt;?xml version=&amp;amp;quot;1.0&amp;amp;quot; encoding=&amp;amp;quot;UTF-8&amp;amp;quot; standalone=&amp;amp;quot;no&amp;amp;quot;?&amp;amp;gt;&amp;amp;#10;&amp;amp;lt;default/&amp;amp;gt;&amp;amp;#10;&amp;quot; childType=&amp;quot;org.eclipse.debug.core.containerType.default&amp;quot;/&amp;gt;&amp;#10;&amp;lt;childContainerEntry childMemento=&amp;quot;&amp;amp;lt;?xml version=&amp;amp;quot;1.0&amp;amp;quot; encoding=&amp;amp;quot;UTF-8&amp;amp;quot; standalone=&amp;amp;quot;no&amp;amp;quot;?&amp;amp;gt;&amp;amp;#10;&amp;amp;lt;project name=&amp;amp;quot;LiteDemoTest&amp;amp;quot; referencedProjects=&amp;amp;quot;true&amp;amp;quot;/&amp;amp;gt;&amp;amp;#10;&amp;quot; childType=&amp;quot;org.eclipse.debug.core.containerType.project&amp;quot;/&amp;gt;&amp;#10;&amp;lt;/cpuSpecificContainer&amp;gt;&amp;#10;&quot; typeId=&quot;com.ti.ccstudio.debug.containerType.cpu.specific&quot;/&gt;&#10;&lt;container memento=&quot;&amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot; standalone=&amp;quot;no&amp;quot;?&amp;gt;&amp;#10;&amp;lt;cpuSpecificContainer cpuName=&amp;quot;C6678 Device Functional Simulator, Little Endian_0/TMS320C66x_0&amp;quot;&amp;gt;&amp;#10;&amp;lt;childContainerEntry childMemento=&amp;quot;&amp;amp;lt;?xml version=&amp;amp;quot;1.0&amp;amp;quot; encoding=&amp;amp;quot;UTF-8&amp;amp;quot; standalone=&amp;amp;quot;no&amp;amp;quot;?&amp;amp;gt;&amp;amp;#10;&amp;amp;lt;default/&amp;amp;gt;&amp;amp;#10;&amp;quot; childType=&amp;quot;org.eclipse.debug.core.containerType.default&amp;quot;/&amp;gt;&amp;#10;&amp;lt;childContainerEntry childMemento=&amp;quot;&amp;amp;lt;?xml version=&amp;amp;quot;1.0&amp;amp;quot; encoding=&amp;amp;quot;UTF-8&amp;amp;quot; standalone=&amp;amp;quot;no&amp;amp;quot;?&amp;amp;gt;&amp;amp;#10;&amp;amp;lt;project name=&amp;amp;quot;LiteDemoTest&amp;amp;quot; referencedProjects=&amp;amp;quot;true&amp;amp;quot;/&amp;amp;gt;&amp;amp;#10;&amp;quot; childType=&amp;quot;org.eclipse.debug.core.containerType.project&amp;quot;/&amp;gt;&amp;#10;&amp;lt;/cpuSpecificContainer&amp;gt;&amp;#10;&quot; typeId=&quot;com.ti.ccstudio.debug.containerType.cpu.specific&quot;/&gt;&#10;&lt;/sourceContainers&gt;&#10;&lt;/sourceLookupDirector&gt;&#10;"/>
+<stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;/&gt;&#10;"/>
+</launchConfiguration>
--- a/pnna/pnna-c6x/project/.project
+++ b/pnna/pnna-c6x/project/.project
@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>project</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
+			<triggers>full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.ti.ccstudio.core.ccsNature</nature>
+		<nature>org.eclipse.cdt.core.cnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
+		<nature>org.eclipse.cdt.core.ccnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+	</natures>
+	<variableList>
+		<variable>
+			<name>ORIGINAL_PROJECT_ROOT</name>
+			<value>file:/D:/workspace_v6/LiteDemoTest134lenet</value>
+		</variable>
+	</variableList>
+</projectDescription>
--- a/pnna/pnna-c6x/project/.settings/org.eclipse.cdt.codan.core.prefs
+++ b/pnna/pnna-c6x/project/.settings/org.eclipse.cdt.codan.core.prefs
@ -0,0 +1,3 @@
+eclipse.preferences.version=1
+inEditor=false
+onBuild=false
--- a/pnna/pnna-c6x/project/.settings/org.eclipse.cdt.debug.core.prefs
+++ b/pnna/pnna-c6x/project/.settings/org.eclipse.cdt.debug.core.prefs
@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+org.eclipse.cdt.debug.core.toggleBreakpointModel=com.ti.ccstudio.debug.CCSBreakpointMarker
--- a/pnna/pnna-c6x/project/.settings/org.eclipse.core.resources.prefs
+++ b/pnna/pnna-c6x/project/.settings/org.eclipse.core.resources.prefs
@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+encoding//Debug/example/postprocess/subdir_rules.mk=UTF-8
+encoding//Debug/example/postprocess/subdir_vars.mk=UTF-8
+encoding//Debug/example/subdir_rules.mk=UTF-8
+encoding//Debug/example/subdir_vars.mk=UTF-8
+encoding//Debug/makefile=UTF-8
+encoding//Debug/objects.mk=UTF-8
+encoding//Debug/sources.mk=UTF-8
+encoding//Debug/subdir_rules.mk=UTF-8
+encoding//Debug/subdir_vars.mk=UTF-8
+pnna=
--- a/pnna/pnna-c6x/project/78E.ccxml
+++ b/pnna/pnna-c6x/project/78E.ccxml
@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<configurations XML_version="1.2" id="configurations_0">
+<configuration XML_version="1.2" id="Blackhawk XDS560v2-USB Mezzanine Emulator_0">
+        <instance XML_version="1.2" desc="Blackhawk XDS560v2-USB Mezzanine Emulator_0" href="connections/BH-XDS560v2-USB_Mezzanine.xml" id="Blackhawk XDS560v2-USB Mezzanine Emulator_0" xml="BH-XDS560v2-USB_Mezzanine.xml" xmlpath="connections"/>
+        <connection XML_version="1.2" id="Blackhawk XDS560v2-USB Mezzanine Emulator_0">
+            <instance XML_version="1.2" href="drivers/tixds560icepick_d.xml" id="drivers" xml="tixds560icepick_d.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds560c66xx.xml" id="drivers" xml="tixds560c66xx.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds560cs_dap.xml" id="drivers" xml="tixds560cs_dap.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds560cortexA15.xml" id="drivers" xml="tixds560cortexA15.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds560csstm.xml" id="drivers" xml="tixds560csstm.xml" xmlpath="drivers"/>
+            <instance XML_version="1.2" href="drivers/tixds560etbcs.xml" id="drivers" xml="tixds560etbcs.xml" xmlpath="drivers"/>
+            <platform XML_version="1.2" id="platform_0">
+                <instance XML_version="1.2" desc="66AK2H12_0" href="devices/66AK2H12.xml" id="66AK2H12_0" xml="66AK2H12.xml" xmlpath="devices"/>
+            <device HW_revision="1" XML_version="1.2" description="66AK2H12" id="66AK2H12_0" partnum="66AK2H12">
+                    <router HW_revision="1.0" XML_version="1.2" description="ICEPick_D Router" id="IcePick_D_0" isa="ICEPICK_D">
+                        <subpath id="subpath_14">
+                            <router HW_revision="1.0" XML_version="1.2" description="CS_DAP Router" id="CS_DAP_0" isa="CS_DAP">
+                                <subpath id="cortex_A15_1">
+                                    <cpu HW_revision="1.0" XML_version="1.2" description="CortexA15 CPU" id="arm_A15_1" isa="CortexA15">
+                                        <property Type="choicelist" Value="1" id="bypass"/>
+                                    </cpu>
+                                </subpath>
+                                <subpath id="cortex_A15_2">
+                                    <cpu HW_revision="1.0" XML_version="1.2" description="CortexA15 CPU" id="arm_A15_2" isa="CortexA15">
+                                        <property Type="choicelist" Value="1" id="bypass"/>
+                                    </cpu>
+                                </subpath>
+                                <subpath id="cortex_A15_3">
+                                    <cpu HW_revision="1.0" XML_version="1.2" description="CortexA15 CPU" id="arm_A15_3" isa="CortexA15">
+                                        <property Type="choicelist" Value="1" id="bypass"/>
+                                    </cpu>
+                                </subpath>
+                            </router>
+                        </subpath>
+                    </router>
+                </device>
+            </platform>
+        </connection>
+    </configuration>
+</configurations>
--- a/pnna/pnna-c6x/project/78E.cmd
+++ b/pnna/pnna-c6x/project/78E.cmd
@ -0,0 +1,54 @@
+/****************************************************************************/
+/*  C6678.cmd                                                               */
+/*  Copyright (c) 2011 Texas Instruments Incorporated                       */
+/*  Author: Rafael de Souza                                                 */
+/*                                                                          */
+/*    Description: This file is a sample linker command file that can be    */
+/*                 used for linking programs built with the C compiler and  */
+/*                 running the resulting .out file on an C6678              */
+/*                 device.  Use it as a guideline.  You will want to        */
+/*                 change the memory layout to match your specific C6xxx    */
+/*                 target system.  You may want to change the allocation    */
+/*                 scheme according to the size of your program.            */
+/*                                                                          */
+/*    Usage:       The map below divides the external memory in segments    */
+/*                 Use the linker option --define=COREn=1                   */
+/*                 Where n is the core number.                              */
+/*                                                                          */
+/****************************************************************************/
+
+-heap  0x4000000
+-stack 0x1000000
+//--entry_point=RST
+MEMORY
+{
+//	vectors:       o = 0x00800000  l = 0x00000200
+//    L2SRAM:        o = 0C000000h   l = 20000h
+//    DDRADD:        o = 0c100000h   l = 100000h      //1MB
+    DDR:		   o = 0x80000000  l = 0x20000000
+}
+
+SECTIONS
+{
+    .text             >  DDR
+    .far              >  DDR
+    .bss              >  DDR
+    .cinit            >  DDR
+    .pinit            >  DDR
+    .cio              >  DDR
+    .const            >  DDR
+    .data             >  DDR
+    .switch           >  DDR
+    .stack            >  DDR
+    .sysmem           >  DDR
+
+    ".DataInDDR"      >  DDR
+
+    .binit         >  DDR
+    .init_array    >  DDR
+    .neardata      >  DDR
+    .fardata       >  DDR
+    .rodata        >  DDR
+
+}
+