# 第六章． ： （ ）
### 目录
- [6.1 实验4的基础知识 ](#fundamental )
- [6.1.1 内存映射I/O(MMIO) ](#subsec_MMIO )
- [6.1.2 轮询I/O控制方式 ](#subsec_polling )
- [6.1.3 中断驱动I/O控制方式 ](#subsec_plic )
- [6.1.4 设备树 ](#subsec_device_tree )
- [6.2 lab4_1 POLL ](#polling )
- [给定应用 ](#lab4_1_app )
- [实验内容 ](#lab4_1_content )
- [实验指导 ](#lab4_1_guide )
- [6.3 lab4_2_PLIC ](#PLIC )
- [给定应用 ](#lab4_2_app )
- [实验内容 ](#lab4_2_content )
- [实验指导 ](#lab4_2_guide )
- [6.4 lab4_3_hostdevice ](#hostdevice )
- [给定应用 ](#lab4_3_app )
- [实验内容 ](#lab4_3_content )
- [实验指导 ](#lab4_3_guide )
< a name = "fundamental" > < / a >
## 6.1 实验4的基础知识
完成前面所有实验后， ， ， ， ， ，
< a name = "subsec_MMIO" > < / a >
### 6.1.1 内存映射I/O(MMIO)
内存映射(Memory-Mapping I/O)是一种用于设备驱动程序和设备通信的方式， ， ， ， ， ，
在MMIO中， ， ， ， ， ， ， ， ， ，
用户空间程序使用mmap系统调用将IO设备的物理内存地址映射到用户空间的虚拟内存地址上， ， ， ，
< a name = "subsec_polling" > < / a >
### 6.1.2 轮询I/O控制方式
在实验四中，我们设备管理的主要任务是控制设备与内存的数据传递，具体为从蓝牙设备读取到用户输入的指令字符（或传递数据给蓝牙在手机端进行打印），解析为小车前、后、左、右、停止等动作来传输数据给电机实现对小车的控制。在前两个实验中，我们分别需要对轮询控制方式和中断控制方式进行实现。
首先， （ ） ， ， ， ， ， ， ，
轮询I/O控制方式流程如图：
< img src = "pictures/fig6_1_polling.png" alt = "fig6_1" style = "zoom:100%;" / >
< a name = "subsec_plic" > < / a >
### 6.1.3 中断驱动I/O控制方式
在前一种轮询的控制方式中， ， ， ， ， ， ， ，
采用中断驱动的控制方式， ， ， ，
中断驱动I/O方式流程如图：
< img src = "pictures/fig6_2_plic.png" alt = "fig6_2" style = "zoom:100%;" / >
< a name = "subsec_device_tree" > < / a >
### 6.1.4 设备树
设备树（ ） ， ， ， ，
硬件的相应信息都会写在`.dts`为后缀的文件中，`dtc`是编译`dts`的工具，`dtb(Device Tree Blob)`， ；
< img src = "pictures/fig6_3.png" alt = "fig6_3" style = "zoom:130%;" / >
在rocketchip中，
< a name = "polling" > < / a >
## 6.2 lab4_1 POLL
< a name = "lab4_1_app" > < / a >
#### **给定应用**
- user/app_poll.c
```
1 /*
2 * Below is the given application for lab4_1.
3 * The goal of this app is to control the car via Bluetooth.
4 */
5
6 #include "user_lib.h"
7 #include "util/types.h"
8
9 int main(void) {
10 printu("please input the instruction through bluetooth!\n");
11 while(1)
12 {
13 char temp = (char)uartgetchar();
14 uartputchar(temp);
15 switch (temp)
16 {
17 case '1' : gpio_reg_write(0x2e); break; //前进
18 case '2' : gpio_reg_write(0xd1); break; //后退
19 case '3' : gpio_reg_write(0x63); break; //左转
20 case '4' : gpio_reg_write(0x9c); break; //右转
21 case 'q' : exit(0); break;
22 default : gpio_reg_write(0x00); break; //停止
23 }
24 }
25 exit(0);
26 return 0;
27 }
```
应用通过轮询的方式从蓝牙端获取指令，实现对小车的控制功能。
- 切换到lab4_1， ， ：
```
//切换到lab4_1
$ git checkout lab4_1_poll
//继承lab3_3以及之前的答案
$ git merge lab3_3_rrsched -m "continue to work on lab4_1"
//重新构造
$ make clean; make
//运行构造结果
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_poll
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
please input the instruction through bluetooth!
You need to implement the uart_getchar function in lab4_1 here!
System is shutting down with exit code -1.
```
从结果上来看， ， ， ， ，
< a name = "lab4_1_content" > < / a >
#### **实验内容**
如输出提示所表示的那样， ， ， ， ：
```
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_poll
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
Ticks 0
please input the instruction through bluetooth!
Ticks 1
going to insert process 0 to ready queue.
going to schedule process 0 to run.
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
< a name = "lab4_1_guide" > < / a >
#### **实验指导**
基于实验lab1_1， ， ： ， ， ， ， ：
```
16 #define SYS_user_uart_putchar (SYS_user_base + 6)
17 #define SYS_user_uart_getchar (SYS_user_base + 7)
18 #define SYS_user_gpio_reg_write (SYS_user_base + 8)
```
继续追踪， ， ， ：
```
133 case SYS_user_uart_putchar:
134 sys_user_uart_putchar(a1);return 1;
135 case SYS_user_uart_getchar:
136 return sys_user_uart_getchar();
137 case SYS_user_gpio_reg_write:
138 return sys_user_gpio_reg_write(a1);
```
读者的任务即为在kernel/syscall.c中追踪并完善对应的函数。对于uart的函数， ：
< img src = "pictures/fig6_3_address.png" alt = "fig6_3" style = "zoom:80%;" / >
我们可以看到配置uart端口的偏移地址为0x60000000， ， ， ，
在kernel/syscall.c中找到函数实现空缺， ：
```
84 //add uart putchar getchar syscall
85 //
86 // implement the SYS_user_uart_putchar syscall
87 //
88 void sys_user_uart_putchar(uint8 ch) {
89 volatile uint32 *status = (void* )(uintptr_t)0x60000008;
90 volatile uint32 *tx = (void* )(uintptr_t)0x60000004;
91 while (*status & 0x00000008);
92 *tx = ch;
93 }
94
95 ssize_t sys_user_uart_getchar() {
96 // TODO (lab4_1): implment the syscall of sys_user_uart_getchar.
97 // hint: the functionality of sys_user_uart_getchar is to get data from UART address. therefore,
98 // we should let a pointer point, insert it in
99 // the rear of ready queue, and finally, schedule a READY process to run.
100 panic( "You have to implement sys_user_uart_getchar to get data from UART using uartgetchar in lab4_1.\n" );
101
102 }
103
104
105
106 //car control
107 ssize_t sys_user_gpio_reg_write(uint8 val) {
108 volatile uint32_t *control_reg = (void* )(uintptr_t)0x60001004;
109 volatile uint32_t *data_reg = (void* )(uintptr_t)0x60001000;
110 //*control_reg = 0;
111 *data_reg = (uint32_t)val;
112 return 1;
113 }
114
```
和uart端口读写过程类似， ， ，
安卓手机端验证： ， ：
| pynq接口 | HC-05接口 |
| -------- | --------- |
| VCC | VCC |
| GND | GND |
| JA4 | RXD |
| JA3 | TXD |
接入时注意对应接口错位正确插入， ， ， ，
成功连接蓝牙模块后，启动连接：
```
$ ssh xilinx@192.168.2.99
```
随后使用scp指令将编译后的pke内核和用户app文件导入：
```
$ scp 文件名 xilinx@192.168.2.99:~
```
此时便成功进入pynq板环境，
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定） ， ：
```
$ git commit -a -m "my work on lab4_1 is done."
```
< a name = "PLIC" > < / a >
## 6.3 lab4_2_PLIC
< a name = "lab4_2_app" > < / a >
#### **给定应用**
- user/app_PLIC.c
```
1 /*
2 * Below is the given application for lab4_2.
3 * The goal of this app is to control the car via Bluetooth.
4 */
5
6 #include "user_lib.h"
7 #include "util/types.h"
8 void delay(unsigned int time){
9 unsigned int a = 0xfffff ,b = time;
10 volatile unsigned int i,j;
11 for(i = 0; i < a ; + + i ) {
12 for(j = 0; j < b ; + + j ) {
13 ;
14 }
15 }
16 }
17 int main(void) {
18 printu("Hello world!\n");
19 int i;
20 int pid = fork();
21 if(pid == 0)
22 {
23 while (1)
24 {
25 delay(3);
26 printu("waiting for you!\n");
27 }
28
29 }
30 else
31 {
32 for (;;) {
33 char temp = (char)uartgetchar();
34 printu("%c\n", temp);
35 switch (temp)
36 {
37 case '1' : gpio_reg_write(0x2e); break; //前进
38 case '2' : gpio_reg_write(0xd1); break; //后退
39 case '3' : gpio_reg_write(0x63); break; //左转
40 case '4' : gpio_reg_write(0x9c); break; //右转
41 case 'q' : exit(0); break;
42 default : gpio_reg_write(0x00); break; //停止
43 }
44 }
45 }
46
47
48 exit(0);
49
50 return 0;
51 }
```
应用通过中断的方式从蓝牙端获取指令，实现对小车的控制功能。
- 切换到lab4_2， ， ：
```
//切换到lab4_2
$ git checkout lab4_2_PLIC
//继承lab4_1以及之前的答案
$ git merge lab4_1_poll -m "continue to work on lab4_2"
//重新构造
$ make clean; make
//运行构造结果
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_poll
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
please input the instruction through bluetooth!
You need to implement the uart_getchar function in lab4_2 here!
System is shutting down with exit code -1.
```
< a name = "lab4_2_content" > < / a >
#### **实验内容**
如输出提示所表示的那样， ， ， ， ：
```
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_polling
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
Ticks 0
please input the instruction through bluetooth!
Ticks 1
User exit with code:0.
no more ready processes, system shutdown now.
System is shutting down with exit code 0.
```
< a name = "lab4_2_guide" > < / a >
#### **实验指导**
对于本实验的应用， ， ：
```
16 #define SYS_user_uart_putchar (SYS_user_base + 6)
17 #define SYS_user_uart_getchar (SYS_user_base + 7)
18 #define SYS_user_gpio_reg_write (SYS_user_base + 8)
```
继续追踪， ， ， ：
```
139 case SYS_user_uart_getchar:
140 return sys_user_uart_getchar();
```
你的任务即为在kernel/syscall.c中追踪并完善对应的函数。
在kernel/syscall.c中找到函数实现空缺， ：
```
88 //
89 // implement the uart syscall
90 //
103 ssize_t sys_user_uart_getchar() {
104 panic( "You need to implement the uart_getchar function in lab4_2 here.\n" );
105 //sleep
106
107 //Wait for wake
108
109 //get the value
110
111 //Return the result character
112
113
114 }
```
当蓝牙有数据发送时， ，
在kernel/strap.c中找到函数空缺， ：
```
100 case CAUSE_MEXTERNEL_S_TRAP:
101 {
102 panic( "You need to complete case CAUSE_MEXTERNEL_S_TRAP function in lab4_2 here.\n"
103 int irq = *(uint32 * )0xc201004L;
104 *(uint32 * )0xc201004L = irq;
105 volatile int *ctrl_reg = (void * )(uintptr_t)0x6000000c;
106 *ctrl_reg = *ctrl_reg | (1 < < 4 ) ;
107
108 // get the data from MMIO.
109 // send it to the process.
110 // call function to awake process[0]
111
112
113
114 break;
115 }
```
在kernel/process.c中找到函数实现空缺， ：
```
221 void do_sleep(){
222 panic( "You need to implement do_sleep function in lab4_2 here.\n"
223 // set the process BLOCKED.
224 }
```
在kernel/process.c中找到函数实现空缺， ：
```
226 void do_wake(){
227 panic( "You need to implement do_sleep function in lab4_2 here.\n"
228 //set the process READY.
229 //insert_to_ready_queue
230
231 //schedule
232 }
```
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定） ， ：
```
$ git commit -a -m "my work on lab4_2 is done."
```
< a name = "hostdevice" > < / a >
## 6.4 lab4_3
< a name = "lab4_3_app" > < / a >
#### **给定应用**
- user/app_host_device.c
```
1 #pragma pack(4)
2 #define _SYS__TIMEVAL_H_
3 struct timeval {
4 unsigned int tv_sec;
5 unsigned int tv_usec;
6 };
7
8 #include "user_lib.h"
9 #include "videodev2.h"
10 #define DARK 64
11 #define RATIO 7 / 10
12
13 int main() {
14 char *info = allocate_share_page();
15 int pid = do_fork();
16 if (pid == 0) {
17 int f = do_open("/dev/video0", O_RDWR), r;
18
19 struct v4l2_format fmt;
20 fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
21 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
22 fmt.fmt.pix.width = 320;
23 fmt.fmt.pix.height = 180;
24 fmt.fmt.pix.field = V4L2_FIELD_NONE;
25 r = do_ioctl(f, VIDIOC_S_FMT, &fmt);
26 printu("Pass format: %d\n", r);
27
28 struct v4l2_requestbuffers req;
29 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
30 req.count = 1; req.memory = V4L2_MEMORY_MMAP;
31 r = do_ioctl(f, VIDIOC_REQBUFS, &req);
32 printu("Pass request: %d\n", r);
33
34 struct v4l2_buffer buf;
35 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
36 buf.memory = V4L2_MEMORY_MMAP; buf.index = 0;
37 r = do_ioctl(f, VIDIOC_QUERYBUF, &buf);
38 printu("Pass buffer: %d\n", r);
39
40 int length = buf.length;
41 char *img = do_mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, f, buf.m.offset);
42 unsigned int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
43 r = do_ioctl(f, VIDIOC_STREAMON, &type);
44 printu("Open stream: %d\n", r);
45
46 char *img_data = allocate_page();
47 for (int i = 0; i < (length + 4095) / 4096 - 1; i++)
48 allocate_page();
49 yield();
50
51 for (;;) {
52 if (*info == '1') {
53 r = do_ioctl(f, VIDIOC_QBUF, &buf);
54 printu("Buffer enqueue: %d\n", r);
55 r = do_ioctl(f, VIDIOC_DQBUF, &buf);
56 printu("Buffer dequeue: %d\n", r);
57 r = read_mmap(img_data, img, length);
58 int num = 0;
59 for (int i = 0; i < length ; i + = 2 )
60 if (img_data[i] < DARK ) num + + ;
61 printu("Dark num: %d > %d\n", num, length / 2 * RATIO);
62 if (num > length / 2 * RATIO) {
63 *info = '0'; gpio_reg_write(0x00);
64 }
65 } else if (*info == 'q') break;
66 }
67
68 for (char *i = img_data; i - img_data < length ; i + = 4096 )
69 free_page(i);
70 r = do_ioctl(f, VIDIOC_STREAMOFF, &type);
71 printu("Close stream: %d\n", r);
72 do_munmap(img, length); do_close(f); exit(0);
73 } else {
74 yield();
75 for (;;) {
76 char temp = (char)uartgetchar();
77 printu("From bluetooth: %c\n", temp);
78 *info = temp;
79 switch (temp) {
80 case '1': gpio_reg_write(0x2e); break; //前进
81 case '2': gpio_reg_write(0xd1); break; //后退
82 case '3': gpio_reg_write(0x63); break; //左转
83 case '4': gpio_reg_write(0x9c); break; //右转
84 case 'q': exit(0); break;
85 default: gpio_reg_write(0x00); break; //停止
86 }
87 }
88 }
89 return 0;
90 }
```
该用户程序包含两个进程， ， ， （ ） ； ， ， ： ， ， ， （ ） ， ， ， ， ，
- 切换到lab4_3、继承lab4_2中所做修改， ：
```
//切换到lab4_2
$ git checkout lab4_2_PLIC
//继承lab3_3以及之前的答案
$ git merge lab4_2_PLIC -m "continue to work on lab4_2"
//重新构造
$ make clean; make
//运行构造结果
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 512 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x0000000080010000, PKE kernel size: 0x0000000000010000 .
free physical memory address: [0x0000000080010000, 0x000000008003ffff]
kernel memory manager is initializing ...
kernel pagetable addr is 0x000000008003e000
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080005000
kernel page table is on
Switching to user mode...
in alloc_proc. user frame 0x0000000080039000, user stack 0x000000007ffff000, user kstack 0x0000000080038000
User application is loading.
Application: app_PLIC
CODE_SEGMENT added at mapped info offset:3
Application program entry point (virtual address): 0x00000000810000de
going to insert process 0 to ready queue.
going to schedule process 0 to run.
please input the instruction through bluetooth!
You need to implement the uart_getchar function in lab4_3 here!
System is shutting down with exit code -1.
```
< a name = "lab4_3_content" > < / a >
#### 实验内容
如应用提示所表示的那样， ， ， ； ， ，
跟踪相关系统调用， ：
```
25 int do_open(char *pathname, int flags) {
26 // TODO (lab4_3): call host open through spike_file_open and then bind fd to spike_file
27 // hint: spike_file_dup function can bind spike_file_t to an int fd.
28 panic( "You need to finish open function in lab4_3.\n" );
29 }
```
```
39 int do_ioctl(int fd, uint64 request, char *data) {
40 // TODO (lab4_3): call host ioctl through frontend_sycall
41 // hint: fronted_syscall ioctl argument:
42 // 1.call number
43 // 2.fd
44 // 3.the order to device
45 // 4.data address
46 panic( "You need to call host's ioctl by frontend_syscall in lab4_3.\n" );
47 return frontend_syscall(HTIFSYS_ioctl, spike_file_get(fd)->kfd,
48 request, (uint64)data, 0, 0, 0, 0);
49 }
```
实验预期结果：小车在前进过程中能够正常识别障碍物后并自动停车。
< a name = "lab4_3_guide" > < / a >
#### 实验指导
##### 摄像头控制
USB摄像头最基础的控制方法是使用读写设备文件的方式。拍摄一张照片包含以下过程：
* 打开设备文件，
* 设置设备参数，
* 映射内存， ， ，
* 拍摄，
* 结束和清理， ， ，
其中ioctl、mmap、munmap三个函数是PKE和riscv-fesvr不支持的， ， ：
* 对riscv-fesvr的修改： （ ） ， （ ） ， ， ， ， ， ；
* 对PKE内核代码的修改：
* 对用户代码的修改： ， ， ，
##### 图片解析
应用第21行可以看到， ， ， ， ，
因此对于获取过来的数据删去奇数索引的数据， ， ： ， ，
**注意：对于灰度阈值的设定可根据环境亮度进行一定的调整，可以先根据摄像头返回的图像进行分析，计算出对应障碍物的灰度值；灰度阈值越精确，小车对于障碍物的识别将越灵敏，并能在合理的距离内识别到障碍物并停车。**
**实验完毕后，记得提交修改（命令行中-m后的字符串可自行确定） ， ：
```
$ git commit -a -m "my work on lab4_3 is done."
```
