接口
@@ -460,7 +454,8 @@ HdfChipDriver需要实现的接口有
在产品配置目录下创建芯片的配置文件//vendor/MyProductVendor/MyProduct/config/wifi/wlan\_chip\_chip\_name.hcs。
-注意： 路径中的vendor\_name、product\_name、chip\_name请替换成实际名称
+注意： 路径中的vendor\_name、product\_name、chip\_name请替换成实际名称。
+
模板如下：
```
@@ -525,7 +520,7 @@ obj-$(CONFIG_DRIVERS_WLAN_XXX) += $(HDF_DEVICE_ROOT)/MySoCVendor/peripheral/buil
当在内核中开启DRIVERS\_WLAN\_XXX开关时，会调用//device/MySoCVendor/peripheral/build/standard/中的makefile。更多详细的开发手册，请参考[WLAN开发](/pages/0006000000)。
-## 开发板移植实例
+### 4. 开发移植示例
-[DAYU开发板](https://gitee.com/openharmony-sig/devboard_device_hihope_build/blob/master/DAYU%20%E5%B9%B3%E5%8F%B0OpenHarmony%20%E9%80%82%E9%85%8D%E6%8C%87%E5%AF%BC%20-202108.pdf)
+开发移植示例请参考[DAYU开发板](https://gitee.com/openharmony-sig/devboard_device_hihope_build/blob/master/DAYU%20%E5%B9%B3%E5%8F%B0OpenHarmony%20%E9%80%82%E9%85%8D%E6%8C%87%E5%AF%BC%20-202108.pdf)。
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\347\247\273\346\244\215/04.\346\240\207\345\207\206\347\263\273\347\273\237\350\212\257\347\211\207\347\247\273\346\244\215\346\214\207\345\257\274/02.\344\270\200\347\247\215\345\277\253\351\200\237\347\247\273\346\244\215OpenHarmonyLinux\345\206\205\346\240\270\347\232\204\346\226\271\346\263\225.md" "b/website/docs/01.\346\226\207\346\241\243/04.\347\247\273\346\244\215/04.\346\240\207\345\207\206\347\263\273\347\273\237\350\212\257\347\211\207\347\247\273\346\244\215\346\214\207\345\257\274/02.\344\270\200\347\247\215\345\277\253\351\200\237\347\247\273\346\244\215OpenHarmonyLinux\345\206\205\346\240\270\347\232\204\346\226\271\346\263\225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..36e2cf3b239d0c3efb9045c315f8e0ecae5acd2b
--- /dev/null
+++ "b/website/docs/01.\346\226\207\346\241\243/04.\347\247\273\346\244\215/04.\346\240\207\345\207\206\347\263\273\347\273\237\350\212\257\347\211\207\347\247\273\346\244\215\346\214\207\345\257\274/02.\344\270\200\347\247\215\345\277\253\351\200\237\347\247\273\346\244\215OpenHarmonyLinux\345\206\205\346\240\270\347\232\204\346\226\271\346\263\225.md"
@@ -0,0 +1,320 @@
+---
+title: 一种快速移植OpenHarmonyLinux内核的方法
+permalink: /pages/00030301
+navbar: true
+sidebar: true
+prev: true
+next: true
+search: true
+article: true
+comment: false
+editLink: false
+date: 2021-12-30 18:31:29
+---
+# 一种快速移植OpenHarmony Linux内核的方法
+
+- [移植概述](#移植概述)
+- [移植到三方芯片平台的整体思路](#移植到三方芯片平台的整体思路)
+ - [内核态层和用户态层](#内核态层和用户态层)
+ - [获得内核态层的两种方法](#获得内核态层的两种方法)
+ - [借助已有Linux内核来移植OpenHarmony的流程](#section1233187263176)
+- [移植到三方芯片平台的步骤](#移植到三方芯片平台的步骤)
+ - [整体构建环境的准备](#整体构建环境的准备)
+ - [内核态基础代码的移植](#内核态基础代码的移植)
+ - [内核态必选特性HDF的移植](#内核态必选特性hdf的移植)
+ - [编译Image](#编译image)
+ - [编译和运行HDF测试用例（可选）](#编译和运行hdf测试用例-可选-)
+
+## 移植概述
+
+
+本文面向希望将OpenHarmony移植到三方芯片平台硬件的开发者，介绍一种借助三方芯片平台自带Linux内核的现有能力，快速移植OpenHarmony到三方芯片平台的方法。
+
+
+## 移植到三方芯片平台的整体思路
+
+
+### 内核态层和用户态层
+
+为了更好的解释整个内核移植，首先需要介绍一些概念：
+
+我们可以把OpenHarmony简单的分为
+
+OpenHarmony = OpenHarmony内核态层 + OpenHarmony用户态层
+
+
+
+其中OpenHarmony内核态层就是上图的紫色部分，可以看到，它主要由内核本身（如Linux Kernel，LiteOS），和一些运行在内核态的一些特性组成，比如HDF等。
+
+而OpenHarmony用户态层，在上图，就是紫色之外的部分。可以看到，由下往上看，它主要由系统服务层，框架层，应用层组成。在这儿我们将这三层整体称为“OpenHarmony用户态层”。
+
+为什么这么区分呢？因为我们这篇文章主要是要讨论如何快速的把OpenHarmony移植到三方芯片平台上。而OpenHarmony的用户态层，整体来说和三方芯片平台的耦合度不高，移植较为方便。而内核态层中的内核本身以及HDF驱动框架等，和三方芯片平台的耦合度较高，是移植的重难点。我们先做这个区分，就是为了先把聚光灯打到我们最需要关注的OpenHarmony内核态层上，开始分析和解题。另外说明，本文只包含Linux内核的快速移植，不包含LiteOS的移植。
+
+
+### 获得内核态层的两种方法
+
+为了表述方便，我们在下文部分地方用“OH”代替“OpenHarmony”。
+
+将OH内核态层继续分解
+
+OH内核态层 = OH Linux内核 + OH内核态特性（可选特性或者必选特性，如必选特性HDF，今后的可选特性HMDFS等）
+
+而OH Linux内核 = 标准LTS Linux内核 + 三方SoC芯片平台代码 + OH内核态基础代码（支撑OH用户态层运行的最基础代码）
+
+因此OH内核态层 = 标准LTS Linux内核 + 三方SoC芯片平台代码 + OH内核态基础代码 + OH内核态特性（如HDF，今后的HMDFS等）
+
+
+
+而将前两项组合，标准LTS Linux 内核 + 三方SoC芯片平台代码，其实就是一个三方Linux内核的基础组成。从上面的推导可以看出，OpenHarmony内核态层其实能够由两种方法得到：
+
+方法一：OH内核态层 = 三方Linux内核 + OH内核态基础代码 + OH内核态特性（如HDF，今后的HMDFS等）
+
+也就是直接借助三方Linux内核，再加上基础OH内核态基础代码、以及HDF等OH内核态特性。
+
+方法二：OH内核态层 = OH Linux内核 + OH内核态特性（如HDF，今后的HMDFS等）
+
+也就是直接采用OH Linux内核，然后再加入OH的其他内核态特性。
+
+当前方法二中OH Linux内核支持的三方芯片平台还不够丰富。为了能够响应三方开发者快速移植OpenHarmony的要求，下文会着重介绍方法一，即借助三方已有的Linux内核，来快速移植OpenHarmony。
+
+
+### 借助已有Linux内核来移植OpenHarmony的流程
+
+
+整个移植流程可以分为三步：
+
+1. 准备整体构建环境，包括将三方芯片平台的现有内核代码拷贝到OpenHarmony的整体编译环境下。
+
+2. OpenHarmony内核态基础代码的移植。
+
+3. OpenHarmony内核态必选特性（如HDF等）的移植。
+
+详细步骤在接下来的章节中介绍。
+
+
+## 移植到三方芯片平台的步骤
+
+下面以树莓派3b (BCM2837) 为例，演示将OpenHarmony移植到树莓派的过程。
+
+
+### 整体构建环境的准备
+
+1. 将三方内核纳入OpenHarmony编译环境。
+
+ 完整编译过一遍标准Hi3516DV300内核之后，clone树莓派内核源码并复制到manifest输出目录下：
+
+ ```
+ export PROJ_ROOT=[OpenHarmony manifest]
+ git clone https://gitee.com/xfan1024/oh-rpi3b-kernel.git
+ cp -r oh-rpi3b-kernel $PROJ_ROOT/out/KERNEL_OBJ/kernel/src_tmp/linux-rpi3b
+ ```
+
+2. 配置树莓派内核编译环境。
+ ```shell
+ # 进入树莓派kernel目录
+ cd out/KERNEL_OBJ/kernel/src_tmp/linux-rpi3b
+
+ # 配置编译环境,使用工程项目自带的clang
+ export PATH=$PROJ_ROOT/prebuilts/clang/ohos/linux-x86_64/llvm/bin:$PROJ_ROOT/prebuilts/gcc/linux-x86/arm/gcc-linaro-7.5.0-arm-linux-gnueabi/bin/:$PATH
+ export MAKE_OPTIONS="ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- CC=clang HOSTCC=clang"
+ export PRODUCT_PATH=vendor/hisilicon/Hi3516DV300
+ ```
+
+3. 注释掉clang不识别的flag。
+
+ PROJ_ROOT/out/KERNEL_OBJ/kernel/src_tmp/linux-rpi3b/arch/arm/Makefile注释掉以下这一行：
+
+ ```makefile
+ KBUILD_CFLAGS +=-fno-omit-frame-pointer -mapcs -mno-sched-prolog
+ ```
+
+
+### 内核态基础代码的移植
+
+目前OpenHarmony内核态的基础代码，主要是日志服务相关。轻量化内核日志服务代码包含：
+
+```
+drivers/staging/hilog
+drivers/staging/hievent
+```
+
+将以上代码，从OpenHarmony内核代码目录kernel/linux/linux-4.19/drivers/staging中，拷贝到out/KERNEL_OBJ/kernel/src_tmp/linux-rpi3b/drivers/staging 下。
+
+在三方内核的drivers/staging/Kconfig文件内增加如下代码：
+```
+source "drivers/staging/hilog/Kconfig"
+
+source "drivers/staging/hievent/Kconfig"
+
+```
+
+在内核config项中打开对应的CONFIG控制宏：CONFIG_HILOG和CONFIG_HIEVENT。
+
+具体日志使用说明请参见：[Hilog_lite组件介绍](https://gitee.com/openharmony/hiviewdfx_hilog_lite/blob/master/README_zh.md)。
+
+
+### 内核态必选特性HDF的移植
+
+1. 打HDF补丁。
+
+ 在Linux内核打HDF补丁时，执行补丁shell脚本合入HDF补丁。
+
+ 1. 配置HDF补丁脚本的三个变量参数。
+ 2. 获取patch_hdf.sh脚本。
+ 3. 执行patch_hdf.sh脚本依次传入三个变量参数。
+
+ patch_hdf.sh脚本三个参数含义为：第一个入参为工程根目录路径，第二入参为内核目录路径，第三个入参为hdf补丁文件。
+
+ ```
+ ./patch_hdf.sh [工程根目录路径] [内核目录路径] [hdf补丁文件]
+ ```
+
+ 以树莓派3b为示例介绍：
+
+ ```
+ # 进入树莓派kernel目录
+ $PROJ_ROOT/drivers/adapter/khdf/linux/patch_hdf.sh \
+ $PROJ_ROOT # 指定工程根目录路径 \
+ $PROJ_ROOT/out/KERNEL_OBJ/kernel/src_tmp/linux-rpi3b # 打补丁的内核目录路径 \
+ $PROJ_ROOT/kernel/linux/patches/linux-4.19/hi3516dv300_patch/hdf.patch # HDF补丁文件
+ ```
+
+2. 配置config。
+
+ 提供HDF基本配置，如果需要其他功能，通过menuconfig打开对应驱动开关即可。
+
+ HDF补丁执行成功后，默认HDF开关是关闭的，打开HDF基本配置选项如下：
+
+ ```
+ CONFIG_DRIVERS_HDF=y
+ CONFIG_HDF_SUPPORT_LEVEL=2
+ CONFIG_DRIVERS_HDF_PLATFORM=y
+ CONFIG_DRIVERS_HDF_PLATFORM_MIPI_DSI=y
+ CONFIG_DRIVERS_HDF_PLATFORM_GPIO=y
+ CONFIG_DRIVERS_HDF_PLATFORM_I2C=y
+ CONFIG_DRIVERS_HDF_PLATFORM_UART=y
+ CONFIG_DRIVERS_HDF_TEST=y
+ ```
+
+ 或者通过menuconfig界面打开HDF相关配置，命令如下：
+
+ ```
+ # 生成.config配置文件
+ make ${MAKE_OPTIONS} rpi3b_oh_defconfig
+
+ # 更改HDF内核配置
+ make ${MAKE_OPTIONS} menuconfig
+ # [*] Device Drivers
+ # [*] HDF driver framework support --->
+ ```
+
+ 配置如下（在Device Drivers -> HDF driver framework support目录下）：
+
+ 
+
+
+### 编译Image
+
+```
+# 执行编译命令
+make ${MAKE_OPTIONS} -j33 zImage
+```
+
+
+### 编译和运行HDF测试用例（可选）
+
+**简介**
+
+HDF（Hardware Driver Foundation)自测试用例，用于测试HDF框架和外设的基本功能，本文主要介绍HDF内核态用例测试方法。
+
+**预置条件**
+
+测试前需要在menuconfig里检查HDF测试开关CONFIG_DRIVERS_HDF_TEST=y，代码全量编译通过。
+
+**用例编译和测试方法**
+
+
+1. 编译hdf测试用例。
+
+2. 用hdc_std工具推送测试文件到设备中。
+
+3. 进入设备data/test目录，执行测试文件即可。
+
+用例编译和测试详细步骤如下：
+
+1. 编译hdf测试用例。
+
+ 编译hdf测试用例命令和文件路径如下：
+
+ ```
+ ./build.sh --product-name Hi3516DV300 --build-target hdf_test
+ ```
+
+ 等待编译完成。
+
+2. 将测试文件移动到目标移植设备上（以树莓派为例）
+
+
+
+ 1. 先在树莓派里新建data/test目录。
+ ```
+ mkdir -p data/test
+ ```
+ 2. 推送依赖库和测试用例到树莓派。
+ ```
+ hdc_std file send XXX\out\{device_name}\hdf\hdf\libhdf_test_common.z.so /system/lib
+ hdc_std file send XXX\out\{device_name}\tests\unittest\hdf\config\hdf_adapter_uhdf_test_config /data/test
+ hdc_std file send XXX\out\{device_name}\tests\unittest\hdf\devmgr\DevMgrTest /data/test
+ hdc_std file send XXX\out\{device_name}\tests\unittest\hdf\osal\OsalTest /data/test
+ hdc_std file send XXX\out\{device_name}\tests\unittest\hdf\sbuf\SbufTest /data/test
+ ```
+ 方法二：移动到储存卡内，启动树莓派之后装载。
+
+ 1. 拔掉树莓派连接电脑的串口、USB线，然后拔下数据卡。
+ 2. 将数据卡插入到电脑的读取口，将编译好的zImage和测试文件夹test/下载到电脑，然后移动到数据卡的根目录下。zImage文件会被替换，请提前做好备份。
+ 3. 最后将数据卡插回树莓派。
+ ```
+ # 让树莓派文件系统读取储存卡根目录
+ mount -t vfat /dev/block/mmcblk0p1 /boot
+ cd /boot/[测试文件目录]
+ # 允许修改系统文件
+ mount -o remount,rw /
+ # 安装测试用库
+ mv libhdf_test_common.z.so /system/lib
+ mkdir /data/test
+ mv * /data/test
+ ```
+
+3. 执行测试
+ 1. 进入目录执行测试文件目录data/test。
+ ```
+ cd /data/test
+ ```
+ 2. 修改文件执行权限。
+ ```
+ chmod 777 hdf_adapter_uhdf_test_config DevMgrTest OsalTest SbufTest
+ ```
+ 3. 开始测试。
+ ```
+ ./hdf_adapter_uhdf_test_config
+ ./DevMgrTest
+ ./OsalTest
+ ./SbufTest
+ ```
+ 4. 如果所有测试文件输出均显示PASSED，那么HDF功能即安装成功。
+
+ 示例：DevMgrTest用例成功结果显示：
+ ```
+ ./DevMgrTest
+ Running main() from gmock_main.cc
+ [==========] Running 1 test from 1 test case.
+ [----------] Global test environment set-up.
+ [----------] 1 test from DevMgrTest
+ [ RUN ] DevMgrTest.DriverLoaderTest_001
+ [ OK ] DevMgrTest.DriverLoaderTest_001 (0 ms)
+ [----------] 1 test from DevMgrTest (0 ms total)
+ [----------] Global test environment tear-down
+ Gtest xml output finished
+ [==========] 1 test from 1 test case ran. (0 ms total)
+ [ PASSED ] 1 test.
+ ```
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/01.GPIO.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/01.GPIO.md"
deleted file mode 100644
index c034f9a5a80805bcb879033266b0ca77059c566e..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/01.GPIO.md"
+++ /dev/null
@@ -1,573 +0,0 @@
----
-title: GPIO
-permalink: /pages/00030100
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# GPIO
-
-- [概述](#section1635911016188)
- - [接口说明](#section17715915181611)
-
-- [使用指导](#section259614242196)
- - [使用流程](#section103477714216)
- - [确定GPIO管脚号](#section370083272117)
- - [使用API操作GPIO管脚](#section13604050132118)
-
-- [使用实例](#section25941262111)
-
-## 概述
-
-GPIO（General-purpose input/output）即通用型输入输出。通常，GPIO控制器通过分组的方式管理所有GPIO管脚，每组GPIO有一个或多个寄存器与之关联，通过读写寄存器完成对GPIO管脚的操作。
-
-GPIO接口定义了操作GPIO管脚的标准方法集合，包括：
-
-- 设置管脚方向： 方向可以是输入或者输出\(暂不支持高阻态\)
-
-- 读写管脚电平值： 电平值可以是低电平或高电平
-- 设置管脚中断服务函数：设置一个管脚的中断响应函数，以及中断触发方式
-- 使能和禁止管脚中断：禁止或使能管脚中断
-
-### 接口说明
-
-**表 1** GPIO驱动API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-GPIO读写
- |
-GpioRead
- |
-读管脚电平值
- |
-
-GpioWrite
- |
-写管脚电平值
- |
-
-GPIO配置
- |
-GpioSetDir
- |
-设置管脚方向
- |
-
-GpioGetDir
- |
-获取管脚方向
- |
-
-GPIO中断设置
- |
-GpioSetIrq
- |
-设置管脚对应的中断服务函数
- |
-
-GpioUnSetIrq
- |
-取消管脚对应的中断服务函数
- |
-
-GpioEnableIrq
- |
-使能管脚中断
- |
-
-GpioDisableIrq
- |
-禁止管脚中断
- |
-
-
-
-
-> **说明：**
->本文涉及的所有接口，仅限内核态使用，不支持在用户态使用。
-
-## 使用指导
-
-### 使用流程
-
-GPIO标准API通过GPIO管脚号来操作指定管脚，使用GPIO的一般流程如[图1](#fig1399416053717)所示。
-
-**图 1** GPIO使用流程图
-
-
-
-
-### 确定GPIO管脚号
-
-不同SOC芯片由于其GPIO控制器型号、参数、以及控制器驱动的不同，GPIO管脚号的换算方式不一样。
-
-- Hi3516DV300
-
- 控制器管理12组GPIO管脚，每组8个。
-
- GPIO号 = GPIO组索引 \(0\~11\) \* 每组GPIO管脚数\(8\) + 组内偏移
-
- 举例：GPIO10\_3的GPIO号 = 10 \* 8 + 3 = 83
-
-- Hi3518EV300
-
- 控制器管理10组GPIO管脚，每组10个。
-
- GPIO号 = GPIO组索引 \(0\~9\) \* 每组GPIO管脚数\(10\) + 组内偏移
-
- 举例：GPIO7\_3的GPIO管脚号 = 7 \* 10 + 3 = 73
-
-
-### 使用API操作GPIO管脚
-
-- 设置GPIO管脚方向
-
- 在进行GPIO管脚读写前，需要先通过如下函数设置GPIO管脚方向：
-
- int32\_t GpioSetDir\(uint16\_t gpio, uint16\_t dir\);
-
- **表 2** GpioSetDir参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
- gpio
- |
- 待设置的GPIO管脚号
- |
-
- dir
- |
- 待设置的方向值
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- 设置成功
- |
-
- 负数
- |
- 设置失败
- |
-
-
-
-
-
-- 读写GPIO管脚
-
- 如果要读取一个GPIO管脚电平，通过以下函数完成：
-
- int32\_t GpioRead\(uint16\_t gpio, uint16\_t \*val\);
-
- **表 3** GpioRead参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
- gpio
- |
- 待读取的GPIO管脚号
- |
-
- val
- |
- 接收读取电平值的指针
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- 读取成功
- |
-
- 负数
- |
- 读取失败
- |
-
-
-
-
- 如果要向GPIO管脚写入电平值，通过以下函数完成：
-
- int32\_t GpioWrite\(uint16\_t gpio, uint16\_t val\);
-
- **表 4** GpioWrite参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
- gpio
- |
- 待写入的GPIO管脚号
- |
-
- val
- |
- 待写入的电平值
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- 写入成功
- |
-
- 负数
- |
- 写入失败
- |
-
-
-
-
- 示例代码：
-
- ```
- int32_t ret;
- uint16_t val;
- /* 将3号GPIO管脚配置为输出 */
- ret = GpioSetDir(3, GPIO_DIR_OUT);
- if (ret != 0) {
- HDF_LOGE("GpioSerDir: failed, ret %d\n", ret);
- return;
- }
- /* 向3号GPIO管脚写入低电平GPIO_VAL_LOW */
- ret = GpioWrite(3, GPIO_VAL_LOW);
- if (ret != 0) {
- HDF_LOGE("GpioWrite: failed, ret %d\n", ret);
- return;
- }
- /* 将6号GPIO管脚配置为输入 */
- ret = GpioSetDir(6, GPIO_DIR_IN);
- if (ret != 0) {
- HDF_LOGE("GpioSetDir: failed, ret %d\n", ret);
- return;
- }
- /* 读取6号GPIO管脚的电平值 */
- ret = GpioRead(6, &val);
- ```
-
-
-- 设置GPIO中断
-
- 如果要为一个GPIO管脚设置中断响应程序，使用如下函数：
-
- int32\_t GpioSetIrq\(uint16\_t gpio, uint16\_t mode, GpioIrqFunc func, void \*arg\);
-
- **表 5** GpioSetIrq参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
- gpio
- |
- GPIO管脚号
- |
-
- mode
- |
- 中断触发模式
- |
-
- func
- |
- 中断服务程序
- |
-
- arg
- |
- 传递给中断服务程序的入参
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- 设置成功
- |
-
- 负数
- |
- 设置失败
- |
-
-
-
-
- > **注意：**
- >同一时间，只能为某个GPIO管脚设置一个中断服务函数，如果重复调用GpioSetIrq函数，则之前设置的中断服务函数会被取代。
-
- 当不再需要响应中断服务函数时，使用如下函数取消中断设置：
-
- int32\_t GpioUnSetIrq\(uint16\_t gpio\);
-
- **表 6** GpioUnSetIrq参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
- gpio
- |
- GPIO管脚号
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- 取消成功
- |
-
- 负数
- |
- 取消失败
- |
-
-
-
-
- 在中断服务程序设置完成后，还需要先通过如下函数使能GPIO管脚的中断：
-
- int32\_t GpioEnableIrq\(uint16\_t gpio\);
-
- **表 7** GpioEnableIrq参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
- gpio
- |
- GPIO管脚号
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- 使能成功
- |
-
- 负数
- |
- 使能失败
- |
-
-
-
-
- > **注意：**
- >必须通过此函数使能管脚中断，之前设置的中断服务函数才能被正确响应。
-
- 如果要临时屏蔽此中断，可以通过如下函数禁止GPIO管脚中断：
-
- int32\_t GpioDisableIrq\(uint16\_t gpio\);
-
- **表 8** GpioDisableIrq参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
- gpio
- |
- GPIO管脚号
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- 禁止成功
- |
-
- 负数
- |
- 禁止失败
- |
-
-
-
-
- 示例代码：
-
- ```
- /* 中断服务函数
- */
- int32_t MyCallBackFunc(uint16_t gpio, void *data)
- {
- HDF_LOGI("%s: gpio:%u interrupt service in! data=%p\n", __func__, gpio, data);
- return 0;
- }
-
- int32_t ret;
- /* 设置中断服务程序为MyCallBackFunc，入参为NULL，中断触发模式为上升沿触发 */
- ret = GpioSetIrq(3, OSAL_IRQF_TRIGGER_RISING, MyCallBackFunc, NULL);
- if (ret != 0) {
- HDF_LOGE("GpioSetIrq: failed, ret %d\n", ret);
- return;
- }
-
- /* 使能3号GPIO管脚中断 */
- ret = GpioEnableIrq(3);
- if (ret != 0) {
- HDF_LOGE("GpioEnableIrq: failed, ret %d\n", ret);
- return;
- }
-
- /* 禁止3号GPIO管脚中断 */
- ret = GpioDisableIrq(3);
- if (ret != 0) {
- HDF_LOGE("GpioDisableIrq: failed, ret %d\n", ret);
- return;
- }
-
- /* 取消3号GPIO管脚中断服务程序 */
- ret = GpioUnSetIrq(3);
- if (ret != 0) {
- HDF_LOGE("GpioUnSetIrq: failed, ret %d\n", ret);
- return;
- }
- ```
-
-
-## 使用实例
-
-本实例程序中，我们将测试一个GPIO管脚的中断触发：为管脚设置中断服务函数，触发方式为边沿触发，然后通过交替写高低电平到管脚，产生电平波动，制造触发条件，观察中断服务函数的执行。
-
-首先需要选取一个空闲的GPIO管脚，本例程基于Hi3516DV300某开发板，GPIO管脚选择GPIO10\_3，换算成GPIO号为83。
-
-读者可以根据自己使用的开发板，参考其原理图，选择一个空闲的GPIO管脚即可。
-
-```
-#include "gpio_if.h"
-#include "hdf_log.h"
-#include "osal_irq.h"
-#include "osal_time.h"
-
-static uint32_t g_irqCnt;
-
-/* 中断服务函数*/
-static int32_t TestCaseGpioIrqHandler(uint16_t gpio, void *data)
-{
- HDF_LOGE("%s: irq triggered! on gpio:%u, data=%p", __func__, gpio, data);
- g_irqCnt++; /* 如果中断服务函数触发执行，则将全局中断计数加1 */
- return GpioDisableIrq(gpio);
-}
-
-/* 测试用例函数 */
-static int32_t TestCaseGpioIrqEdge(void)
-{
- int32_t ret;
- uint16_t valRead;
- uint16_t mode;
- uint16_t gpio = 83; /* 待测试的GPIO管脚号 */
- uint32_t timeout;
-
- /* 将管脚方向设置为输出 */
- ret = GpioSetDir(gpio, GPIO_DIR_OUT);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: set dir fail! ret:%d\n", __func__, ret);
- return ret;
- }
-
- /* 先禁止该管脚中断 */
- ret = GpioDisableIrq(gpio);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: disable irq fail! ret:%d\n", __func__, ret);
- return ret;
- }
-
- /* 为管脚设置中断服务函数，触发模式为上升沿和下降沿共同触发 */
- mode = OSAL_IRQF_TRIGGER_RISING | OSAL_IRQF_TRIGGER_FALLING;
- HDF_LOGE("%s: mode:%0x\n", __func__, mode);
- ret = GpioSetIrq(gpio, mode, TestCaseGpioIrqHandler, NULL);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: set irq fail! ret:%d\n", __func__, ret);
- return ret;
- }
-
- /* 使能此管脚中断 */
- ret = GpioEnableIrq(gpio);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: enable irq fail! ret:%d\n", __func__, ret);
- (void)GpioUnSetIrq(gpio);
- return ret;
- }
-
- g_irqCnt = 0; /* 清除全局计数器 */
- timeout = 0; /* 等待时间清零 */
- /* 等待此管脚中断服务函数触发，等待超时时间为1000毫秒 */
- while (g_irqCnt <= 0 && timeout < 1000) {
- (void)GpioRead(gpio, &valRead);
- (void)GpioWrite(gpio, (valRead == GPIO_VAL_LOW) ? GPIO_VAL_HIGH : GPIO_VAL_LOW);
- HDF_LOGE("%s: wait irq timeout:%u\n", __func__, timeout);
- OsalMDelay(200); /* wait for irq trigger */
- timeout += 200;
- }
- (void)GpioUnSetIrq(gpio);
- return (g_irqCnt > 0) ? HDF_SUCCESS : HDF_FAILURE;
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/02.I2C.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/02.I2C.md"
deleted file mode 100644
index acd20ad2a0e680c4f23d89053237f28e2f556275..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/02.I2C.md"
+++ /dev/null
@@ -1,439 +0,0 @@
----
-title: I2C
-permalink: /pages/00030101
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# I2C
-
-- [概述](#section5361140416)
- - [接口说明](#section459052019177)
-
-- [使用指导](#section1695201514281)
- - [使用流程](#section1338373417288)
- - [打开I2C控制器](#section13751110132914)
- - [进行I2C通信](#section9202183372916)
- - [关闭I2C控制器](#section19481164133018)
-
-- [使用实例](#section5302202015300)
-
-## 概述
-
-- I2C\(Inter Integrated Circuit\)总线是由Philips公司开发的一种简单、双向二线制同步串行总线。
-- I2C以主从方式工作，通常有一个主设备和一个或者多个从设备，主从设备通过SDA\(SerialData\)串行数据线以及SCL\(SerialClock\)串行时钟线两根线相连，如[图1 ](#fig1135561232714)所示。
-
-- I2C数据的传输必须以一个起始信号作为开始条件，以一个结束信号作为传输的停止条件。数据传输以字节为单位，高位在前，逐个bit进行传输。
-- I2C总线上的每一个设备都可以作为主设备或者从设备，而且每一个设备都会对应一个唯一的地址，当主设备需要和某一个从设备通信时，通过广播的方式，将从设备地址写到总线上，如果某个从设备符合此地址，将会发出应答信号，建立传输。
-
-- I2C接口定义了完成I2C传输的通用方法集合，包括：
-
- - I2C控制器管理: 打开或关闭I2C控制器
- - I2C消息传输：通过消息传输结构体数组进行自定义传输
-
- **图 1** I2C物理连线示意图
- 
-
-
-### 接口说明
-
-**表 1** I2C驱动API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-I2C控制器管理接口
- |
-I2cOpen
- |
-打开I2C控制器
- |
-
-I2cClose
- |
-关闭I2C控制器
- |
-
-I2c消息传输接口
- |
-I2cTransfer
- |
-自定义传输
- |
-
-
-
-
-> **说明：**
->本文涉及的所有接口，仅限内核态使用，不支持在用户态使用。
-
-## 使用指导
-
-### 使用流程
-
-使用I2C设备的一般流程如[图2](#fig166181128151112)所示。
-
-**图 2** I2C设备使用流程图
-
-
-
-
-### 打开I2C控制器
-
-在进行I2C通信前，首先要调用I2cOpen打开I2C控制器。
-
-DevHandle I2cOpen\(int16\_t number\);
-
-**表 2** I2cOpen参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-number
- |
-I2C控制器号
- |
-
-返回值
- |
-返回值描述
- |
-
-NULL
- |
-打开I2C控制器失败
- |
-
-设备句柄
- |
-打开的I2C控制器设备句柄
- |
-
-
-
-
-假设系统中存在8个I2C控制器，编号从0到7，那么我们现在获取3号控制器
-
-```
-DevHandle i2cHandle = NULL; /* I2C控制器句柄 /
-
-/* 打开I2C控制器 */
-i2cHandle = I2cOpen(3);
-if (i2cHandle == NULL) {
- HDF_LOGE("I2cOpen: failed\n");
- return;
-}
-```
-
-### 进行I2C通信
-
-消息传输
-
-int32\_t I2cTransfer\(DevHandle handle, struct I2cMsg \*msgs, int16\_t count\);
-
-**表 3** I2cTransfer参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-I2C控制器设备句柄
- |
-
-msgs
- |
-待传输数据的消息结构体数组
- |
-
-count
- |
-消息数组长度
- |
-
-返回值
- |
-返回值描述
- |
-
-正整数
- |
-成功传输的消息结构体数目
- |
-
-负数
- |
-执行失败
- |
-
-
-
-
-I2C传输消息类型为I2cMsg，每个传输消息结构体表示一次读或写，通过一个消息数组，可以执行若干次的读写组合操作。
-
-```
-int32_t ret;
-uint8_t wbuff[2] = { 0x12, 0x13 };
-uint8_t rbuff[2] = { 0 };
-struct I2cMsg msgs[2]; /* 自定义传输的消息结构体数组 */
-msgs[0].buf = wbuff; /* 写入的数据 */
-msgs[0].len = 2; /* 写入数据长度为2 */
-msgs[0].addr = 0x5A; /* 写入设备地址为0x5A */
-msgs[0].flags = 0; /* 传输标记为0，默认为写 */
-msgs[1].buf = rbuff; /* 要读取的数据 */
-msgs[1].len = 2; /* 读取数据长度为2 */
-msgs[1].addr = 0x5A; /* 读取设备地址为0x5A */
-msgs[1].flags = I2C_FLAG_READ /* I2C_FLAG_READ置位 */
-/* 进行一次自定义传输，传输的消息个数为2 */
-ret = I2cTransfer(i2cHandle, msgs, 2);
-if (ret != 2) {
- HDF_LOGE("I2cTransfer: failed, ret %d\n", ret);
- return;
-}
-```
-
-> **注意：**
->- I2cMsg结构体中的设备地址不包含读写标志位，读写信息由flags成员变量的读写控制位传递。
->- 本函数不对消息结构体个数count做限制，其最大个数度由具体I2C控制器决定。
->- 本函数也不对每个消息结构体中的数据长度做限制，同样由具体I2C控制器决定。
->- 本函数可能会引起系统休眠，不允许在中断上下文调用
-
-### 关闭I2C控制器
-
-I2C通信完成之后，需要关闭I2C控制器，关闭函数如下所示：
-
-void I2cClose\(DevHandle handle\);
-
-**表 4** I2cClose参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-I2C控制器设备句柄
- |
-
-
-
-
-```
-I2cClose(i2cHandle); /* 关闭I2C控制器 */
-```
-
-## 使用实例
-
-本例程以操作开发板上的I2C设备为例，详细展示I2C接口的完整使用流程。
-
-本例拟对Hi3516DV300某开发板上TouchPad设备进行简单的寄存器读写访问，基本硬件信息如下：
-
-- SOC：hi3516dv300。
-
-- Touch IC：I2C地址为0x38, IC内部寄存器位宽为1字节。
-
-- 原理图信息：TouchPad设备挂接在3号I2C控制器下；IC的复位管脚为3号GPIO。
-
-本例程首先对Touch IC进行复位操作（开发板上电默认会给TouchIC供电，本例程不考虑供电），然后对其内部寄存器进行随机读写，测试I2C通路是否正常。
-
-> **说明：**
->本例程重点在于展示I2C设备访问流程，并验证I2C通路，所以对于设备寄存器读写值不做关注，读写寄存器导致的行为由设备自身决定。
-
-示例如下：
-
-```
-#include "i2c_if.h" /* I2C标准接口头文件 */
-#include "gpio_if.h" /* GPIO标准接口头文件 */
-#include "hdf_log.h" /* 标准日志打印头文件 */
-#include "osal_io.h" /* 标准IO读写接口头文件 */
-#include "osal_time.h" /* 标准延迟&睡眠接口头文件 */
-
-/* 定义一个表示TP设备的结构体，存储i2c及gpio相关硬件信息 */
-struct TpI2cDevice {
- uint16_t rstGpio; /* 复位管脚 */
- uint16_t busId; /* I2C总线号 */
- uint16_t addr; /* I2C设备地址 */
- uint16_t regLen; /* 寄存器字节宽度 */
- DevHandle i2cHandle; /* I2C控制器句柄 */
-};
-
-/* I2C管脚io配置，需要查阅SOC寄存器手册 */
-#define I2C3_DATA_REG_ADDR 0x112f008c /* 3号I2C控制器SDA管脚配置寄存器地址 */
-#define I2C3_CLK_REG_ADDR 0x112f0090 /* 3号I2C控制器SCL管脚配置寄存器地址 */
-#define I2C_REG_CFG 0x5f1 /* 3号I2C控制器SDA及SCL管脚配置值 */
-
-static void TpSocIoCfg(void)
-{
- /* 将3号I2C控制器对应两个管脚的IO功能设置为I2C */
- OSAL_WRITEL(I2C_REG_CFG, IO_DEVICE_ADDR(I2C3_DATA_REG_ADDR));
- OSAL_WRITEL(I2C_REG_CFG, IO_DEVICE_ADDR(I2C3_CLK_REG_ADDR));
-}
-
-/* 对TP的复位管脚进行初始化， 拉高维持20ms, 再拉底维持50ms，最后再拉高维持20ms， 完成复位动作 */
-static int32_t TestCaseGpioInit(struct TpI2cDevice *tpDevice)
-{
- int32_t ret;
-
- /* 设置复位管脚方向为输出 */
- ret = GpioSetDir(tpDevice->rstGpio, GPIO_DIR_OUT);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: set rst dir fail!:%d", __func__, ret);
- return ret;
- }
-
- ret = GpioWrite(tpDevice->rstGpio, GPIO_VAL_HIGH);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: set rst hight fail!:%d", __func__, ret);
- return ret;
- }
- OsalMSleep(20);
-
- ret = GpioWrite(tpDevice->rstGpio, GPIO_VAL_LOW);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: set rst low fail!:%d", __func__, ret);
- return ret;
- }
- OsalMSleep(50);
-
- ret = GpioWrite(tpDevice->rstGpio, GPIO_VAL_HIGH);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: set rst high fail!:%d", __func__, ret);
- return ret;
- }
- OsalMSleep(20);
-
- return HDF_SUCCESS;
-}
-
-/* 基于I2cTransfer方法封装一个寄存器读写的辅助函数， 通过flag表示读或写 */
-static int TpI2cReadWrite(struct TpI2cDevice *tpDevice, unsigned int regAddr,
- unsigned char *regData, unsigned int dataLen, uint8_t flag)
-{
- int index = 0;
- unsigned char regBuf[4] = {0};
- struct I2cMsg msgs[2] = {0};
-
- /* 单双字节寄存器长度适配 */
- if (tpDevice->regLen == 1) {
- regBuf[index++] = regAddr & 0xFF;
- } else {
- regBuf[index++] = (regAddr >> 8) & 0xFF;
- regBuf[index++] = regAddr & 0xFF;
- }
-
- /* 填充I2cMsg消息结构 */
- msgs[0].addr = tpDevice->addr;
- msgs[0].flags = 0; /* 标记为0，表示写入 */
- msgs[0].len = tpDevice->regLen;
- msgs[0].buf = regBuf;
-
- msgs[1].addr = tpDevice->addr;
- msgs[1].flags = (flag == 1) ? I2C_FLAG_READ : 0; /* 添加读标记位，表示读取 */
- msgs[1].len = dataLen;
- msgs[1].buf = regData;
-
- if (I2cTransfer(tpDevice->i2cHandle, msgs, 2) != 2) {
- HDF_LOGE("%s: i2c read err", __func__);
- return HDF_FAILURE;
- }
- return HDF_SUCCESS;
-}
-
-/* TP寄存器读函数 */
-static inline int TpI2cReadReg(struct TpI2cDevice *tpDevice, unsigned int regAddr,
- unsigned char *regData, unsigned int dataLen)
-{
- return TpI2cReadWrite(tpDevice, regAddr, regData, dataLen, 1);
-}
-
-/* TP寄存器写函数 */
-static inline int TpI2cWriteReg(struct TpI2cDevice *tpDevice, unsigned int regAddr,
- unsigned char *regData, unsigned int dataLen)
-{
- return TpI2cReadWrite(tpDevice, regAddr, regData, dataLen, 0);
-}
-
-/* I2C例程总入口 */
-static int32_t TestCaseI2c(void)
-{
- int32_t i;
- int32_t ret;
- unsigned char bufWrite[7] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xA, 0xB, 0xC };
- unsigned char bufRead[7] = {0};
- static struct TpI2cDevice tpDevice;
-
- /* IO管脚功能配置 */
- TpSocIoCfg();
-
- /* TP设备信息初始化 */
- tpDevice.rstGpio = 3;
- tpDevice.busId = 3;
- tpDevice.addr = 0x38;
- tpDevice.regLen = 1;
- tpDevice.i2cHandle = NULL;
-
- /* GPIO管脚初始化 */
- ret = TestCaseGpioInit(&tpDevice);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: gpio init fail!:%d", __func__, ret);
- return ret;
- }
-
- /* 打开I2C控制器 */
- tpDevice.i2cHandle = I2cOpen(tpDevice.busId);
- if (tpDevice.i2cHandle == NULL) {
- HDF_LOGE("%s: Open I2c:%u fail!", __func__, tpDevice.busId);
- return -1;
- }
-
- /* 向TP-IC的0xD5寄存器连续写7字节数据 */
- ret = TpI2cWriteReg(&tpDevice, 0xD5, bufWrite, 7);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: tp i2c write reg fail!:%d", __func__, ret);
- I2cClose(tpDevice.i2cHandle);
- return -1;
- }
- OsalMSleep(10);
-
- /* 从TP-IC的0xD5寄存器连续读7字节数据 */
- ret = TpI2cReadReg(&tpDevice, 0xD5, bufRead, 7);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: tp i2c read reg fail!:%d", __func__, ret);
- I2cClose(tpDevice.i2cHandle);
- return -1;
- }
-
- HDF_LOGE("%s: tp i2c write&read reg success!", __func__);
- for (i = 0; i < 7; i++) {
- HDF_LOGE("%s: bufRead[%d] = 0x%x", __func__, i, bufRead[i]);
- }
-
- /* 访问完毕关闭I2C控制器 */
- I2cClose(tpDevice.i2cHandle);
- return ret;
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/04.SDIO.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/04.SDIO.md"
deleted file mode 100644
index bf125206a8b6af533bb54b5fb98e3f281f08b8a0..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/04.SDIO.md"
+++ /dev/null
@@ -1,1081 +0,0 @@
----
-title: SDIO
-permalink: /pages/00030103
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# SDIO
-
-- [概述](#section1155271783811)
- - [接口说明](#section08064247248)
-
-- [使用指导](#section1878939192515)
- - [使用流程](#section1490685512255)
- - [打开SDIO控制器](#section10782428132616)
- - [独占HOST](#section11263172312715)
- - [使能SDIO设备](#section17861486271)
- - [注册SDIO中断](#section521213262286)
- - [进行SDIO通信](#section85661522153420)
- - [释放SDIO中断](#section1683449352)
- - [去使能SDIO设备](#section15379324143611)
- - [释放HOST](#section536018263713)
- - [关闭SDIO控制器](#section4752739183716)
-
-- [使用实例](#section376910122382)
-
-## 概述
-
-- SDIO是安全数字输入输出接口（Secure Digital Input and Output）的缩写，是从SD内存卡接口的基础上演化出来的一种外设接口。SDIO接口兼容以前的SD内存卡，并且可以连接支持SDIO接口的设备。
-- SDIO的应用比较广泛，目前，有许多手机都支持SDIO功能，并且很多SDIO外设也被开发出来，使得手机外接外设更加容易。常见的SDIO外设有WLAN、GPS、CAMERA、蓝牙等。
-- SDIO总线有两端，其中一端是主机端（HOST），另一端是设备端（DEVICE）。所有的通信都是由HOST端发出命令开始的，在DEVICE端只要能解析HOST的命令，就可以同HOST进行通信了。SDIO的HOST可以连接多个DEVICE，如下图所示：
-
- - CLK信号：HOST给DEVICE的时钟信号。
- - VDD信号：电源信号。
- - VSS信号：Ground信号。
- - D0-3信号：4条数据线，其中，DAT1信号线复用为中断线，在1BIT模式下DAT0用来传输数据，在4BIT模式下DAT0-DAT3用来传输数据。
- - CMD信号：用于HOST发送命令和DEVICE回复响应。
-
- **图 1** SDIO的HOST-DEVICE连接示意图
-
-
- 
-
-- SDIO接口定义了操作SDIO的通用方法集合，包括打开/关闭SDIO控制器、独占/释放HOST、使能/去使能设备、申请/释放中断、读写、获取/设置公共信息等。
-
-### 接口说明
-
-**表 1** SDIO驱动API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-SDIO设备打开/关闭接口
- |
-SdioOpen
- |
-打开指定总线号的SDIO控制器
- |
-
-SdioClose
- |
-关闭SDIO控制器
- |
-
-SDIO读写接口
- |
-SdioReadBytes
- |
-从指定地址开始，增量读取指定长度的数据
- |
-
-SdioWriteBytes
- |
-从指定地址开始，增量写入指定长度的数据
- |
-
-SdioReadBytesFromFixedAddr
- |
-从固定地址读取指定长度的数据
- |
-
-SdioWriteBytesToFixedAddr
- |
-向固定地址写入指定长度的数据
- |
-
-SdioReadBytesFromFunc0
- |
-从SDIO function 0的指定地址空间读取指定长度的数据
- |
-
-SdioWriteBytesToFunc0
- |
-向SDIO function 0的指定地址空间写入指定长度的数据
- |
-
-SDIO设置块大小接口
- |
-SdioSetBlockSize
- |
-设置块的大小
- |
-
-SDIO获取/设置公共信息接口
- |
-SdioGetCommonInfo
- |
-获取公共信息
- |
-
-SdioSetCommonInfo
- |
-设置公共信息
- |
-
-SDIO刷新数据接口
- |
-SdioFlushData
- |
-刷新数据
- |
-
-SDIO独占/释放HOST接口
- |
-SdioClaimHost
- |
-独占Host
- |
-
-SdioReleaseHost
- |
-释放Host
- |
-
-SDIO使能/去使能功能设备接口
- |
-SdioEnableFunc
- |
-使能SDIO功能设备
- |
-
-SdioDisableFunc
- |
-去使能SDIO功能设备
- |
-
-SDIO申请/释放中断接口
- |
-SdioClaimIrq
- |
-申请中断
- |
-
-SdioReleaseIrq
- |
-释放中断
- |
-
-
-
-
-> **说明：**
->本文涉及的所有接口，目前只支持在内核态使用，不支持在用户态使用。
-
-## 使用指导
-
-### 使用流程
-
-使用SDIO的一般流程如[图2](#fig1343742311264)所示。
-
-**图 2** SDIO使用流程图
-
-
-
-
-### 打开SDIO控制器
-
-在使用SDIO进行通信前，首先要调用SdioOpen获取SDIO控制器的设备句柄，该函数会返回指定总线号的SDIO控制器的设备句柄。
-
-DevHandle SdioOpen\(int16\_t mmcBusNum, struct SdioFunctionConfig \*config\);
-
-**表 2** SdioOpen函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-mmcBusNum
- |
-总线号
- |
-
-config
- |
-SDIO功能配置信息
- |
-
-返回值
- |
-返回值描述
- |
-
-NULL
- |
-获取SDIO控制器的设备句柄失败
- |
-
-设备句柄
- |
-SDIO控制器的设备句柄
- |
-
-
-
-
-打开SDIO控制器的示例如下：
-
-```
-DevHandle handle = NULL;
-struct SdioFunctionConfig config;
-config.funcNr = 1;
-config.vendorId = 0x123;
-config.deviceId = 0x456;
-/* 打开总线号为1的SDIO控制器 */
-handle = SdioOpen(1, &config);
-if (handle == NULL) {
- HDF_LOGE("SdioOpen: failed!\n");
-}
-```
-
-### 独占HOST
-
-获取到SDIO控制器的设备句柄之后，需要先独占HOST才能进行SDIO后续的一系列操作，独占HOST函数如下所示：
-
-void SdioClaimHost\(DevHandle handle\);
-
-**表 3** SdioClaimHost函数的参数描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-
-
-
-独占HOST示例如下：
-
-```
-SdioClaimHost(handle); /* 独占HOST */
-```
-
-### 使能SDIO设备
-
-在访问寄存器之前，需要先使能SDIO设备，使能SDIO设备的函数如下所示：
-
-int32\_t SdioEnableFunc\(DevHandle handle\);
-
-**表 4** SdioEnableFunc函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-SDIO使能成功
- |
-
-负数
- |
-SDIO使能失败
- |
-
-
-
-
-使能SDIO设备的示例如下：
-
-```
-int32_t ret;
-/* 使能SDIO设备 */
-ret = SdioEnableFunc(handle);
-if (ret != 0) {
- HDF_LOGE("SdioEnableFunc: failed, ret %d\n", ret);
-}
-```
-
-### 注册SDIO中断
-
-在通信之前，还需要注册SDIO中断，注册SDIO中断函数如下图所示：
-
-int32\_t SdioClaimIrq\(DevHandle handle, SdioIrqHandler \*handler\);
-
-**表 5** SdioClaimIrq函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-handler
- |
-中断服务函数指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-注册中断成功
- |
-
-负数
- |
-注册中断失败
- |
-
-
-
-
-注册SDIO中的示例如下：
-
-```
-/* 中断服务函数需要根据各自平台的情况去实现 */
-static void SdioIrqFunc(void *data)
-{
- if (data == NULL) {
- HDF_LOGE("SdioIrqFunc: data is NULL.\n");
- return;
- }
- /* 需要开发者自行添加具体实现 */
-}
-
-int32_t ret;
-/* 注册SDIO中断 */
-ret = SdioClaimIrq(handle, SdioIrqFunc);
-if (ret != 0) {
- HDF_LOGE("SdioClaimIrq: failed, ret %d\n", ret);
-}
-```
-
-### 进行SDIO通信
-
-- 向SDIO设备增量写入指定长度的数据
-
-对应的接口函数如下所示：
-
-int32\_t SdioWriteBytes\(DevHandle handle, uint8\_t \*data, uint32\_t addr, uint32\_t size\);
-
-**表 6** SdioWriteBytes函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-data
- |
-待写入数据的指针
- |
-
-addr
- |
-待写入数据的起始地址
- |
-
-size
- |
-待写入数据的长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-SDIO写数据成功
- |
-
-负数
- |
-SDIO写数据失败
- |
-
-
-
-
-向SDIO设备增量写入指定长度的数据的示例如下：
-
-```
-int32_t ret;
-uint8_t wbuff[] = {1,2,3,4,5};
-uint32_t addr = 0x100 + 0x09;
-/* 向SDIO设备起始地址0x109，增量写入5个字节的数据 */
-ret = SdioWriteBytes(handle, wbuff, addr, sizeof(wbuff) / sizeof(wbuff[0]));
-if (ret != 0) {
- HDF_LOGE("SdioWriteBytes: failed, ret %d\n", ret);
-}
-```
-
-- 从SDIO设备增量读取指定长度的数据
-
-对应的接口函数如下所示：
-
-int32\_t SdioReadBytes\(DevHandle handle, uint8\_t \*data, uint32\_t addr, uint32\_t size\);
-
-**表 7** SdioReadBytes函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-data
- |
-接收读取数据的指针
- |
-
-addr
- |
-待读取数据的起始地址
- |
-
-size
- |
-待读取数据的长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-SDIO读数据成功
- |
-
-负数
- |
-SDIO读数据失败
- |
-
-
-
-
-从SDIO设备增量读取指定长度的数据的示例如下：
-
-```
-int32_t ret;
-uint8_t rbuff[5] = {0};
-uint32_t addr = 0x100 + 0x09;
-/* 从SDIO设备起始地址0x109，增量读取5个字节的数据 */
-ret = SdioReadBytes(handle, rbuff, addr, 5);
-if (ret != 0) {
- HDF_LOGE("SdioReadBytes: failed, ret %d\n", ret);
-}
-```
-
-- 向SDIO设备的固定地址写入指定长度的数据
-
- 对应的接口函数如下所示：
-
- int32\_t SdioWriteBytesToFixedAddr\(DevHandle handle, uint8\_t \*data, uint32\_t addr, uint32\_t size, uint32\_t scatterLen\);
-
- **表 8** SdioWriteBytesToFixedAddr函数的参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
|---|
-
- handle
- |
- SDIO控制器的设备句柄
- |
-
- data
- |
- 待写入数据的指针
- |
-
- addr
- |
- 待写入数据的固定地址
- |
-
- size
- |
- 待写入数据的长度
- |
-
- scatterLen
- |
- 集散表的长度。如果该字段不为0，则data为集散表类型。
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- SDIO写数据成功
- |
-
- 负数
- |
- SDIO写数据失败
- |
-
-
-
-
- 向SDIO设备的固定地址写入指定长度的数据的示例如下：
-
- ```
- int32_t ret;
- uint8_t wbuff[] = {1，2，3，4，5};
- uint32_t addr = 0x100 + 0x09;
- /* 向SDIO设备固定地址0x109写入5个字节的数据 */
- ret = SdioWriteBytesToFixedAddr(handle, wbuff, addr, sizeof(wbuff) / sizeof(wbuff[0]), 0);
- if (ret != 0) {
- HDF_LOGE("SdioWriteBytesToFixedAddr: failed, ret %d\n", ret);
- }
- ```
-
-- 从SDIO设备的固定地址读取指定长度的数据
-
- 对应的接口函数如下所示：
-
- int32\_t SdioReadBytesFromFixedAddr\(DevHandle handle, uint8\_t \*data, uint32\_t addr, uint32\_t size, uint32\_t scatterLen\);
-
- **表 9** SdioReadBytesFromFixedAddr函数的参数和返回值描述
-
-
- 参数
- |
- 参数描述
- |
-
|---|
-
- handle
- |
- SDIO控制器的设备句柄
- |
-
- data
- |
- 接收读取数据的指针
- |
-
- addr
- |
- 待读取数据的起始地址
- |
-
- size
- |
- 待读取数据的长度
- |
-
- scatterLen
- |
- 集散表的长度。如果该字段不为0，则data为集散表类型。
- |
-
- 返回值
- |
- 返回值描述
- |
-
- 0
- |
- SDIO读数据成功
- |
-
- 负数
- |
- SDIO读数据失败
- |
-
-
-
-
- 从SDIO设备的固定地址读取指定长度的数据的示例如下：
-
- ```
- int32_t ret;
- uint8_t rbuff[5] = {0};
- uint32_t addr = 0x100 + 0x09;
- /* 从SDIO设备固定地址0x109中读取5个字节的数据 */
- ret = SdioReadBytesFromFixedAddr(handle, rbuff, addr, 5, 0);
- if (ret != 0) {
- HDF_LOGE("SdioReadBytesFromFixedAddr: failed, ret %d\n", ret);
- }
- ```
-
-
-- 向SDIO function 0的指定地址空间写入指定长度的数据
-
-当前只支持写入一个字节的数据，对应的接口函数如下所示：
-
-int32\_t SdioWriteBytesToFunc0\(DevHandle handle, uint8\_t \*data, uint32\_t addr, uint32\_t size\);
-
-**表 10** SdioWriteBytesToFunc0函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-data
- |
-待写入数据的指针
- |
-
-addr
- |
-待写入数据的起始地址
- |
-
-size
- |
-待写入数据的长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-SDIO写数据成功
- |
-
-负数
- |
-SDIO写数据失败
- |
-
-
-
-
-向SDIO function 0的指定地址空间写入指定长度的数据的示例如下：
-
-```
-int32_t ret;
-uint8_t wbuff = 1;
-/* 向SDIO function 0地址0x2中写入1字节的数据 */
-ret = SdioWriteBytesToFunc0(handle, &wbuff, 0x2, 1);
-if (ret != 0) {
- HDF_LOGE("SdioWriteBytesToFunc0: failed, ret %d\n", ret);
-}
-```
-
-- 从SDIO function 0的指定地址空间读取指定长度的数据
-
-当前只支持读取一个字节的数据，对应的接口函数如下所示：
-
-int32\_t SdioReadBytesFromFunc0\(DevHandle handle, uint8\_t \*data, uint32\_t addr, uint32\_t size\);
-
-**表 11** SdioReadBytesFromFunc0函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-data
- |
-接收读取数据的指针
- |
-
-addr
- |
-待读取数据的起始地址
- |
-
-size
- |
-待读取数据的长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-SDIO读数据成功
- |
-
-负数
- |
-SDIO读数据失败
- |
-
-
-
-
-从SDIO function 0的指定地址空间读取指定长度的数据的示例如下：
-
-```
-int32_t ret;
-uint8_t rbuff;
-/* 从SDIO function 0设备地址0x2中读取1字节的数据 */
-ret = SdioReadBytesFromFunc0(handle, &rbuff, 0x2, 1);
-if (ret != 0) {
- HDF_LOGE("SdioReadBytesFromFunc0: failed, ret %d\n", ret);
-}
-```
-
-### 释放SDIO中断
-
-通信完成之后，需要释放SDIO中断，函数如下所示：
-
-int32\_t SdioReleaseIrq\(DevHandle handle\);
-
-**表 12** SdioReleaseIrq函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-释放SDIO中断成功
- |
-
-负数
- |
-释放SDIO中断失败
- |
-
-
-
-
-释放SDIO中断的示例如下：
-
-```
-int32_t ret;
-/* 释放SDIO中断 */
-ret = SdioReleaseIrq(handle);
-if (ret != 0) {
- HDF_LOGE("SdioReleaseIrq: failed, ret %d\n", ret);
-}
-```
-
-### 去使能SDIO设备
-
-通信完成之后，还需要去使能SDIO设备，函数如下所示：
-
-int32\_t SdioDisableFunc\(DevHandle handle\);
-
-**表 13** SdioDisableFunc函数的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-去使能SDIO设备成功
- |
-
-负数
- |
-去使能SDIO设备失败
- |
-
-
-
-
-去使能SDIO设备的示例如下：
-
-```
-int32_t ret;
-/* 去使能SDIO设备 */
-ret = SdioDisableFunc(handle);
-if (ret != 0) {
- HDF_LOGE("SdioDisableFunc: failed, ret %d\n", ret);
-}
-```
-
-### 释放HOST
-
-通信完成之后，还需要释放去HOST，函数如下所示：
-
-void SdioReleaseHost\(DevHandle handle\);
-
-**表 14** SdioReleaseHost函数的参数描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-
-
-
-释放HOST的示例如下：
-
-```
-SdioReleaseHost(handle); /* 释放HOST */
-```
-
-### 关闭SDIO控制器
-
-SDIO通信完成之后，最后需要关闭SDIO控制器，函数如下所示：
-
-void SdioClose\(DevHandle handle\);
-
-该函数会释放掉申请的资源。
-
-**表 15** SdioClose函数的参数描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-SDIO控制器的设备句柄
- |
-
-
-
-
-关闭SDIO控制器的示例如下：
-
-```
-SdioClose(handle); /* 关闭SDIO控制器 */
-```
-
-## 使用实例
-
-SDIO设备完整的使用示例如下所示，首先打开总线号为1的SDIO控制器，然后独占HOST、使能设备、注册中断，接着进行SDIO通信（读写等），通信完成之后，释放中断、去使能设备、释放HOST，最后关闭SDIO控制器。
-
-```
-#include "hdf_log.h"
-#include "sdio_if.h"
-
-#define TEST_FUNC_NUM 1 /* 本测试用例中，使用编号为1的I/O function */
-#define TEST_FBR_BASE_ADDR 0x100 /* 编号为1的I/O function的FBR基地址 */
-#define TEST_ADDR_OFFSET 9 /* 本测试用例中，需要读写的寄存器的地址偏移 */
-#define TEST_DATA_LEN 3 /* 本测试用例中，读写数据的长度 */
-#define TEST_BLOCKSIZE 2 /* 本测试用例中，数据块的大小，单位字节 */
-
-/* 中断服务函数，需要根据各自平台的情况去实现 */
-static void SdioIrqFunc(void *data)
-{
- if (data == NULL) {
- HDF_LOGE("SdioIrqFunc: data is NULL.\n");
- return;
- }
- /* 需要开发者自行添加具体的实现 */
-}
-
-void SdioTestSample(void)
-{
- int32_t ret;
- DevHandle handle = NULL;
- uint8_t data[TEST_DATA_LEN] = {0};
- struct SdioFunctionConfig config = {1, 0x123, 0x456};
- uint8_t val;
- uint32_t addr;
-
- /* 打开总线号为1的SDIO设备 */
- handle = SdioOpen(1, &config);
- if (handle == NULL) {
- HDF_LOGE("SdioOpen: failed!\n");
- return;
- }
- /* 独占HOST */
- SdioClaimHost(handle);
- /* 使能SDIO设备 */
- ret = SdioEnableFunc(handle);
- if (ret != 0) {
- HDF_LOGE("SdioEnableFunc: failed, ret %d\n", ret);
- goto ENABLE_ERR;
- }
- /* 注册中断 */
- ret = SdioClaimIrq(handle, SdioIrqFunc);
- if (ret != 0) {
- HDF_LOGE("SdioClaimIrq: failed, ret %d\n", ret);
- goto CLAIM_IRQ_ERR;
- }
- /* 设置块大小为2字节 */
- ret = SdioSetBlockSize(handle, TEST_BLOCKSIZE);
- if (ret != 0) {
- HDF_LOGE("SdioSetBlockSize: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 从SDIO设备增量地址读取3字节的数据 */
- addr = TEST_FBR_BASE_ADDR * TEST_FUNC_NUM + TEST_ADDR_OFFSET;
- ret = SdioReadBytes(handle, data, addr, TEST_DATA_LEN);
- if (ret != 0) {
- HDF_LOGE("SdioReadBytes: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 向SDIO设备增量地址写入3字节的数据 */
- ret = SdioWriteBytes(handle, data, addr, TEST_DATA_LEN);
- if (ret != 0) {
- HDF_LOGE("SdioWriteBytes: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 从SDIO设备读取1字节的数据 */
- ret = SdioReadBytes(handle, &val, addr, 1);
- if (ret != 0) {
- HDF_LOGE("SdioReadBytes: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 向SDIO设备写入1字节的数据 */
- ret = SdioWriteBytes(handle, &val, addr, 1);
- if (ret != 0) {
- HDF_LOGE("SdioWriteBytes: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 从SDIO设备固定地址读取3字节的数据 */
- ret = SdioReadBytesFromFixedAddr(handle, data, addr, TEST_DATA_LEN, 0);
- if (ret != 0) {
- HDF_LOGE("SdioReadBytesFromFixedAddr: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 向SDIO设备固定地址写入1字节的数据 */
- ret = SdioWriteBytesToFixedAddr(handle, data, addr, 1, 0);
- if (ret != 0) {
- HDF_LOGE("SdioWriteBytesToFixedAddr: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 从SDIO function 0读取1字节的数据 */
- addr = 0x02;
- ret = SdioReadBytesFromFunc0(handle, &val, addr, 1);
- if (ret != 0) {
- HDF_LOGE("SdioReadBytesFromFunc0: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
- /* 向SDIO function 0写入1字节的数据 */
- ret = SdioWriteBytesToFunc0(handle, &val, addr, 1);
- if (ret != 0) {
- HDF_LOGE("SdioWriteBytesToFunc0: failed, ret %d\n", ret);
- goto COMM_ERR;
- }
-COMM_ERR:
- /* 释放中断 */
- ret = SdioReleaseIrq(handle);
- if (ret != 0) {
- HDF_LOGE("SdioReleaseIrq: failed, ret %d\n", ret);
- }
-CLAIM_IRQ_ERR:
- /* 去使能SDIO设备 */
- ret = SdioDisableFunc(handle);
- if (ret != 0) {
- HDF_LOGE("SdioDisableFunc: failed, ret %d\n", ret);
- }
-ENABLE_ERR:
- /* 释放HOST */
- SdioReleaseHost(handle);
- /* 关闭SDIO设备 */
- SdioClose(handle);
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/05.SPI.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/05.SPI.md"
deleted file mode 100644
index 8f778608d39356a933c4d159185736a18c5b1fdc..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/05.SPI.md"
+++ /dev/null
@@ -1,579 +0,0 @@
----
-title: SPI
-permalink: /pages/00030104
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# SPI
-
-- [概述](#section193356154511)
- - [接口说明](#section232141411476)
-
-- [使用指导](#section71363452477)
- - [使用流程](#section32846814820)
- - [获取SPI设备句柄](#section1927265711481)
- - [获取SPI设备属性](#section541133418493)
- - [配置SPI设备属性](#section7870106145010)
- - [进行SPI通信](#section13324155195013)
- - [销毁SPI设备句柄](#section19661632135117)
-
-- [使用实例](#section06541058155120)
-
-## 概述
-
-- SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线。
-- SPI是由Motorola公司开发，用于在主设备和从设备之间进行通信，常用于与闪存、实时时钟、传感器以及模数转换器等进行通信。
-- SPI以主从方式工作，通常有一个主设备和一个或者多个从设备。主设备和从设备之间一般用4根线相连，它们分别是：
- - SCLK – 时钟信号，由主设备产生；
- - MOSI – 主设备数据输出，从设备数据输入；
- - MISO – 主设备数据输入，从设备数据输出；
- - CS – 片选，从设备使能信号，由主设备控制。
-
-
-- 一个主设备和两个从设备的连接示意图如[图1](#fig15227181812587)所示，Device A和Device B共享主设备的SCLK、MISO和MOSI三根引脚，Device A的片选CS0连接主设备的CS0，Device B的片选CS1连接主设备的CS1。
-
-**图 1** SPI主从设备连接示意图。
-
-
-
-
-- SPI通信通常由主设备发起，通过以下步骤完成一次通信：
-
-1. 通过CS选中要通信的从设备，在任意时刻，一个主设备上最多只能有一个从设备被选中。
-2. 通过SCLK给选中的从设备提供时钟信号。
-3. 基于SCLK时钟信号，主设备数据通过MOSI发送给从设备，同时通过MISO接收从设备发送的数据，完成通信。
-
-- 根据SCLK时钟信号的CPOL（Clock Polarity，时钟极性）和CPHA（Clock Phase，时钟相位）的不同组合，SPI有以下四种工作模式：
- - CPOL=0，CPHA=0 时钟信号idle状态为低电平，第一个时钟边沿采样数据。
- - CPOL=0，CPHA=1 时钟信号idle状态为低电平，第二个时钟边沿采样数据。
- - CPOL=1，CPHA=0 时钟信号idle状态为高电平，第一个时钟边沿采样数据。
- - CPOL=1，CPHA=1 时钟信号idle状态为高电平，第二个时钟边沿采样数据。
-
-
-- SPI接口定义了操作SPI设备的通用方法集合，包括：
- - SPI设备句柄获取和释放。
- - SPI读写: 从SPI设备读取或写入指定长度数据。
- - SPI自定义传输：通过消息传输结构体执行任意读写组合过程。
- - SPI设备配置：获取和设置SPI设备属性。
-
-
-> **说明：**
->当前只支持主机模式，不支持从机模式。
-
-### 接口说明
-
-**表 1** SPI驱动API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-SPI设备句柄获取释放接口
- |
-SpiOpen
- |
-获取SPI设备句柄
- |
-
-SpiClose
- |
-释放SPI设备句柄
- |
-
-SPI读写接口
- |
-SpiRead
- |
-读取指定长度的数据
- |
-
-SpiWrite
- |
-写入指定长度的数据
- |
-
-SpiTransfer
- |
-SPI数据传输接口
- |
-
-SPI设备配置接口
-
- |
-SpiSetCfg
- |
-根据指定参数，配置SPI设备
- |
-
-SpiGetCfg
- |
-获取SPI设备配置参数
- |
-
-
-
-
-> **说明：**
->本文涉及的所有接口，仅限内核态使用，不支持在用户态使用。
-
-## 使用指导
-
-### 使用流程
-
-使用SPI的一般流程如[图2](#fig23885455594)所示。
-
-**图 2** SPI使用流程图
-
-
-
-
-### 获取SPI设备句柄
-
-在使用SPI进行通信时，首先要调用SpiOpen获取SPI设备句柄，该函数会返回指定总线号和片选号的SPI设备句柄。
-
-DevHandle SpiOpen\(const struct SpiDevInfo \*info\);
-
-**表 2** SpiOpen参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-info
- |
-SPI设备描述符
- |
-
-返回值
- |
-返回值描述
- |
-
-NULL
- |
-获取SPI设备句柄失败
- |
-
-设备句柄
- |
-对应的SPI设备句柄
- |
-
-
-
-
-假设系统中的SPI设备总线号为0，片选号为0，获取该SPI设备句柄的示例如下：
-
-```
-struct SpiDevInfo spiDevinfo; /* SPI设备描述符 */
-DevHandle spiHandle = NULL; /* SPI设备句柄 */
-spiDevinfo.busNum = 0; /* SPI设备总线号 */
-spiDevinfo.csNum = 0; /* SPI设备片选号 */
-
-/* 获取SPI设备句柄 */
-spiHandle = SpiOpen(&spiDevinfo);
-if (spiHandle == NULL) {
- HDF_LOGE("SpiOpen: failed\n");
- return;
-}
-```
-
-### 获取SPI设备属性
-
-在获取到SPI设备句柄之后，需要配置SPI设备属性。配置SPI设备属性之前，可以先获取SPI设备属性，获取SPI设备属性的函数如下所示：
-
-int32\_t SpiGetCfg\(DevHandle handle, struct SpiCfg \*cfg\);
-
-**表 3** SpiGetCfg参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-SPI设备句柄
- |
-
-cfg
- |
-SPI设备配置参数
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-获取配置成功
- |
-
-负数
- |
-获取配置失败
- |
-
-
-
-
-```
-int32_t ret;
-struct SpiCfg cfg = {0}; /* SPI配置信息*/
-ret = SpiGetCfg(spiHandle, &cfg); /* 获取SPI设备属性 */
-if (ret != 0) {
- HDF_LOGE("SpiGetCfg: failed, ret %d\n", ret);
-}
-```
-
-### 配置SPI设备属性
-
-在获取到SPI设备句柄之后，需要配置SPI设备属性，配置SPI设备属性的函数如下所示：
-
-int32\_t SpiSetCfg\(DevHandle handle, struct SpiCfg \*cfg\);
-
-**表 4** SpiSetCfg参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-SPI设备句柄
- |
-
-cfg
- |
-SPI设备配置参数
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-配置成功
- |
-
-负数
- |
-配置失败
- |
-
-
-
-
-```
-int32_t ret;
-struct SpiCfg cfg = {0}; /* SPI配置信息*/
-cfg.mode = SPI_MODE_LOOP; /* 以回环模式进行通信 */
-cfg.transferMode = PAL_SPI_POLLING_TRANSFER; /* 以轮询的方式进行通信 */
-cfg.maxSpeedHz = 115200; /* 最大传输频率 */
-cfg.bitsPerWord = 8; /* 读写位宽为8个比特 */
-ret = SpiSetCfg(spiHandle, &cfg); /* 配置SPI设备属性 */
-if (ret != 0) {
- HDF_LOGE("SpiSetCfg: failed, ret %d\n", ret);
-}
-```
-
-### 进行SPI通信
-
-- 向SPI设备写入指定长度的数据
-
-如果只向SPI设备写一次数据，则可以通过以下函数完成：
-
-int32\_t SpiWrite\(DevHandle handle, uint8\_t \*buf, uint32\_t len\);
-
-**表 5** SpiWrite参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-SPI设备句柄
- |
-
-buf
- |
-待写入数据的指针
- |
-
-len
- |
-待写入的数据长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-写入成功
- |
-
-负数
- |
-写入失败
- |
-
-
-
-
-```
-int32_t ret;
-uint8_t wbuff[4] = {0x12, 0x34, 0x56, 0x78};
-/* 向SPI设备写入指定长度的数据 */
-ret = SpiWrite(spiHandle, wbuff, 4);
-if (ret != 0) {
- HDF_LOGE("SpiWrite: failed, ret %d\n", ret);
-}
-```
-
-- 从SPI设备读取指定长度的数据
-
-如果只读取一次数据，则可以通过以下函数完成：
-
-int32\_t SpiRead\(DevHandle handle, uint8\_t \*buf, uint32\_t len\);
-
-**表 6** SpiRead参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-SPI设备句柄
- |
-
-buf
- |
-待读取数据的指针
- |
-
-len
- |
-待读取的数据长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-读取成功
- |
-
-负数
- |
-读取失败
- |
-
-
-
-
-```
-int32_t ret;
-uint8_t rbuff[4] = {0};
-/* 从SPI设备读取指定长度的数据 */
-ret = SpiRead(spiHandle, rbuff, 4);
-if (ret != 0) {
- HDF_LOGE("SpiRead: failed, ret %d\n", ret);
-}
-```
-
-- 自定义传输
-
-如果需要发起一次自定义传输，则可以通过以下函数完成：
-
-int32\_t SpiTransfer\(DevHandle handle, struct SpiMsg \*msgs, uint32\_t count\);
-
-**表 7** SpiTransfer参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-SPI设备句柄
- |
-
-msgs
- |
-待传输数据的数组
- |
-
-count
- |
-msgs数组长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-执行成功
- |
-
-负数
- |
-执行失败
- |
-
-
-
-
-```
-int32_t ret;
-uint8_t wbuff[1] = {0x12};
-uint8_t rbuff[1] = {0};
-struct SpiMsg msg; /* 自定义传输的消息*/
-msg.wbuf = wbuff; /* 写入的数据 */
-msg.rbuf = rbuff; /* 读取的数据 */
-msg.len = 1; /* 读取、写入数据的长度都是1 */
-msg.csChange = 1; /* 进行下一次传输前关闭片选 */
-msg.delayUs = 0; /* 进行下一次传输前不进行延时 */
-msg.speed = 115200; /* 本次传输的速度 */
-/* 进行一次自定义传输，传输的msg个数为1 */
-ret = SpiTransfer(spiHandle, &msg, 1);
-if (ret != 0) {
- HDF_LOGE("SpiTransfer: failed, ret %d\n", ret);
-}
-```
-
-### 销毁SPI设备句柄
-
-SPI通信完成之后，需要销毁SPI设备句柄，销毁SPI设备句柄的函数如下所示：
-
-void SpiClose\(DevHandle handle\);
-
-该函数会释放掉申请的资源。
-
-**表 8** SpiClose参数描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-SPI设备句柄
- |
-
-
-
-
-```
-SpiClose(spiHandle); /* 销毁SPI设备句柄 */
-```
-
-## 使用实例
-
-SPI设备完整的使用示例如下所示，首先获取SPI设备句柄，然后配置SPI设备属性，接着调用读写接口进行数据传输，最后销毁SPI设备句柄。
-
-```
-#include "hdf_log.h"
-#include "spi_if.h"
-
-void SpiTestSample(void)
-{
- int32_t ret;
- struct SpiCfg cfg; /* SPI配置信息 */
- struct SpiDevInfo spiDevinfo; /* SPI设备描述符 */
- DevHandle spiHandle = NULL; /* SPI设备句柄 */
- struct SpiMsg msg; /* 自定义传输的消息 */
- uint8_t rbuff[4] = { 0 };
- uint8_t wbuff[4] = { 0x12, 0x34, 0x56, 0x78 };
- uint8_t wbuff2[4] = { 0xa1, 0xb2, 0xc3, 0xd4 };
-
- spiDevinfo.busNum = 0; /* SPI设备总线号 */
- spiDevinfo.csNum = 0; /* SPI设备片选号 */
- spiHandle = SpiOpen(&spiDevinfo); /* 根据spiDevinfo获取SPI设备句柄 */
- if (spiHandle == NULL) {
- HDF_LOGE("SpiOpen: failed\n");
- return;
- }
- /* 获取SPI设备属性 */
- ret = SpiGetCfg(spiHandle, &cfg);
- if (ret != 0) {
- HDF_LOGE("SpiGetCfg: failed, ret %d\n", ret);
- goto err;
- }
- cfg.maxSpeedHz = 115200; /* 将最大时钟频率改为115200 */
- cfg.bitsPerWord = 8; /* 传输位宽改为8比特 */
- /* 配置SPI设备属性 */
- ret = SpiSetCfg(spiHandle, &cfg);
- if (ret != 0) {
- HDF_LOGE("SpiSetCfg: failed, ret %d\n", ret);
- goto err;
- }
- /* 向SPI设备写入指定长度的数据 */
- ret = SpiWrite(spiHandle, wbuff, 4);
- if (ret != 0) {
- HDF_LOGE("SpiWrite: failed, ret %d\n", ret);
- goto err;
- }
- /* 从SPI设备读取指定长度的数据 */
- ret = SpiRead(spiHandle, rbuff, 4);
- if (ret != 0) {
- HDF_LOGE("SpiRead: failed, ret %d\n", ret);
- goto err;
- }
- msg.wbuf = wbuff2; /* 写入的数据 */
- msg.rbuf = rbuff; /* 读取的数据 */
- msg.len = 4; /* 读取写入数据的长度为4 */
- msg.csChange = 1; /* 进行下一次传输前关闭片选 */
- msg.delayUs = 0; /* 进行下一次传输前不进行延时 */
- msg.speed = 115200; /* 本次传输的速度 */
- /* 进行一次自定义传输，传输的msg个数为1 */
- ret = SpiTransfer(spiHandle, &msg, 1);
- if (ret != 0) {
- HDF_LOGE("SpiTransfer: failed, ret %d\n", ret);
- goto err;
- }
-err:
- /* 销毁SPI设备句柄 */
- SpiClose(spiHandle);
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/06.UART.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/06.UART.md"
deleted file mode 100644
index 288e4579f47180e8b9a930c747af91b4f7cdf7d0..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/06.UART.md"
+++ /dev/null
@@ -1,695 +0,0 @@
----
-title: UART
-permalink: /pages/00030105
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# UART
-
-- [概述](#section833012453535)
- - [接口说明](#section1680292311549)
-
-- [使用指导](#section12779050105412)
- - [使用流程](#section1858116395510)
- - [获取UART设备句柄](#section124512065617)
- - [UART设置波特率](#section86881004579)
- - [UART获取波特率](#section897032965712)
- - [UART设置设备属性](#section129141884588)
- - [UART获取设备属性](#section18689637165812)
- - [设置UART传输模式](#section72713435918)
- - [向UART设备写入指定长度的数据](#section128001736155919)
- - [从UART设备中读取指定长度的数据](#section92851601604)
- - [销毁UART设备句柄](#section1477410521406)
-
-- [使用实例](#section35404241311)
-
-## 概述
-
-- UART是通用异步收发传输器（Universal Asynchronous Receiver/Transmitter）的缩写，是通用串行数据总线，用于异步通信。该总线双向通信，可以实现全双工传输。
-- UART应用比较广泛，常用于输出打印信息，也可以外接各种模块，如GPS、蓝牙等。
-- 两个UART设备的连接示意图如下，UART与其他模块一般用2线（图1）或4线（图2）相连，它们分别是：
- - TX：发送数据端，和对端的RX相连；
- - RX：接收数据端，和对端的TX相连；
- - RTS：发送请求信号，用于指示本设备是否准备好，可接受数据，和对端CTS相连；
- - CTS：允许发送信号，用于判断是否可以向对端发送数据，和对端RTS相连；
-
- **图 1** 2线UART设备连接示意图
-
-
- 
-
- **图 2** 4线UART设备连接示意图
-
-
- 
-
-
-- UART通信之前，收发双方需要约定好一些参数：波特率、数据格式（起始位、数据位、校验位、停止位）等。通信过程中，UART通过TX发送给对端数据，通过RX接收对端发送的数据。当UART接收缓存达到预定的门限值时，RTS变为不可发送数据，对端的CTS检测到不可发送数据，则停止发送数据。
-- UART接口定义了操作UART端口的通用方法集合，包括获取、释放设备句柄、读写数据、获取和设置波特率、获取和设置设备属性。
-
-### 接口说明
-
-**表 1** UART驱动API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-UART获取/释放设备句柄
-
- |
-UartOpen
- |
-UART获取设备句柄
- |
-
-UartClose
- |
-UART释放设备句柄
- |
-
-UART读写接口
-
- |
-UartRead
- |
-从UART设备中读取指定长度的数据
- |
-
-UartWrite
- |
-向UART设备中写入指定长度的数据
- |
-
-UART获取/设置波特率接口
- |
-UartGetBaud
- |
-UART获取波特率
- |
-
-UartSetBaud
- |
-UART设置波特率
- |
-
-UART获取/设置设备属性
-
- |
-UartGetAttribute
- |
-UART获取设备属性
- |
-
-UartSetAttribute
- |
-UART设置设备属性
- |
-
-UART设置传输模式
- |
-UartSetTransMode
- |
-UART设置传输模式
- |
-
-
-
-
-> **说明：**
->本文涉及的所有接口，仅限内核态使用，不支持在用户态使用。
-
-## 使用指导
-
-### 使用流程
-
-使用UART的一般流程如[图3](#fig1852173020185)所示。
-
-**图 3** UART使用流程图
-
-
-
-
-### 获取UART设备句柄
-
-在使用UART进行通信时，首先要调用UartOpen获取UART设备句柄，该函数会返回指定端口号的UART设备句柄。
-
-DevHandle UartOpen\(uint32\_t port\);
-
-**表 2** UartOpen参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-port
- |
-UART设备号
- |
-
-返回值
- |
-返回值描述
- |
-
-NULL
- |
-获取UART设备句柄失败
- |
-
-设备句柄
- |
-UART设备句柄
- |
-
-
-
-
-假设系统中的UART端口号为3，获取该UART设备句柄的示例如下：
-
-```
-DevHandle handle = NULL; /* UART设备句柄 */
-uint32_t port = 3; /* UART设备端口号 */
-handle = UartOpen(port);
-if (handle == NULL) {
- HDF_LOGE("UartOpen: failed!\n");
- return;
-}
-```
-
-### UART设置波特率
-
-在通信之前，需要设置UART的波特率，设置波特率的函数如下所示：
-
-int32\_t UartSetBaud\(DevHandle handle, uint32\_t baudRate\);
-
-**表 3** UartSetBaud参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-baudRate
- |
-待设置的波特率值
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-UART设置波特率成功
- |
-
-负数
- |
-UART设置波特率失败
- |
-
-
-
-
-假设需要设置的UART波特率为9600，设置波特率的实例如下：
-
-```
-int32_t ret;
-/* 设置UART波特率 */
-ret = UartSetBaud(handle, 9600);
-if (ret != 0) {
- HDF_LOGE("UartSetBaud: failed, ret %d\n", ret);
-}
-```
-
-### UART获取波特率
-
-设置UART的波特率后，可以通过获取波特率接口来查看UART当前的波特率，获取波特率的函数如下所示：
-
-int32\_t UartGetBaud\(DevHandle handle, uint32\_t \*baudRate\);
-
-**表 4** UartGetBaud参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-baudRate
- |
-接收波特率值的指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-UART获取波特率成功
- |
-
-负数
- |
-UART获取波特率失败
- |
-
-
-
-
-获取波特率的实例如下：
-
-```
-int32_t ret;
-uint32_t baudRate;
-/* 获取UART波特率 */
-ret = UartGetBaud(handle, &baudRate);
-if (ret != 0) {
- HDF_LOGE("UartGetBaud: failed, ret %d\n", ret);
-}
-```
-
-### UART设置设备属性
-
-在通信之前，需要设置UART的设备属性，设置设备属性的函数如下图所示：
-
-int32\_t UartSetAttribute\(DevHandle handle, struct UartAttribute \*attribute\)；
-
-**表 5** UartSetAttribute参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-attribute
- |
-待设置的设备属性
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-UART设置设备属性成功
- |
-
-负数
- |
-UART设置设备属性失败
- |
-
-
-
-
-设置UART的设备属性的实例如下：
-
-```
-int32_t ret;
-struct UartAttribute attribute;
-attribute.dataBits = UART_ATTR_DATABIT_7; /* UART传输数据位宽，一次传输7个bit */
-attribute.parity = UART_ATTR_PARITY_NONE; /* UART传输数据无校检 */
-attribute.stopBits = UART_ATTR_STOPBIT_1; /* UART传输数据停止位为1位 */
-attribute.rts = UART_ATTR_RTS_DIS; /* UART禁用RTS */
-attribute.cts = UART_ATTR_CTS_DIS; /* UART禁用CTS */
-attribute.fifoRxEn = UART_ATTR_RX_FIFO_EN; /* UART使能RX FIFO */
-attribute.fifoTxEn = UART_ATTR_TX_FIFO_EN; /* UART使能TX FIFO */
-/* 设置UART设备属性 */
-ret = UartSetAttribute(handle, &attribute);
-if (ret != 0) {
- HDF_LOGE("UartSetAttribute: failed, ret %d\n", ret);
-}
-```
-
-### UART获取设备属性
-
-设置UART的设备属性后，可以通过获取设备属性接口来查看UART当前的设备属性，获取设备属性的函数如下图所示：
-
-int32\_t UartGetAttribute\(DevHandle handle, struct UartAttribute \*attribute\);
-
-**表 6** UartGetAttribute参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-attribute
- |
-接收UART设备属性的指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-UART获取设备属性成功
- |
-
-负数
- |
-UART获取设备属性失败
- |
-
-
-
-
-获取UART的设备属性的实例如下：
-
-```
-int32_t ret;
-struct UartAttribute attribute;
-/* 获取UART设备属性 */
-ret = UartGetAttribute(handle, &attribute);
-if (ret != 0) {
- HDF_LOGE("UartGetAttribute: failed, ret %d\n", ret);
-}
-```
-
-### 设置UART传输模式
-
-在通信之前，需要设置UART的传输模式，设置传输模式的函数如下图所示：
-
-int32\_t UartSetTransMode\(DevHandle handle, enum UartTransMode mode\)；
-
-**表 7** UartSetTransMode参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-mode
- |
-待设置的传输模式，
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-UART设置传输模式成功
- |
-
-负数
- |
-UART设置传输模式失败
- |
-
-
-
-
-假设需要设置的UART传输模式为UART\_MODE\_RD\_BLOCK，设置传输模式的实例如下：
-
-```
-int32_t ret;
-/* 设置UART传输模式 */
-ret = UartSetTransMode(handle, UART_MODE_RD_BLOCK);
-if (ret != 0) {
- HDF_LOGE("UartSetTransMode: failed, ret %d\n", ret);
-}
-```
-
-### 向UART设备写入指定长度的数据
-
-对应的接口函数如下所示：
-
-int32\_t UartWrite\(DevHandle handle, uint8\_t \*data, uint32\_t size\);
-
-**表 8** UartWrite参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-data
- |
-待写入数据的指针
- |
-
-size
- |
-待写入数据的长度
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-UART写数据成功
- |
-
-负数
- |
-UART写数据失败
- |
-
-
-
-
-写入指定长度数据的实例如下：
-
-```
-int32_t ret;
-uint8_t wbuff[5] = {1, 2, 3, 4, 5};
-/* 向UART设备写入指定长度的数据 */
-ret = UartWrite(handle, wbuff, 5);
-if (ret != 0) {
- HDF_LOGE("UartWrite: failed, ret %d\n", ret);
-}
-```
-
-### 从UART设备中读取指定长度的数据
-
-对应的接口函数如下所示：
-
-int32\_t UartRead\(DevHandle handle, uint8\_t \*data, uint32\_t size\);
-
-**表 9** UartRead参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-data
- |
-接收读取数据的指针
- |
-
-size
- |
-待读取数据的长度
- |
-
-返回值
- |
-返回值描述
- |
-
-非负数
- |
-UART读取到的数据长度
- |
-
-负数
- |
-UART读取数据失败
- |
-
-
-
-
-读取指定长度数据的实例如下：
-
-```
-int32_t ret;
-uint8_t rbuff[5] = {0};
-/* 从UART设备读取指定长度的数据 */
-ret = UartRead(handle, rbuff, 5);
-if (ret < 0) {
- HDF_LOGE("UartRead: failed, ret %d\n", ret);
-}
-```
-
-> **注意：**
->UART返回值为非负值，表示UART读取成功。若返回值等于0，表示UART无有效数据可以读取。若返回值大于0，表示实际读取到的数据长度，该长度小于或等于传入的参数size的大小，并且不超过当前正在使用的UART控制器规定的最大单次读取数据长度的值。
-
-### 销毁UART设备句柄
-
-UART通信完成之后，需要销毁UART设备句柄，函数如下所示：
-
-void UartClose\(DevHandle handle\);
-
-该函数会释放申请的资源。
-
-**表 10** UartClose参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-UART设备句柄
- |
-
-
-
-
-销毁UART设备句柄的实例如下：
-
-```
-UartClose(handle); /* 销毁UART设备句柄 *
-```
-
-## 使用实例
-
-UART设备完整的使用示例如下所示，首先获取UART设备句柄，接着设置波特率、设备属性和传输模式，之后进行UART通信，最后销毁UART设备句柄。
-
-```
-#include "hdf_log.h"
-#include "uart_if.h"
-
-void UartTestSample(void)
-{
- int32_t ret;
- uint32_t port;
- DevHandle handle = NULL;
- uint8_t wbuff[5] = { 1, 2, 3, 4, 5 };
- uint8_t rbuff[5] = { 0 };
- struct UartAttribute attribute;
- attribute.dataBits = UART_ATTR_DATABIT_7; /* UART传输数据位宽，一次传输7个bit */
- attribute.parity = UART_ATTR_PARITY_NONE; /* UART传输数据无校检 */
- attribute.stopBits = UART_ATTR_STOPBIT_1; /* UART传输数据停止位为1位 */
- attribute.rts = UART_ATTR_RTS_DIS; /* UART禁用RTS */
- attribute.cts = UART_ATTR_CTS_DIS; /* UART禁用CTS */
- attribute.fifoRxEn = UART_ATTR_RX_FIFO_EN; /* UART使能RX FIFO */
- attribute.fifoTxEn = UART_ATTR_TX_FIFO_EN; /* UART使能TX FIFO */
- /* UART设备端口号，要填写实际平台上的端口号 */
- port = 1;
- /* 获取UART设备句柄 */
- handle = UartOpen(port);
- if (handle == NULL) {
- HDF_LOGE("UartOpen: failed!\n");
- return;
- }
- /* 设置UART波特率为9600 */
- ret = UartSetBaud(handle, 9600);
- if (ret != 0) {
- HDF_LOGE("UartSetBaud: failed, ret %d\n", ret);
- goto _ERR;
- }
- /* 设置UART设备属性 */
- ret = UartSetAttribute(handle, &attribute);
- if (ret != 0) {
- HDF_LOGE("UartSetAttribute: failed, ret %d\n", ret);
- goto _ERR;
- }
- /* 设置UART传输模式为非阻塞模式 */
- ret = UartSetTransMode(handle, UART_MODE_RD_NONBLOCK);
- if (ret != 0) {
- HDF_LOGE("UartSetTransMode: failed, ret %d\n", ret);
- goto _ERR;
- }
- /* 向UART设备写入5字节的数据 */
- ret = UartWrite(handle, wbuff, 5);
- if (ret != 0) {
- HDF_LOGE("UartWrite: failed, ret %d\n", ret);
- goto _ERR;
- }
- /* 从UART设备读取5字节的数据 */
- ret = UartRead(handle, rbuff, 5);
- if (ret < 0) {
- HDF_LOGE("UartRead: failed, ret %d\n", ret);
- goto _ERR;
- }
-_ERR:
- /* 销毁UART设备句柄 */
- UartClose(handle);
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/08.MIPI_DSI.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/08.MIPI_DSI.md"
deleted file mode 100644
index a73a199e47b8da9995664526a44cf84415dc2041..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/02.\345\271\263\345\217\260\351\251\261\345\212\250\345\274\200\345\217\221/08.MIPI_DSI.md"
+++ /dev/null
@@ -1,567 +0,0 @@
----
-title: MIPI_DSI
-permalink: /pages/00030107
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# MIPI DSI
-
-- [概述](#section16806142183217)
- - [接口说明](#section129611916132011)
-
-- [使用指导](#section037231715335)
- - [使用流程](#section49299119344)
- - [获取MIPI-DSI操作句柄](#section5126155683811)
- - [MIPI-DSI相应配置](#section201164274344)
- - [发送/回读控制指令](#section199401342173415)
- - [释放MIPI-DSI操作句柄](#section161011610357)
-
-- [使用实例](#section17470126123520)
-
-## 概述
-
-- DSI（Display Serial Interface）是由移动行业处理器接口联盟（Mobile Industry Processor Interface \(MIPI\) Alliance）制定的规范，旨在降低移动设备中显示控制器的成本。它以串行的方式发送像素数据或指令给外设\(通常是LCD或者类似的显示设备\)，或从外设中读取状态信息或像素信息；它定义了主机、图像数据源和目标设备之间的串行总线和通信协议。
-
-- MIPI-DSI具备高速模式和低速模式两种工作模式，全部数据通道都可以用于单向的高速传输，但只有第一个数据通道才可用于低速双向传输，从属端的状态信息、像素等是通过该数据通道返回。时钟通道专用于在高速传输数据的过程中传输同步时钟信号。
-- 图1显示了简化的DSI接口。从概念上看，符合DSI的接口与基于DBI-2和DPI-2标准的接口具有相同的功能。它向外围设备传输像素或命令数据，并且可以从外围设备读取状态或像素信息。主要区别在于，DSI对所有像素数据、命令和事件进行序列化，而在传统接口中，这些像素数据、命令和事件通常需要附加控制信号才能在并行数据总线上传输。
-
- **图 1** DSI发送、接收接口
- 
-
-
-### 接口说明
-
-**表 1** MIPI-DSI API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-设置/获取当前MIPI-DSI相关配置
- |
-MipiDsiSetCfg
- |
-设置MIPI-DSI相关配置
- |
-
-MipiDsiGetCfg
- |
-获取当前MIPI-DSI相关配置
- |
-
-获取/释放MIPI-DSI操作句柄
- |
-MipiDsiOpen
- |
-获取MIPI-DSI操作句柄
- |
-
-MipiDsiClose
- |
-释放MIPI-DSI操作句柄
- |
-
-设置MIPI-DSI进入Low power模式/High speed模式
- |
-MipiDsiSetLpMode
- |
-设置MIPI-DSI进入Low power模式
- |
-
-MipiDsiSetHsMode
- |
-设置MIPI-DSI进入High speed模式
- |
-
-MIPI-DSI发送/回读指令
- |
-MipiDsiTx
- |
-MIPI-DSI发送相应指令的接口
- |
-
-MipiDsiRx
- |
-MIPI-DSI按期望长度回读的接口
- |
-
-
-
-
-> **说明：**
->本文涉及的所有接口，仅限内核态使用，不支持在用户态使用
-
-## 使用指导
-
-### 使用流程
-
-使用MIPI-DSI的一般流程如[图2](#fig99821771782)所示。
-
-**图 2** MIPI-DSI使用流程图
-
-
-
-
-### 获取MIPI-DSI操作句柄
-
-在进行MIPI-DSI进行通信前，首先要调用MipiDsiOpen获取操作句柄，该函数会返回指定通道ID的操作句柄。
-
-DevHandle MipiDsiOpen\(uint8\_t id\);
-
-**表 2** MipiDsiOpen的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-id
- |
-MIPI DSI通道ID
- |
-
-返回值
- |
-返回值描述
- |
-
-NULL
- |
-获取失败
- |
-
-设备句柄
- |
-获取到指令通道的操作句柄, 类型为DevHandle
- |
-
-
-
-
-假设系统中的MIPI-DSI通道为0，获取该通道操作句柄的示例如下：
-
-```
-DevHandle mipiDsiHandle = NULL; /* 设备句柄 */
-chnId = 0; /* MIPI-DSI通道ID */
-
-/* 获取操作句柄 */
-mipiDsiHandle = MipiDsiOpen(chnId);
-if (mipiDsiHandle == NULL) {
- HDF_LOGE("MipiDsiOpen: failed\n");
- return;
-}
-```
-
-### MIPI-DSI相应配置
-
-- 写入MIPI-DSI配置
-
-int32\_t MipiDsiSetCfg\(DevHandle handle, struct MipiCfg \*cfg\);
-
-**表 3** MipiDsiSetCfg的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-操作句柄
- |
-
-cfg
- |
-MIPI-DSI相应配置buf 指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-设置成功
- |
-
-负数
- |
-设置失败
- |
-
-
-
-
-```
-int32_t ret;
-struct MipiCfg cfg = {0};
-
-/* 当前对接的屏幕配置如下 */
-cfg.lane = DSI_4_LANES;
-cfg.mode = DSI_CMD_MODE;
-cfg.burstMode = VIDEO_NON_BURST_MODE_SYNC_EVENTS;
-cfg.format = FORMAT_RGB_24_BIT;
-cfg.pixelClk = 174;
-cfg.phyDataRate = 384;
-cfg.timingInfo.hsaPixels = 50;
-cfg.timingInfo.hbpPixels = 55;
-cfg.timingInfo.hlinePixels = 1200;
-cfg.timingInfo.yResLines = 1800;
-cfg.timingInfo.vbpLines = 33;
-cfg.timingInfo.vsaLines = 76;
-cfg.timingInfo.vfpLines = 120;
-cfg.timingInfo.xResPixels = 1342;
-/* 写入配置数据 */
-ret = MipiDsiSetCfg(g_handle, &cfg);
-if (ret != 0) {
- HDF_LOGE("%s: SetMipiCfg fail! ret=%d\n", __func__, ret);
- return -1;
-}
-```
-
-- 获取当前MIPI-DSI的配置
-
-int32\_t MipiDsiGetCfg\(DevHandle handle, struct MipiCfg \*cfg\);
-
-**表 4** MipiDsiGetCfg的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-操作句柄
- |
-
-cfg
- |
-MIPI-DSI相应配置buf 指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-获取成功
- |
-
-负数
- |
-获取失败
- |
-
-
-
-
-```
-int32_t ret;
-struct MipiCfg cfg;
-memset(&cfg, 0, sizeof(struct MipiCfg));
-ret = MipiDsiGetCfg(g_handle, &cfg);
-if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: GetMipiCfg fail!\n", __func__);
- return HDF_FAILURE;
-}
-```
-
-### 发送/回读控制指令
-
-- 发送指令
-
-int32\_t MipiDsiTx\(PalHandle handle, struct DsiCmdDesc \*cmd\);
-
-**表 5** MipiDsiTx的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-操作句柄
- |
-
-cmd
- |
-需要发送的指令数据指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-发送成功
- |
-
-负数
- |
-发送失败
- |
-
-
-
-
-```
-int32_t ret;
-struct DsiCmdDesc *cmd = OsalMemCalloc(sizeof(struct DsiCmdDesc));
-if (cmd == NULL) {
- return HDF_FAILURE;
-}
-cmd->dtype = DTYPE_DCS_WRITE;
-cmd->dlen = 1;
-cmd->payload = OsalMemCalloc(sizeof(uint8_t));
-if (cmd->payload == NULL) {
- HdfFree(cmd);
- return HDF_FAILURE;
-}
-*(cmd->payload) = DTYPE_GEN_LWRITE;
-MipiDsiSetLpMode(mipiHandle);
-ret = MipiDsiTx(mipiHandle, cmd);
-MipiDsiSetHsMode(mipiHandle);
-if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: PalMipiDsiTx fail! ret=%d\n", __func__, ret);
- HdfFree(cmd->payload);
- HdfFree(cmd);
- return HDF_FAILURE;
-}
-HdfFree(cmd->payload);
-HdfFree(cmd);
-```
-
-- 回读指令
-
-int32\_t MipiDsiRx\(DevHandle handle, struct DsiCmdDesc \*cmd, uint32\_t readLen, uint8\_t \*out\);
-
-**表 6** MipiDsiRx的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-操作句柄
- |
-
-cmd
- |
-需要回读的指令数据指针
- |
-
-readLen
- |
-期望回读的数据长度
- |
-
-out
- |
-回读的数据buf指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-获取成功
- |
-
-负数
- |
-获取失败
- |
-
-
-
-
-```
-int32_t ret;
-uint8_t readVal = 0;
-
-struct DsiCmdDesc *cmdRead = OsalMemCalloc(sizeof(struct DsiCmdDesc));
-if (cmdRead == NULL) {
- return HDF_FAILURE;
-}
-cmdRead->dtype = DTYPE_DCS_READ;
-cmdRead->dlen = 1;
-cmdRead->payload = OsalMemCalloc(sizeof(uint8_t));
-if (cmdRead->payload == NULL) {
- HdfFree(cmdRead);
- return HDF_FAILURE;
-}
-*(cmdRead->payload) = DDIC_REG_STATUS;
-MipiDsiSetLpMode(g_handle);
-ret = MipiDsiRx(g_handle, cmdRead, sizeof(readVal), &readVal);
-MipiDsiSetHsMode(g_handle);
-if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: MipiDsiRx fail! ret=%d\n", __func__, ret);
- HdfFree(cmdRead->payload);
- HdfFree(cmdRead);
- return HDF_FAILURE;
-}
-HdfFree(cmdRead->payload);
-HdfFree(cmdRead);
-```
-
-### 释放MIPI-DSI操作句柄
-
-MIPI-DSI使用完成之后，需要释放操作句柄，释放句柄的函数如下所示：
-
-void MipiDsiClose\(DevHandle handle\);
-
-该函数会释放掉由MipiDsiOpen申请的资源。
-
-**表 7** MipiDsiClose的参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-MIPI-DSI操作句柄
- |
-
-
-
-
-```
-MipiDsiClose(mipiHandle); /* 释放掉MIPI-DSI操作句柄 */
-```
-
-## 使用实例
-
-MIPI-DSI完整的使用示例如下所示：
-
-```
-#include "hdf.h"
-#include "mipi_dsi_if.h"
-
-void PalMipiDsiTestSample(void)
-{
- uint8_t chnId;
- int32_t ret;
- DevHandle handle = NULL;
-
- /* 设备通道编号 */
- chnId = 0;
- /* 获取操作句柄 */
- handle = MipiDsiOpen(chnId);
- if (handle == NULL) {
- HDF_LOGE("MipiDsiOpen: failed!\n");
- return;
- }
- /* 配置相应参数 */
- struct MipiCfg cfg = {0};
- cfg.lane = DSI_4_LANES;
- cfg.mode = DSI_CMD_MODE;
- cfg.burstMode = VIDEO_NON_BURST_MODE_SYNC_EVENTS;
- cfg.format = FORMAT_RGB_24_BIT;
- cfg.pixelClk = 174;
- cfg.phyDataRate = 384;
- cfg.timingInfo.hsaPixels = 50;
- cfg.timingInfo.hbpPixels = 55;
- cfg.timingInfo.hlinePixels = 1200;
- cfg.timingInfo.yResLines = 1800;
- cfg.timingInfo.vbpLines = 33;
- cfg.timingInfo.vsaLines = 76;
- cfg.timingInfo.vfpLines = 120;
- cfg.timingInfo.xResPixels = 1342;
- /* 写入配置数据 */
- ret = MipiDsiSetCfg(g_handle, &cfg);
- if (ret != 0) {
- HDF_LOGE("%s: SetMipiCfg fail! ret=%d\n", __func__, ret);
- return;
- }
- /* 发送PANEL初始化指令 */
- struct DsiCmdDesc *cmd = OsalMemCalloc(sizeof(struct DsiCmdDesc));
- if (cmd == NULL) {
- return;
- }
- cmd->dtype = DTYPE_DCS_WRITE;
- cmd->dlen = 1;
- cmd->payload = OsalMemCalloc(sizeof(uint8_t));
- if (cmd->payload == NULL) {
- HdfFree(cmd);
- return;
- }
- *(cmd->payload) = DTYPE_GEN_LWRITE;
- MipiDsiSetLpMode(mipiHandle);
- ret = MipiDsiTx(mipiHandle, cmd);
- MipiDsiSetHsMode(mipiHandle);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: MipiDsiTx fail! ret=%d\n", __func__, ret);
- HdfFree(cmd->payload);
- HdfFree(cmd);
- return;
- }
- HdfFree(cmd->payload);
- HdfFree(cmd);
- /* 回读panel状态寄存器 */
- uint8_t readVal = 0;
- struct DsiCmdDesc *cmdRead = OsalMemCalloc(sizeof(struct DsiCmdDesc));
- if (cmdRead == NULL) {
- return;
- }
- cmdRead->dtype = DTYPE_DCS_READ;
- cmdRead->dlen = 1;
- cmdRead->payload = OsalMemCalloc(sizeof(uint8_t));
- if (cmdRead->payload == NULL) {
- HdfFree(cmdRead);
- return;
- }
- *(cmdRead->payload) = DDIC_REG_STATUS;
- MipiDsiSetLpMode(g_handle);
- ret = MipiDsiRx(g_handle, cmdRead, sizeof(readVal), &readVal);
- MipiDsiSetHsMode(g_handle);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: MipiDsiRx fail! ret=%d\n", __func__, ret);
- HdfFree(cmdRead->payload);
- HdfFree(cmdRead);
- return;
- }
- HdfFree(cmdRead->payload);
- HdfFree(cmdRead);
- /* 释放MIPI DSI设备句柄 */
- MipiDsiClose(handle);
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/03.\345\271\263\345\217\260\351\251\261\345\212\250\344\275\277\347\224\250/03.RTC.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/03.\345\271\263\345\217\260\351\251\261\345\212\250\344\275\277\347\224\250/03.RTC.md"
deleted file mode 100644
index 260db1a2f842b56d37d5a8663875849a14dcf4ab..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/03.\345\271\263\345\217\260\351\251\261\345\212\250\344\275\277\347\224\250/03.RTC.md"
+++ /dev/null
@@ -1,957 +0,0 @@
----
-title: RTC
-permalink: /pages/00030202
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# RTC
-
-- [概述](#section104842041574)
- - [接口说明](#section3373340142215)
-
-- [使用指导](#section20636145604113)
- - [使用流程](#section16919828134215)
- - [创建RTC设备句柄](#section1131212144310)
- - [销毁RTC设备句柄](#section10744117144314)
- - [注册RTC定时报警回调函数](#section14839440184320)
- - [操作RTC](#section161927578433)
-
-- [使用实例](#section1186111020456)
-
-## 概述
-
-RTC\(real-time clock\)为操作系统中的实时时钟设备，为操作系统提供精准的实时时间和定时报警功能。当设备下电后，通过外置电池供电，RTC继续记录操作系统时间；设备上电后，RTC提供实时时钟给操作系统，确保断电后系统时间的连续性。
-
-### 接口说明
-
-**表 1** RTC设备API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-RTC句柄操作
- |
-RtcOpen
- |
-获取RTC设备驱动句柄
- |
-
-RtcClose
- |
-释放RTC设备驱动句柄
- |
-
-RTC时间操作接口
- |
-RtcReadTime
- |
-读RTC时间信息，包括年、月、星期、日、时、分、秒、毫秒
- |
-
-RtcWriteTime
- |
-写RTC时间信息，包括年、月、星期、日、时、分、秒、毫秒
- |
-
-RTC报警操作接口
- |
-RtcReadAlarm
- |
-读RTC报警时间信息
- |
-
-RtcWriteAlarm
- |
-写RTC报警时间信息
- |
-
-RtcRegisterAlarmCallback
- |
-注册报警超时回调函数
- |
-
-RtcAlarmInterruptEnable
- |
-使能/去使能RTC报警中断
- |
-
-RTC配置操作
- |
-RtcGetFreq
- |
-读RTC外接晶振频率
- |
-
-RtcSetFreq
- |
-配置RTC外接晶振频率
- |
-
-RtcReset
- |
-RTC复位
- |
-
-读写用户定义寄存器
- |
-RtcReadReg
- |
-读用户自定义寄存器
- |
-
-RtcWriteReg
- |
-写用户自定义寄存器
- |
-
-
-
-
-> **说明：**
->本文涉及的所有接口，仅限内核态使用，不支持在用户态使用。
-
-## 使用指导
-
-### 使用流程
-
-在操作系统启动过程中，驱动管理模块根据配置文件加载RTC驱动，RTC驱动会检测RTC器件并初始化驱动。
-
-使用RTC设备的一般流程如[图1](#fig166181128151112)所示。
-
-**图 1** RTC设备使用流程图
-
-
-
-
-### 创建RTC设备句柄
-
-RTC驱动加载成功后，驱动开发者使用驱动框架提供的查询接口并调用RTC设备驱动接口。
-
-> **说明：**
->当前操作系统支持一个RTC设备。
-
-DevHandle RtcOpen\(void\);
-
-**表 2** RtcOpen参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-void
- |
-NA
- |
-
-返回值
- |
-返回值描述
- |
-
-handle
- |
-操作成功返回 指针类型
- |
-
-NULL
- |
-操作失败
- |
-
-
-
-
-```
-DevHandle handle = NULL;
-
-/* 获取RTC句柄 */
-handle = RtcOpen();
-if (handle == NULL) {
- /* 错误处理 */
-}
-```
-
-### 销毁RTC设备句柄
-
-销毁RTC设备句柄，系统释放对应的资源。
-
-void RtcClose\(DevHandle handle\);
-
-**表 3** RtcClose参数描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-
-
-
-```
-/* 销毁RTC句柄 */
-RtcClose(handle);
-```
-
-### 注册RTC定时报警回调函数
-
-系统启动后需要注册RTC定时报警回调函数，报警超时后触发回调函数。
-
-int32\_t RtcRegisterAlarmCallback\(DevHandle handle, enum RtcAlarmIndex alarmIndex, RtcAlarmCallback cb\);
-
-**表 4** RtcRegisterAlarmCallback参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-RTC设备句柄
- |
-
-alarmIndex
- |
-报警索引
- |
-
-cb
- |
-定时报警回调函数
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-注册RTC\_ALARM\_INDEX\_A的定时报警处理函数， 示例如下：
-
-```
-/* 用户注册RTC定时报警回调函数的方法 */
-int32_t RtcAlarmACallback(enum RtcAlarmIndex alarmIndex)
-{
- if (alarmIndex == RTC_ALARM_INDEX_A) {
- /* 报警A的处理 */
- } else if (alarmIndex == RTC_ALARM_INDEX_B) {
- /* 报警B的处理 */
- } else {
- /* 错误处理 */
- }
- return 0;
-}
-int32_t ret;
-/* 注册报警A的定时回调函数 */
-ret = RtcRegisterAlarmCallback(handle, RTC_ALARM_INDEX_A, RtcAlarmACallback);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-### 操作RTC
-
-- 读取RTC时间。
-
-系统从RTC读取时间信息，包括年、月、星期、日、时、分、秒、毫秒，则可以通过以下函数完成：
-
-int32\_t RtcReadTime\(DevHandle handle, struct RtcTime \*time\);
-
-**表 5** RtcReadTime参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-time
- |
-RTC读取时间信息，包括年、月、星期、日、时、分、秒、毫秒
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-struct RtcTime tm;
-
-/* 系统从RTC读取时间信息 */
-ret = RtcReadTime(handle, &tm);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 设置RTC时间
-
-设置RTC时间，则可以通过以下函数完成:
-
-int32\_t RtcWriteTime\(DevHandle handle, struct RtcTime \*time\);
-
-**表 6** RtcWriteTime参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-time
- |
-写RTC时间信息，包括年、月、星期、日、时、分、秒、毫秒
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-> **说明：**
->RTC起始时间为UTC 1970/01/01 Thursday 00:00:00，年的最大取值按照用户器件手册要求计算配置，星期不用配置。
-
-```
-int32_t ret;
-struct RtcTime tm;
-
-/* 设置RTC时间为 UTC 2020/01/01 00:59:00 .000 */
-tm.year = 2020;
-tm.month = 01;
-tm.day = 01;
-tm.hour= 00;
-tm.minute = 59;
-tm.second = 00;
-tm.millisecond = 0;
-/* 写RTC时间信息 */
-ret = RtcWriteTime(handle, &tm);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 读取RTC报警时间
-
-如果需要读取定时报警时间，则可以通过以下函数完成：
-
-int32\_t RtcReadAlarm\(DevHandle handle, enum RtcAlarmIndex alarmIndex, struct RtcTime \*time\);
-
-**表 7** RtcReadAlarm参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-alarmIndex
- |
-报警索引
- |
-
-time
- |
-RTC报警时间信息，包括年、月、星期、日、时、分、秒、毫秒
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-struct RtcTime alarmTime;
-
-/* 读RTC_ALARM_INDEX_A索引的RTC定时报警时间信息 */
-ret = RtcReadAlarm(handle, RTC_ALARM_INDEX_A, &alarmTime);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 设置RTC报警时间
-
-根据报警索引设置RTC报警时间，通过以下函数完成：
-
-int32\_t RtcWriteAlarm\(DevHandle handle, enum RtcAlarmIndex alarmIndex, struct RtcTime \*time\);
-
-**表 8** RtcWriteAlarm参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-alarmIndex
- |
-报警索引
- |
-
-time
- |
-RTC报警时间信息，包括年、月、星期、日、时、分、秒、毫秒
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-> **说明：**
->RTC起始时间为UTC 1970/01/01 Thursday 00:00:00，年的最大取值按照用户器件手册要求计算配置，星期不用配置。
-
-```
-int32_t ret;
-struct RtcTime alarmTime;
-
-/* 设置RTC报警时间为2020/01/01 00:59:59 .000 */
-alarmTime.year = 2020;
-alarmTime.month = 01;
-alarmTime.day = 01;
-alarmTime.hour = 00;
-alarmTime.minute = 59;
-alarmTime.second = 59;
-alarmTime.millisecond = 0;
-/* 设置RTC_ALARM_INDEX_A索引的定时报警时间 */
-ret = RtcWriteAlarm(handle, RTC_ALARM_INDEX_A, &alarmTime);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 设置定时报警中断使能或去使能
-
-在启动报警操作前，需要先设置报警中断使能，报警超时后会触发告警回调函数，可以通过以下函数完成：
-
-int32\_t RtcAlarmInterruptEnable\(DevHandle handle, enum RtcAlarmIndex alarmIndex, uint8\_t enable\);
-
-**表 9** RtcAlarmInterruptEnable参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-alarmIndex
- |
-报警索引
- |
-
-enable
- |
-RTC报警中断配置，1：使能，0：去使能
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-
-/* 设置RTC报警中断使能 */
-ret = RtcAlarmInterruptEnable(handle, RTC_ALARM_INDEX_A, 1);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 读取RTC外频
-
-读取RTC外接晶体振荡频率，可以通过以下函数完成：
-
-int32\_t RtcGetFreq\(DevHandle handle, uint32\_t \*freq\);
-
-**表 10** RtcGetFreq参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-freq
- |
-RTC的外接晶体振荡频率，单位（HZ）
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-uint32_t freq = 0;
-
-/* 读取RTC外接晶体振荡频率 */
-ret = RtcGetFreq(handle, &freq);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 配置RTC外频
-
-配置RTC外接晶体振荡频率，可以通过以下函数完成：
-
-int32\_t RtcSetFreq\(DevHandle handle, uint32\_t freq\);
-
-**表 11** RtcSetFreq参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-freq
- |
-RTC的外接晶体振荡频率，单位（HZ）
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-uint32_t freq = 32768; /* 32768 Hz */
-
-/* 设置RTC外接晶体振荡频率，注意按照器件手册要求配置RTC外频 */
-ret = RtcSetFreq(handle, freq);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 复位RTC
-
-复位RTC，复位RTC后各配置寄存器恢复默认值，可以通过以下函数完成：
-
-int32\_t RtcReset\(DevHandle handle\);
-
-**表 12** RtcReset参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-
-/* 复位RTC，复位RTC后各配置寄存器恢复默认值 */
-ret = RtcReset(handle);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 读取RTC自定义寄存器配置
-
-按照用户定义的寄存器索引，读取对应的寄存器配置，一个索引对应一字节的配置值，通过以下函数完成：
-
-int32\_t RtcReadReg\(DevHandle handle, uint8\_t usrDefIndex, uint8\_t \*value\);
-
-**表 13** RtcReadReg参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-usrDefIndex
- |
-用户定义的寄存器对应索引
- |
-
-value
- |
-寄存器值
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-uint8_t usrDefIndex = 0; /* 定义0索引对应用户定义的第一个寄存器*/
-uint8_t value = 0;
-
-/* 按照用户定义的寄存器索引，读取对应的寄存器配置，一个索引对应一字节的配置值 */
-ret = RtcReadReg(handle, usrDefIndex, &value);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-- 设置RTC自定义寄存器配置
-
-按照用户定义的寄存器索引，设置对应的寄存器配置，一个索引对应一字节的配置值，通过以下函数完成：
-
-int32\_t RtcWriteReg\(DevHandle handle, uint8\_t usrDefIndex, uint8\_t value\);
-
-**表 14** RtcWriteReg参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
-handle
- |
-RTC设备句柄
- |
-
-usrDefIndex
- |
-用户定义的寄存器对应索引
- |
-
-value
- |
-寄存器值
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-操作成功
- |
-
-负数
- |
-操作失败
- |
-
-
-
-
-```
-int32_t ret;
-uint8_t usrDefIndex = 0; /* 定义0索引对应用户定义第一个寄存器*/
-uint8_t value = 0x10;
-
-/* 按照用户的定义的寄存器索引，设置对应的寄存器配置，一个索引对应一字节的配置值 */
-ret = RtcWriteReg(handle, usrDefIndex, value);
-if (ret != 0) {
- /* 错误处理 */
-}
-```
-
-## 使用实例
-
-本实例提供RTC接口的完整使用流程：
-
-1. 系统启动，驱动管理模块会识别系统当前的RTC器件;
-2. 驱动管理模块完成RTC设备的初始化和设备创建；
-3. 用户通过不同API，对该RTC设备进行对应的操作；
-4. 关闭RTC设备，释放设备资源。
-
-示例如下：
-
-```
-#include "rtc_if.h"
-int32_t RtcAlarmACallback(enum RtcAlarmIndex alarmIndex)
-{
- if (alarmIndex == RTC_ALARM_INDEX_A) {
- /* 报警A的处理 */
- printf("RTC Alarm A callback function\n\r");
- } else if (alarmIndex == RTC_ALARM_INDEX_B) {
- /* 报警B的处理 */
- printf("RTC Alarm B callback function\n\r");
- } else {
- /* 错误处理 */
- }
- return 0;
-}
-
-void RtcTestSample(void)
-{
- int32_t ret;
- struct RtcTime tm;
- struct RtcTime alarmTime;
- uint32_t freq;
- DevHandle handle = NULL;
-
- /* 获取RTC设备句柄 */
- handle = RtcOpen();
- if (handle == NULL) {
- /* 错误处理 */
- }
- /* 注册报警A的定时回调函数 */
- ret = RtcRegisterAlarmCallback(handle, RTC_ALARM_INDEX_A, RtcAlarmACallback);
- if (ret != 0) {
- /* 错误处理 */
- }
- /* 设置RTC外接晶体振荡频率，注意按照器件手册要求配置RTC外频 */
- freq = 32768; /* 32768 Hz */
- ret = RtcSetFreq(handle, freq);
- if (ret != 0) {
- /* 错误处理 */
- }
- /* 设置RTC报警中断使能 */
- ret = RtcAlarmInterruptEnable(handle, RTC_ALARM_INDEX_A, 1);
- if (ret != 0) {
- /* 错误处理 */
- }
- /* 设置RTC时间为2020/01/01 00:00:10 .990 */
- tm.year = 2020;
- tm.month = 01;
- tm.day = 01;
- tm.hour= 0;
- tm.minute = 0;
- tm.second = 10;
- tm.millisecond = 990;
- /* 写RTC时间信息 */
- ret = RtcWriteTime(handle, &tm);
- if (ret != 0) {
- /* 错误处理 */
- }
- /* 设置RTC报警时间为2020/01/01 00:00:30 .100 */
- alarmTime.year = 2020;
- alarmTime.month = 01;
- alarmTime.day = 01;
- alarmTime.hour = 0;
- alarmTime.minute = 0;
- alarmTime.second = 30;
- alarmTime.millisecond = 100;
- /* 设置RTC_ALARM_INDEX_A索引定时报警时间信息, 定时时间到后会打印"RTC Alarm A callback function" */
- ret = RtcWriteAlarm(handle, RTC_ALARM_INDEX_A, &alarmTime);
- if (ret != 0) {
- /* 错误处理 */
- }
-
- /* 读取RTC实时时间 */
- ret = RtcReadTime(handle, &tm);
- if (ret != 0) {
- /* 错误处理 */
- }
- sleep(5)
- printf("RTC read time:\n\r");
- printf("year-month-date-weekday hour:minute:second .millisecond %04u-%02u-%02u-%u %02u:%02u:%02u .%03u",
- tm.year, tm.month, tm.day, tm.weekday, tm.hour, tm.minute, tm.second, tm.millisecond);
- /* 销毁RTC设备句柄 */
- RtcClose(handle);
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/03.\345\271\263\345\217\260\351\251\261\345\212\250\344\275\277\347\224\250/07.WATCHDOG.md" "b/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/03.\345\271\263\345\217\260\351\251\261\345\212\250\344\275\277\347\224\250/07.WATCHDOG.md"
deleted file mode 100644
index 46d23a00e7700bda5d0568f014bd1d52d26e0a88..0000000000000000000000000000000000000000
--- "a/website/docs/01.\346\226\207\346\241\243/04.\350\256\276\345\244\207\345\274\200\345\217\221-\351\251\261\345\212\250/03.\345\271\263\345\217\260\351\251\261\345\212\250\344\275\277\347\224\250/07.WATCHDOG.md"
+++ /dev/null
@@ -1,570 +0,0 @@
----
-title: WATCHDOG
-permalink: /pages/00030206
-navbar: true
-sidebar: true
-prev: true
-next: true
-search: true
-article: true
-comment: false
-editLink: false
-date: 2021-12-30 12:57:43
----
-# WATCHDOG
-
-- [概述](#section14918241977)
- - [接口说明](#section20177131219818)
-
-- [使用指导](#section10103184312813)
- - [使用流程](#section10181195910815)
- - [打开看门狗设备](#section66089201107)
- - [获取看门狗状态](#section786624341011)
- - [设置超时时间](#section182386137111)
- - [获取超时时间](#section1883310371114)
- - [启动看门狗](#section82501405123)
- - [喂狗](#section3547530101211)
- - [停止看门狗](#section944595841217)
- - [关闭看门狗设备](#section96561824121311)
-
-- [使用实例](#section1724514523135)
-
-## 概述
-
-看门狗（watchdog），又叫看门狗计时器（watchdog timer），是一种硬件的计时设备，当系统的主程序发生某些错误时，导致未及时清除看门狗计时器的计时值，这时看门狗计时器就会对系统发出复位信号，使系统从悬停状态恢复到正常运作状态。
-
-### 接口说明
-
-**表 1** 看门狗 API接口功能介绍
-
-
-功能分类
- |
-接口名
- |
-描述
- |
-
|---|
-
-打开/关闭看门狗
- |
-WatchdogOpen
- |
-打开看门狗设备
- |
-
-WatchdogClose
- |
-关闭看门狗设备
- |
-
-启动/停止看门狗
- |
-WatchdogStart
- |
-启动看门狗
- |
-
-WatchdogStop
- |
-停止看门狗
- |
-
-设置/获取超时时间
- |
-WatchdogSetTimeout
- |
-设置看门狗超时时间
- |
-
-WatchdogGetTimeout
- |
-获取看门狗超时时间
- |
-
-获取看门狗状态
- |
-WatchdogGetStatus
- |
-获取看门狗状态
- |
-
-清除看门狗定时器
- |
-WatchdogFeed
- |
-清除看门狗定时器(喂狗)
- |
-
-
-
-
-> **说明：**
->本文涉及看门狗的所有接口，仅限内核态使用，不支持在用户态使用。
-
-## 使用指导
-
-### 使用流程
-
-使用看门狗的一般流程如[图1](#fig19134125410189)所示。
-
-**图 1** 看门狗使用流程图
-
-
-
-
-### 打开看门狗设备
-
-在操作看门狗之前，需要使用WatchdogOpen打开一个看门狗设备，一个系统可能有多个看门狗，通过ID号来打开指定的看门狗设备：
-
-int32\_t WatchdogOpen\(int16\_t wdtId\);
-
-**表 2** WatchdogOpen参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-wdtId
- |
-看门狗设备号
- |
-
-返回值
- |
-返回值描述
- |
-
-NULL
- |
-打开失败
- |
-
-DevHandle类型指针
- |
-看门狗设备句柄
- |
-
-
-
-
-```
-DevHandle handle = NULL;
-handle = WatchdogOpen(0); /* 打开0号看门狗设备 */
-if (handle == NULL) {
- HDF_LOGE("WatchdogOpen: failed, ret %d\n", ret);
- return;
-}
-```
-
-### 获取看门狗状态
-
-int32\_t WatchdogGetStatus\(DevHandle handle, int32\_t \*status\);
-
-**表 3** WatchdogGetStatus参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-看门狗设备句柄
- |
-
-status
- |
-获取到的启动状态指针
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-获取成功
- |
-
-负数
- |
-获取失败
- |
-
-
-
-
-```
-int32_t ret;
-int32_t status;
-/* 获取Watchdog启动状态 */
-ret = WatchdogGetStatus(handle, &status);
-if (ret != 0) {
- HDF_LOGE("WatchdogGetStatus: failed, ret %d\n", ret);
- return;
-}
-```
-
-### 设置超时时间
-
-int32\_t WatchdogSetTimeout\(PalHandle \*handle, uint32\_t seconds\);
-
-**表 4** WatchdogSetTimeout参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-看门狗设备句柄
- |
-
-seconds
- |
-超时时间，单位为秒
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-设置成功
- |
-
-负数
- |
-设置失败
- |
-
-
-
-
-```
-int32_t ret;
-uint32_t timeOut = 60;
-/* 设置超时时间，单位：秒 */
-ret = WatchdogSetTimeout(handle, timeOut);
-if (ret != 0) {
- HDF_LOGE("WatchdogSetTimeout: failed, ret %d\n", ret);
- return;
-}
-```
-
-### 获取超时时间
-
-int32\_t WatchdogGetTimeout\(PalHandle \*handle, uint32\_t \*seconds\);
-
-**表 5** WatchdogGetTimeout参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-看门狗设备句柄
- |
-
-seconds
- |
-接收超时时间的指针，单位为秒
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-获取成功
- |
-
-负数
- |
-获取失败
- |
-
-
-
-
-```
-int32_t ret;
-uint32_t timeOut;
-/* 获取超时时间，单位：秒 */
-ret = WatchdogGetTimeout(handle, &timeOut);
-if (ret != 0) {
- HDF_LOGE("WatchdogGetTimeout: failed, ret %d\n", ret);
- return;
-}
-```
-
-### 启动看门狗
-
-int32\_t WatchdogStart\(DevHandle handle\);
-
-**表 6** WatchdogStart参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-看门狗设备句柄
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-启动成功
- |
-
-负数
- |
-启动失败
- |
-
-
-
-
-```
-int32_t ret;
-/* 启动看门狗 */
-ret = WatchdogStart(handle);
-if (ret != 0) {
- HDF_LOGE("WatchdogStart: failed, ret %d\n", ret);
- return;
-}
-```
-
-### 喂狗
-
-int32\_t WatchdogFeed\(DevHandle handle\);
-
-**表 7** WatchdogFeed参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-看门狗设备句柄
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-喂狗成功
- |
-
-负数
- |
-喂狗失败
- |
-
-
-
-
-```
-int32_t ret;
-/* 喂狗 */
-ret = WatchdogFeed(handle);
-if (ret != 0) {
- HDF_LOGE("WatchdogFeed: failed, ret %d\n", ret);
- return;
-}
-```
-
-### 停止看门狗
-
-int32\_t WatchdogStop\(DevHandle handle\);
-
-**表 8** WatchdogStop参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-看门狗设备句柄
- |
-
-返回值
- |
-返回值描述
- |
-
-0
- |
-停止成功
- |
-
-负数
- |
-停止失败
- |
-
-
-
-
-```
-int32_t ret;
-/* 停止看门狗 */
-ret = WatchdogStop(handle);
-if (ret != 0) {
- HDF_LOGE("WatchdogStop: failed, ret %d\n", ret);
- return;
-}
-```
-
-### 关闭看门狗设备
-
-当操作完毕时，使用WatchdogClose关闭打开的设备句柄：
-
-void WatchdogClose\(DevHandle handle\);
-
-**表 9** WatchdogClose参数和返回值描述
-
-
-参数
- |
-参数描述
- |
-
|---|
-
-handle
- |
-看门狗设备句柄
- |
-
-
-
-
-```
-/* 关闭看门狗 */
-ret = WatchdogClose(handle);
-```
-
-## 使用实例
-
-本例程提供看门狗的完整使用流程。
-
-在本例程中，我们打开一个看门狗设备，设置超时时间并启动计时:
-
-- 首先定期喂狗，即按时清除看门狗定时器，确保系统不会因定时器超时而复位。
-- 接着再停止喂狗，观察定时器到期后系统是否发生复位行为。
-
-示例如下：
-
-```
-#include "watchdog_if.h"
-#include "hdf_log.h"
-#include "osal_irq.h"
-#include "osal_time.h"
-
-#define WATCHDOG_TEST_TIMEOUT 2
-#define WATCHDOG_TEST_FEED_TIME 6
-
-static int32_t TestCaseWatchdog(void)
-{
- int32_t i;
- int32_t ret;
- uint32_t timeout;
- DevHandle handle = NULL;
-
- /* 打开0号看门狗设备 */
- handle = WatchdogOpen(0);
- if (handle == NULL) {
- HDF_LOGE("Open watchdog fail!");
- return -1;
- }
-
- /* 设置超时时间 */
- ret = WatchdogSetTimeout(handle, WATCHDOG_TEST_TIMEOUT);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: set timeout fail! ret:%d\n", __func__, ret);
- WatchdogClose(handle);
- return ret;
- }
-
- /* 回读设置的超时时间值 */
- ret = WatchdogGetTimeout(handle, &timeout);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: get timeout fail! ret:%d\n", __func__, ret);
- WatchdogClose(handle);
- return ret;
- }
- HDF_LOGI("%s: read timeout back:%u\n", __func__, timeout);
-
- /* 启动看门狗，开始计时 */
- ret = WatchdogStart(handle);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: satrt fail! ret:%d\n", __func__, ret);
- WatchdogClose(handle);
- return ret;
- }
-
- /* 每隔1S喂狗一次 */
- for (i = 0; i < WATCHDOG_TEST_FEED_TIME; i++) {
- HDF_LOGE("%s: feeding watchdog %d times... \n", __func__, i);
- ret = WatchdogFeed(handle);
- if (ret != HDF_SUCCESS) {
- HDF_LOGE("%s: feed dog fail! ret:%d\n", __func__, ret);
- WatchdogClose(handle);
- return ret;
- }
- OsalSleep(1);
- }
- /* 由于喂狗间隔小于超时时间，系统不会发生复位，此日志可以正常打印 */
- HDF_LOGE("%s: no reset ... feeding test OK!!!\n", __func__);
-
- /* 接下来持续不喂狗，使得看门狗计时器超时 */
- for (i = 0; i < WATCHDOG_TEST_FEED_TIME; i++) {
- HDF_LOGE("%s: watiting dog buck %d times... \n", __func__, i);
- OsalSleep(1);
- }
-
- /* 当不喂狗时间到达之前设定的超时时间的时候，系统会发生复位，理论上观察不到此日志的打印 */
- HDF_LOGE("%s: dog has't buck!!! \n", __func__, i);
- WatchdogClose(handle);
- return -1;
-}
-```
-
diff --git "a/website/docs/01.\346\226\207\346\241\243/03.\350\256\276\345\244\207\345\274\200\345\217\221-\345\206\205\346\240\270/01.\350\275\273\351\207\217\347\263\273\347\273\237\345\206\205\346\240\270/01.\345\206\205\346\240\270\346\246\202\350\277\260.md" "b/website/docs/01.\346\226\207\346\241\243/05.\345\255\220\347\263\273\347\273\237\345\274\200\345\217\221/01.\345\206\205\346\240\270/01.\350\275\273\351\207\217\347\263\273\347\273\237\345\206\205\346\240\270/01.\345\206\205\346\240\270\346\246\202\350\277\260.md"
similarity index 80%
rename from "website/docs/01.\346\226\207\346\241\243/03.\350\256\276\345\244\207\345\274\200\345\217\221-\345\206\205\346\240\270/01.\350\275\273\351\207\217\347\263\273\347\273\237\345\206\205\346\240\270/01.\345\206\205\346\240\270\346\246\202\350\277\260.md"
rename to "website/docs/01.\346\226\207\346\241\243/05.\345\255\220\347\263\273\347\273\237\345\274\200\345\217\221/01.\345\206\205\346\240\270/01.\350\275\273\351\207\217\347\263\273\347\273\237\345\206\205\346\240\270/01.\345\206\205\346\240\270\346\246\202\350\277\260.md"
index 8fd7718b53726c375dc003f28d83118ffabd62cf..e2adf8d5af26a2920dd88856e566ecae286df69e 100644
--- "a/website/docs/01.\346\226\207\346\241\243/03.\350\256\276\345\244\207\345\274\200\345\217\221-\345\206\205\346\240\270/01.\350\275\273\351\207\217\347\263\273\347\273\237\345\206\205\346\240\270/01.\345\206\205\346\240\270\346\246\202\350\277\260.md"
+++ "b/website/docs/01.\346\226\207\346\241\243/05.\345\255\220\347\263\273\347\273\237\345\274\200\345\217\221/01.\345\206\205\346\240\270/01.\350\275\273\351\207\217\347\263\273\347\273\237\345\206\205\346\240\270/01.\345\206\205\346\240\270\346\246\202\350\277\260.md"
@@ -1,6 +1,6 @@
---
title: 内核概述
-permalink: /pages/00020000
+permalink: /pages/0004000000
navbar: true
sidebar: true
prev: true
@@ -9,7 +9,7 @@ search: true
article: true
comment: false
editLink: false
-date: 2021-12-30 12:57:42
+date: 2021-12-30 18:31:29
---
# 内核概述
@@ -20,10 +20,10 @@ date: 2021-12-30 12:57:42
## 内核简介
-OpenHarmony LiteOS-M内核是面向IoT领域构建的轻量级物联网操作系统内核，具有小体积、低功耗、高性能的特点。其代码结构简单，主要包括内核最小功能集、内核抽象层、可选组件以及工程目录等。OpenHarmony LiteOS-M内核架构包含硬件相关层以及硬件无关层，如下图所示，其中Kernel Arch模块属于硬件相关层，该模块按不同编译工具链、芯片架构分类，提供统一的HAL（Hardware Abstraction Layer）接口，提升了硬件易适配性，满足AIoT类型丰富的硬件和编译工具链的拓展；Components等其他模块属于硬件无关层，其中Kernel Task等内核模块提供基础能力，Components模块提供网络、文件系统等组件能力，Utils模块提供错误处理、调测等能力，KAL（Kernel Abstraction Layer）模块提供统一的标准接口。
+OpenHarmony LiteOS-M内核是面向IoT领域构建的轻量级物联网操作系统内核，具有小体积、低功耗、高性能的特点。其代码结构简单，主要包括内核最小功能集、内核抽象层、可选组件以及工程目录等。OpenHarmony LiteOS-M内核架构包含硬件相关层以及硬件无关层，如下图所示，其中硬件相关层按不同编译工具链、芯片架构分类，提供统一的HAL（Hardware Abstraction Layer）接口，提升了硬件易适配性，满足AIoT类型丰富的硬件和编译工具链的拓展；其他模块属于硬件无关层，其中基础内核模块提供基础能力，扩展模块提供网络、文件系统等组件能力，还提供错误处理、调测等能力；KAL（Kernel Abstraction Layer）模块提供统一的标准接口。
**图 1** 内核架构图
-
+
### cpu体系架构支持
@@ -42,9 +42,9 @@ CPU体系架构分为通用架构定义和特定架构定义两层，通用架
|