DragonOS-Community/DragonOS
4
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-18 16:26:31 +00:00
Code Issues Releases Wiki Activity

Patch uart (#99)

Browse Source 
* 添加UART驱动相关文件

* 添加驱动核心文件，将rust编写的驱动代码加入Package中

* 添加glib.h文件生成rust代码，添加uart驱动代码

* 添加串口发送及接收相关代码

* 添加字符串发送函数,未实现具体功能

* 为调用uart驱动的代码添加rust接口

* 添加字符串发送函数，修改C语言调用接口

* 添加rust串口驱动

* 添加uart.h头文件，将串口端口类型改为enum

* 添加注释，规范代码
This commit is contained in:
TingHuang
2022-12-06 22:15:03 +08:00
committed by GitHub
parent 036acc52ce
commit f8b55f6d3f
13 changed files with 280 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
kernel/src/driver/uart/Makefile
View File

@ -1,7 +0,0 @@
all: uart.o
CFLAGS += -I .
uart.o: uart.c
$(CC) $(CFLAGS) -c uart.c -o uart.o

1
kernel/src/driver/uart/mod.rs Normal file
View File

@ -0,0 +1 @@
pub mod uart;

112
kernel/src/driver/uart/uart.c
View File

@ -1,112 +0,0 @@
#include "uart.h"
#include <common/kprint.h>
#define UART_MAX_BITS_RATE 115200
/**
* @brief 当前是否有数据到达
*
*/
#define serial_received(p) ((io_in8(p + 5) & 1))
/**
* @brief 当前是否有数据正等待发送
*
*/
#define is_transmit_empty(p) ((io_in8(p + 5) & 0x20))
/**
* @brief 初始化com口
*
* @param port com口的端口号
* @param bits_rate 通信的比特率
*/
int uart_init(uint32_t port, uint32_t bits_rate)
{
// 错误的比特率
if (bits_rate > UART_MAX_BITS_RATE || UART_MAX_BITS_RATE % bits_rate != 0)
return E_UART_BITS_RATE_ERROR;
io_out8(port + 1, 0x00); // Disable all interrupts
io_out8(port + 3, 0x80); // Enable DLAB (set baud rate divisor)
uint16_t divisor = UART_MAX_BITS_RATE / bits_rate;
io_out8(port + 0, divisor & 0xff); // Set divisor (lo byte)
io_out8(port + 1, (divisor >> 8) & 0xff); // (hi byte)
io_out8(port + 3, 0x03); // 8 bits, no parity, one stop bit
io_out8(port + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold
io_out8(port + 4, 0x08); // IRQs enabled, RTS/DSR clear (现代计算机上一般都不需要hardware flow control，因此不需要置位RTS/DSR)
io_out8(port + 4, 0x1E); // Set in loopback mode, test the serial chip
io_out8(port + 0, 0xAE); // Test serial chip (send byte 0xAE and check if serial returns same byte)
// Check if serial is faulty (i.e: not same byte as sent)
if (io_in8(port + 0) != 0xAE)
{
return E_UART_SERIAL_FAULT;
}
// If serial is not faulty set it in normal operation mode
// (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
io_out8(port + 4, 0x08);
char init_text2[] = "uart initialized.\n";
for (int i = 0; i < sizeof(init_text2) - 1; ++i)
uart_send(COM1, init_text2[i]);
return UART_SUCCESS;
/*
Notice that the initialization code above writes to [PORT + 1]
twice with different values. This is once to write to the Divisor
register along with [PORT + 0] and once to write to the Interrupt
register as detailed in the previous section.
The second write to the Line Control register [PORT + 3]
clears the DLAB again as well as setting various other bits.
*/
}
/**
* @brief 发送数据
*
* @param port 端口号
* @param c 要发送的数据
*/
void uart_send(uint32_t port, char c)
{
while (is_transmit_empty(port) == 0)
pause();
io_out8(port, c);
}
/**
* @brief 从uart接收数据
*
* @param port 端口号
* @return uchar 接收到的数据
*/
uchar uart_read(uint32_t port)
{
while (serial_received(port) == 0)
pause();
return io_in8(port);
}
/**
* @brief 通过串口发送整个字符串
*
* @param port 串口端口
* @param str 字符串
*/
void uart_send_str(uint32_t port, const char *str)
{
if ((unlikely(str == NULL)))
return;
while (1)
{
if (unlikely(*str == '\0'))
return;
uart_send(port, *str);
++str;
}
}

63
kernel/src/driver/uart/uart.h
View File

@ -1,20 +1,6 @@
/**
* @file uart.h
* @author longjin (longjin@RinGoTek.cn)
* @brief uart驱动程序 RS-232驱动
* @version 0.1
* @date 2022-04-15
*
* @copyright Copyright (c) 2022
*
*/
#pragma once
#include <common/glib.h>
#define UART_SUCCESS 0
#define E_UART_BITS_RATE_ERROR 1
#define E_UART_SERIAL_FAULT 2
//driver/uart/uart.rs --rust function
enum uart_port_io_addr
{
COM1 = 0x3f8,
@ -26,47 +12,6 @@ enum uart_port_io_addr
COM7 = 0x5e8,
COM8 = 0x4E8,
};
enum uart_register_offset
{
REG_DATA = 0,
REG_INTERRUPT_ENABLE = 1,
REG_II_FIFO = 2, // Interrupt Identification and FIFO control registers
REG_LINE_CONTROL = 3,
REG_MODEM_CONTROL = 4,
REG_LINE_STATUS = 5,
REG_MODEM_STATUE = 6,
REG_SCRATCH = 7
};
/**
* @brief 初始化com口
*
* @param port com口的端口号
* @param bits_rate 通信的比特率
*/
int uart_init(uint32_t port, uint32_t bits_rate);
/**
* @brief 发送数据
*
* @param port 端口号
* @param c 要发送的数据
*/
void uart_send(uint32_t port, char c);
/**
* @brief 从uart接收数据
*
* @param port 端口号
* @return uchar 接收到的数据
*/
uchar uart_read(uint32_t port);
/**
* @brief 通过串口发送整个字符串
*
* @param port 串口端口
* @param str 字符串
*/
void uart_send_str(uint32_t port, const char *str);
extern int c_uart_init(uint16_t port, uint32_t baud_rate);
extern void c_uart_send(uint16_t port, char c);
extern void c_uart_send_str(uint16_t port, const char *str);

258
kernel/src/driver/uart/uart.rs Normal file
View File

@ -0,0 +1,258 @@
use crate::include::bindings::bindings::{io_in8, io_out8};
use core::{str, char, intrinsics::offset};
const UART_SUCCESS: i32 = 0;
const E_UART_BITS_RATE_ERROR: i32 = 1;
const E_UART_SERIAL_FAULT: i32 = 2;
const UART_MAX_BITS_RATE: u32 = 115200;
#[allow(dead_code)]
#[repr(u16)]
#[derive(Clone)]
pub enum UartPort {
COM1 = 0x3f8,
COM2 = 0x2f8,
COM3 = 0x3e8,
COM4 = 0x2e8,
COM5 = 0x5f8,
COM6 = 0x4f8,
COM7 = 0x5e8,
COM8 = 0x4e8,
}
impl UartPort {
///@brief 将u16转换为UartPort枚举类型
///@param val 要转换的u16类型
///@return 输入的端口地址正确，返回UartPort类型，错误，返回错误信息
#[allow(dead_code)]
pub fn from_u16(val: u16) -> Result<Self, &'static str> {
match val {
0x3f8 => Ok(Self::COM1),
0x2f8 => Ok(Self::COM2),
0x3e8 => Ok(Self::COM3),
0x2e8 => Ok(Self::COM4),
0x5f8 => Ok(Self::COM5),
0x4f8 => Ok(Self::COM6),
0x5e8 => Ok(Self::COM7),
0x4e8 => Ok(Self::COM8),
_ => Err("port error!"),
}
}
///@brief 将UartPort枚举类型转换为u16类型
///@param self 要转换的UartPort
///@return 转换的u16值
#[allow(dead_code)]
pub fn to_u16(self: &Self) -> u16 {
match self {
Self::COM1 => 0x3f8,
Self::COM2 => 0x2f8,
Self::COM3 => 0x3e8,
Self::COM4 => 0x2e8,
Self::COM5 => 0x5f8,
Self::COM6 => 0x4f8,
Self::COM7 => 0x5e8,
Self::COM8 => 0x4e8,
}
}
}
#[allow(dead_code)]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
struct UartRegister {
reg_data: u8,
reg_interrupt_enable: u8,
reg_ii_fifo: u8, // Interrupt Identification and FIFO control registers
reg_line_config: u8,
reg_modem_config: u8,
reg_line_status: u8,
reg_modem_statue: u8,
reg_scartch: u8,
}
#[repr(C)]
pub struct UartDriver {
port: UartPort,
baud_rate: u32,
}
impl Default for UartDriver {
fn default() -> Self {
Self {port: UartPort::COM1, baud_rate: 115200}
}
}
impl UartDriver {
/// @brief 串口初始化
/// @param uart_port 端口号
/// @param baud_rate 波特率
/// @return 初始化成功，返回0,失败，返回错误信息
#[allow(dead_code)]
pub fn uart_init(uart_port: &UartPort, baud_rate: u32) -> Result<i32, &'static str> {
let message: &'static str = "uart init.";
let port = uart_port.to_u16();
// 错误的比特率
if baud_rate > UART_MAX_BITS_RATE || UART_MAX_BITS_RATE % baud_rate != 0 {
return Err("uart init error.");
}
unsafe {
io_out8(port + 1, 0x00); // Disable all interrupts
io_out8(port + 3, 0x80); // Enable DLAB (set baud rate divisor)
let divisor = UART_MAX_BITS_RATE / baud_rate;
io_out8(port + 0, (divisor & 0xff) as u8); // Set divisor (lo byte)
io_out8(port + 1, ((divisor >> 8) & 0xff) as u8); // (hi byte)
io_out8(port + 3, 0x03); // 8 bits, no parity, one stop bit
io_out8(port + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold
io_out8(port + 4, 0x08); // IRQs enabled, RTS/DSR clear (现代计算机上一般都不需要hardware flow control，因此不需要置位RTS/DSR)
io_out8(port + 4, 0x1E); // Set in loopback mode, test the serial chip
io_out8(port + 0, 0xAE); // Test serial chip (send byte 0xAE and check if serial returns same byte)
// Check if serial is faulty (i.e: not same byte as sent)
if io_in8(port + 0) != 0xAE {
return Err("uart faulty");
}
// If serial is not faulty set it in normal operation mode
// (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
io_out8(port + 4, 0x08);
}
UartDriver::uart_send(uart_port, message);
Ok(0)
/*
Notice that the initialization code above writes to [PORT + 1]
twice with different values. This is once to write to the Divisor
register along with [PORT + 0] and once to write to the Interrupt
register as detailed in the previous section.
The second write to the Line Control register [PORT + 3]
clears the DLAB again as well as setting various other bits.
*/
}
fn serial_received(offset: u16) -> bool {
if unsafe{ io_in8(offset + 5) } & 1 != 0 {
true
} else {
false
}
}
fn is_transmit_empty(offset: u16) -> bool {
if unsafe{ io_in8(offset + 5) } & 0x20 != 0 {
true
} else {
false
}
}
/// @brief 串口发送
/// @param uart_port 端口号
/// @param str 发送字符切片
/// @return None
#[allow(dead_code)]
fn uart_send(uart_port: &UartPort, str: &str) {
let port = uart_port.to_u16();
while UartDriver::is_transmit_empty(port) == false {
for c in str.bytes() {
unsafe { io_out8(port, c); }
}
} //TODO:pause
}
/// @brief 串口接收一个字节
/// @param uart_port 端口号
/// @return 接收的字节
#[allow(dead_code)]
fn uart_read_byte(uart_port: &UartPort) -> char {
let port = uart_port.to_u16();
while UartDriver::serial_received(port) == false {} //TODO:pause
unsafe { io_in8(port) as char }
}
}
///@brief 发送数据
///@param port 端口号
///@param c 要发送的数据
#[no_mangle]
pub extern "C" fn c_uart_send(port: u16, c: u8) {
while UartDriver::is_transmit_empty(port) == false {} //TODO:pause
unsafe { io_out8(port, c); }
}
///@brief 从uart接收数据
///@param port 端口号
///@return u8 接收到的数据
#[no_mangle]
pub extern "C" fn c_uart_read(port: u16) -> u8 {
while UartDriver::serial_received(port) == false {} //TODO:pause
unsafe { io_in8(port) }
}
///@brief 通过串口发送整个字符串
///@param port 串口端口
///@param str 字符串S
#[no_mangle]
pub extern "C" fn c_uart_send_str(port: u16, str: *const u8)
{
unsafe {
let mut i = 0;
while *offset(str, i) != '\0' as u8 {
c_uart_send(port, *offset(str, i));
i = i + 1;
}
}
}
/// @brief 串口初始化
/// @param u16 端口号
/// @param baud_rate 波特率
/// @return 初始化成功，返回0,失败，返回错误码
#[no_mangle]
pub extern "C" fn c_uart_init(port: u16, baud_rate: u32) -> i32 {
let message: &'static str = "uart init\n";
// 错误的比特率
if baud_rate > UART_MAX_BITS_RATE || UART_MAX_BITS_RATE % baud_rate != 0 {
return -E_UART_BITS_RATE_ERROR;
}
unsafe {
io_out8(port + 1, 0x00); // Disable all interrupts
io_out8(port + 3, 0x80); // Enable DLAB (set baud rate divisor)
let divisor = UART_MAX_BITS_RATE / baud_rate;
io_out8(port + 0, (divisor & 0xff) as u8); // Set divisor (lo byte)
io_out8(port + 1, ((divisor >> 8) & 0xff) as u8); // (hi byte)
io_out8(port + 3, 0x03); // 8 bits, no parity, one stop bit
io_out8(port + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold
io_out8(port + 4, 0x08); // IRQs enabled, RTS/DSR clear (现代计算机上一般都不需要hardware flow control，因此不需要置位RTS/DSR)
io_out8(port + 4, 0x1E); // Set in loopback mode, test the serial chip
io_out8(port + 0, 0xAE); // Test serial chip (send byte 0xAE and check if serial returns same byte)
// Check if serial is faulty (i.e: not same byte as sent)
if io_in8(port + 0) != 0xAE {
return -E_UART_SERIAL_FAULT;
}
// If serial is not faulty set it in normal operation mode
// (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
io_out8(port + 4, 0x08);
let bytes = message.as_bytes();
for c in bytes {
c_uart_send(port, *c);
}
}
return UART_SUCCESS;
/*
Notice that the initialization code above writes to [PORT + 1]
twice with different values. This is once to write to the Divisor
register along with [PORT + 0] and once to write to the Interrupt
register as detailed in the previous section.
The second write to the Line Control register [PORT + 3]
clears the DLAB again as well as setting various other bits.
*/
}