uart_device.rs 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703
  1. use crate::{
  2. driver::{
  3. base::{
  4. char::CharDevice,
  5. device::{
  6. driver::DriverError, Device, DeviceError, DeviceNumber, DevicePrivateData,
  7. DeviceResource, DeviceState, DeviceType, IdTable, KObject, DEVICE_MANAGER,
  8. },
  9. platform::{
  10. platform_device::PlatformDevice, platform_driver::PlatformDriver, CompatibleTable,
  11. },
  12. },
  13. Driver,
  14. },
  15. filesystem::{
  16. devfs::{devfs_register, DevFS, DeviceINode},
  17. sysfs::bus::{bus_device_register, bus_driver_register},
  18. vfs::{FilePrivateData, FileSystem, FileType, IndexNode, Metadata, PollStatus},
  19. },
  20. include::bindings::bindings::{io_in8, io_out8},
  21. kinfo,
  22. libs::spinlock::SpinLock,
  23. syscall::SystemError,
  24. };
  25. use alloc::{
  26. string::{String, ToString},
  27. sync::{Arc, Weak},
  28. vec::Vec,
  29. };
  30. use core::{
  31. any::Any,
  32. char,
  33. intrinsics::offset,
  34. str::{self, from_utf8},
  35. };
  36. const UART_SUCCESS: i32 = 0;
  37. const E_UART_BITS_RATE_ERROR: i32 = 1;
  38. const E_UART_SERIAL_FAULT: i32 = 2;
  39. const UART_MAX_BITS_RATE: u32 = 115200;
  40. lazy_static! {
  41. // 串口设备
  42. pub static ref UART_DEV: Arc<LockedUart> = Arc::new(LockedUart::default());
  43. // 串口驱动
  44. pub static ref UART_DRV: Arc<LockedUartDriver> = Arc::new(LockedUartDriver::default());
  45. }
  46. // @brief 串口端口
  47. #[allow(dead_code)]
  48. #[repr(u16)]
  49. #[derive(Clone, Debug)]
  50. pub enum UartPort {
  51. COM1 = 0x3f8,
  52. COM2 = 0x2f8,
  53. COM3 = 0x3e8,
  54. COM4 = 0x2e8,
  55. COM5 = 0x5f8,
  56. COM6 = 0x4f8,
  57. COM7 = 0x5e8,
  58. COM8 = 0x4e8,
  59. }
  60. impl UartPort {
  61. ///@brief 将u16转换为UartPort枚举类型
  62. ///@param val 要转换的u16类型
  63. ///@return 输入的端口地址正确,返回UartPort类型,错误,返回错误信息
  64. #[allow(dead_code)]
  65. pub fn from_u16(val: u16) -> Result<Self, &'static str> {
  66. match val {
  67. 0x3f8 => Ok(Self::COM1),
  68. 0x2f8 => Ok(Self::COM2),
  69. 0x3e8 => Ok(Self::COM3),
  70. 0x2e8 => Ok(Self::COM4),
  71. 0x5f8 => Ok(Self::COM5),
  72. 0x4f8 => Ok(Self::COM6),
  73. 0x5e8 => Ok(Self::COM7),
  74. 0x4e8 => Ok(Self::COM8),
  75. _ => Err("port error!"),
  76. }
  77. }
  78. ///@brief 将UartPort枚举类型转换为u16类型
  79. ///@param self 要转换的UartPort
  80. ///@return 转换的u16值
  81. #[allow(dead_code)]
  82. pub fn to_u16(self: &Self) -> u16 {
  83. match self {
  84. Self::COM1 => 0x3f8,
  85. Self::COM2 => 0x2f8,
  86. Self::COM3 => 0x3e8,
  87. Self::COM4 => 0x2e8,
  88. Self::COM5 => 0x5f8,
  89. Self::COM6 => 0x4f8,
  90. Self::COM7 => 0x5e8,
  91. Self::COM8 => 0x4e8,
  92. }
  93. }
  94. }
  95. // @brief 串口寄存器
  96. #[allow(dead_code)]
  97. #[repr(C)]
  98. #[derive(Debug, Copy, Clone)]
  99. struct UartRegister {
  100. reg_data: u8,
  101. reg_interrupt_enable: u8,
  102. reg_ii_fifo: u8, // Interrupt Identification and FIFO control registers
  103. reg_line_config: u8,
  104. reg_modem_config: u8,
  105. reg_line_status: u8,
  106. reg_modem_statue: u8,
  107. reg_scartch: u8,
  108. }
  109. // @brief 串口设备结构体
  110. #[derive(Debug)]
  111. pub struct Uart {
  112. private_data: DevicePrivateData, // 设备状态
  113. sys_info: Option<Arc<dyn IndexNode>>,
  114. fs: Weak<DevFS>, // 文件系统
  115. port: UartPort,
  116. baud_rate: u32,
  117. metadata: Metadata,
  118. }
  119. impl Default for Uart {
  120. fn default() -> Self {
  121. let mut metadata = Metadata::default();
  122. metadata.file_type = FileType::CharDevice;
  123. c_uart_init(UartPort::COM1.to_u16(), 115200);
  124. Self {
  125. private_data: DevicePrivateData::new(
  126. IdTable::new(
  127. "uart".to_string(),
  128. DeviceNumber::new(DeviceNumber::from_major_minor(4, 64)),
  129. ),
  130. None,
  131. CompatibleTable::new(vec!["uart"]),
  132. DeviceState::NotInitialized,
  133. ),
  134. sys_info: None,
  135. fs: Weak::default(),
  136. port: UartPort::COM1,
  137. baud_rate: 115200,
  138. metadata,
  139. }
  140. }
  141. }
  142. // @brief 串口设备结构体(加锁)
  143. #[derive(Debug)]
  144. pub struct LockedUart(SpinLock<Uart>);
  145. impl Default for LockedUart {
  146. fn default() -> Self {
  147. Self(SpinLock::new(Uart::default()))
  148. }
  149. }
  150. impl KObject for LockedUart {}
  151. impl PlatformDevice for LockedUart {
  152. fn is_initialized(&self) -> bool {
  153. let state = self.0.lock().private_data.state();
  154. match state {
  155. DeviceState::Initialized => true,
  156. _ => false,
  157. }
  158. }
  159. fn set_state(&self, set_state: DeviceState) {
  160. self.0.lock().private_data.set_state(set_state);
  161. }
  162. fn compatible_table(&self) -> CompatibleTable {
  163. return self.0.lock().private_data.compatible_table().clone();
  164. }
  165. }
  166. impl Device for LockedUart {
  167. fn id_table(&self) -> IdTable {
  168. return IdTable::new(
  169. "uart".to_string(),
  170. DeviceNumber::new(DeviceNumber::from_major_minor(4, 64)),
  171. );
  172. }
  173. fn set_sys_info(&self, sys_info: Option<Arc<dyn IndexNode>>) {
  174. self.0.lock().sys_info = sys_info;
  175. }
  176. fn sys_info(&self) -> Option<Arc<dyn IndexNode>> {
  177. self.0.lock().sys_info.clone()
  178. }
  179. fn dev_type(&self) -> DeviceType {
  180. DeviceType::Serial
  181. }
  182. fn as_any_ref(&self) -> &dyn Any {
  183. self
  184. }
  185. }
  186. impl CharDevice for LockedUart {
  187. fn read(&self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> {
  188. let device = self.0.lock();
  189. if len > buf.len() {
  190. return Err(SystemError::E2BIG);
  191. }
  192. kinfo!("------len: {:?}", len);
  193. for i in 0..len {
  194. buf[i] = Self::uart_read_byte(&device.port) as u8;
  195. kinfo!("------buf[{:?}] = {:?}", i, buf[i]);
  196. }
  197. return Ok(len);
  198. }
  199. fn write(&self, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
  200. let device = self.0.lock();
  201. if len > buf.len() {
  202. return Err(SystemError::E2BIG);
  203. }
  204. Self::uart_send(
  205. &device.port,
  206. from_utf8(&buf[0..len]).map_err(|_| SystemError::EIO)?,
  207. );
  208. return Ok(len);
  209. }
  210. fn sync(&self) -> Result<(), SystemError> {
  211. todo!()
  212. }
  213. }
  214. // impl TtyDevice for LockedUart {
  215. // fn ioctl(&self, cmd: String) -> Result<(), DeviceError> {
  216. // //TODO 补充详细信息
  217. // Err(DeviceError::UnsupportedOperation)
  218. // }
  219. // fn state(&self) -> Result<TtyState, TtyError> {
  220. // todo!()
  221. // }
  222. // }
  223. impl IndexNode for LockedUart {
  224. fn read_at(
  225. &self,
  226. _offset: usize,
  227. len: usize,
  228. buf: &mut [u8],
  229. _data: &mut FilePrivateData,
  230. ) -> Result<usize, SystemError> {
  231. CharDevice::read(self, len, buf)
  232. }
  233. fn write_at(
  234. &self,
  235. _offset: usize,
  236. len: usize,
  237. buf: &[u8],
  238. _data: &mut FilePrivateData,
  239. ) -> Result<usize, SystemError> {
  240. CharDevice::write(self, len, buf)
  241. }
  242. fn poll(&self) -> Result<PollStatus, SystemError> {
  243. todo!()
  244. }
  245. fn fs(&self) -> Arc<dyn FileSystem> {
  246. return self
  247. .0
  248. .lock()
  249. .fs
  250. .clone()
  251. .upgrade()
  252. .expect("DevFS is not initialized inside Uart Device");
  253. }
  254. fn as_any_ref(&self) -> &dyn Any {
  255. todo!()
  256. }
  257. fn list(&self) -> Result<Vec<String>, SystemError> {
  258. todo!()
  259. }
  260. fn metadata(&self) -> Result<Metadata, SystemError> {
  261. return Ok(self.0.lock().metadata.clone());
  262. }
  263. fn open(
  264. &self,
  265. _data: &mut FilePrivateData,
  266. _mode: &crate::filesystem::vfs::file::FileMode,
  267. ) -> Result<(), SystemError> {
  268. // 若文件系统没有实现此方法,则返回“不支持”
  269. return Ok(());
  270. }
  271. fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
  272. // 若文件系统没有实现此方法,则返回“不支持”
  273. return Ok(());
  274. }
  275. fn set_metadata(&self, _metadata: &Metadata) -> Result<(), SystemError> {
  276. // 若文件系统没有实现此方法,则返回“不支持”
  277. return Ok(self.0.lock().metadata = _metadata.clone());
  278. }
  279. fn create(
  280. &self,
  281. name: &str,
  282. file_type: FileType,
  283. mode: u32,
  284. ) -> Result<Arc<dyn IndexNode>, SystemError> {
  285. // 若文件系统没有实现此方法,则默认调用其create_with_data方法。如果仍未实现,则会得到一个Err(-EOPNOTSUPP_OR_ENOTSUP)的返回值
  286. return self.create_with_data(name, file_type, mode, 0);
  287. }
  288. fn create_with_data(
  289. &self,
  290. _name: &str,
  291. _file_type: FileType,
  292. _mode: u32,
  293. _data: usize,
  294. ) -> Result<Arc<dyn IndexNode>, SystemError> {
  295. // 若文件系统没有实现此方法,则返回“不支持”
  296. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  297. }
  298. fn link(&self, _name: &str, _other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
  299. // 若文件系统没有实现此方法,则返回“不支持”
  300. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  301. }
  302. fn unlink(&self, _name: &str) -> Result<(), SystemError> {
  303. // 若文件系统没有实现此方法,则返回“不支持”
  304. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  305. }
  306. fn rmdir(&self, _name: &str) -> Result<(), SystemError> {
  307. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  308. }
  309. fn move_(
  310. &self,
  311. _old_name: &str,
  312. _target: &Arc<dyn IndexNode>,
  313. _new_name: &str,
  314. ) -> Result<(), SystemError> {
  315. // 若文件系统没有实现此方法,则返回“不支持”
  316. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  317. }
  318. fn find(&self, _name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
  319. // 若文件系统没有实现此方法,则返回“不支持”
  320. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  321. }
  322. fn get_entry_name(&self, _ino: crate::filesystem::vfs::InodeId) -> Result<String, SystemError> {
  323. // 若文件系统没有实现此方法,则返回“不支持”
  324. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  325. }
  326. fn get_entry_name_and_metadata(
  327. &self,
  328. ino: crate::filesystem::vfs::InodeId,
  329. ) -> Result<(String, Metadata), SystemError> {
  330. // 如果有条件,请在文件系统中使用高效的方式实现本接口,而不是依赖这个低效率的默认实现。
  331. let name = self.get_entry_name(ino)?;
  332. let entry = self.find(&name)?;
  333. return Ok((name, entry.metadata()?));
  334. }
  335. fn ioctl(&self, _cmd: u32, _data: usize) -> Result<usize, SystemError> {
  336. // 若文件系统没有实现此方法,则返回“不支持”
  337. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  338. }
  339. fn mount(
  340. &self,
  341. _fs: Arc<dyn FileSystem>,
  342. ) -> Result<Arc<crate::filesystem::vfs::MountFS>, SystemError> {
  343. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  344. }
  345. fn truncate(&self, _len: usize) -> Result<(), SystemError> {
  346. return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
  347. }
  348. fn sync(&self) -> Result<(), SystemError> {
  349. return Ok(());
  350. }
  351. }
  352. impl DeviceINode for LockedUart {
  353. fn set_fs(&self, fs: Weak<DevFS>) {
  354. self.0.lock().fs = fs;
  355. }
  356. }
  357. impl LockedUart {
  358. /// @brief 串口初始化
  359. /// @param uart_port 端口号
  360. /// @param baud_rate 波特率
  361. /// @return 初始化成功,返回0,失败,返回错误信息
  362. #[allow(dead_code)]
  363. pub fn uart_init(uart_port: &UartPort, baud_rate: u32) -> Result<(), DeviceError> {
  364. let message: &'static str = "uart init.";
  365. let port = uart_port.to_u16();
  366. // 错误的比特率
  367. if baud_rate > UART_MAX_BITS_RATE || UART_MAX_BITS_RATE % baud_rate != 0 {
  368. return Err(DeviceError::InitializeFailed);
  369. }
  370. unsafe {
  371. io_out8(port + 1, 0x00); // Disable all interrupts
  372. io_out8(port + 3, 0x80); // Enable DLAB (set baud rate divisor)
  373. let divisor = UART_MAX_BITS_RATE / baud_rate;
  374. io_out8(port + 0, (divisor & 0xff) as u8); // Set divisor (lo byte)
  375. io_out8(port + 1, ((divisor >> 8) & 0xff) as u8); // (hi byte)
  376. io_out8(port + 3, 0x03); // 8 bits, no parity, one stop bit
  377. io_out8(port + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold
  378. io_out8(port + 4, 0x08); // IRQs enabled, RTS/DSR clear (现代计算机上一般都不需要hardware flow control,因此不需要置位RTS/DSR)
  379. io_out8(port + 4, 0x1E); // Set in loopback mode, test the serial chip
  380. io_out8(port + 0, 0xAE); // Test serial chip (send byte 0xAE and check if serial returns same byte)
  381. // Check if serial is faulty (i.e: not same byte as sent)
  382. if io_in8(port + 0) != 0xAE {
  383. return Err(DeviceError::InitializeFailed);
  384. }
  385. // If serial is not faulty set it in normal operation mode
  386. // (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
  387. io_out8(port + 4, 0x08);
  388. }
  389. Self::uart_send(uart_port, message);
  390. Ok(())
  391. /*
  392. Notice that the initialization code above writes to [PORT + 1]
  393. twice with different values. This is once to write to the Divisor
  394. register along with [PORT + 0] and once to write to the Interrupt
  395. register as detailed in the previous section.
  396. The second write to the Line Control register [PORT + 3]
  397. clears the DLAB again as well as setting various other bits.
  398. */
  399. }
  400. fn serial_received(offset: u16) -> bool {
  401. if unsafe { io_in8(offset + 5) } & 1 != 0 {
  402. true
  403. } else {
  404. false
  405. }
  406. }
  407. fn is_transmit_empty(offset: u16) -> bool {
  408. if unsafe { io_in8(offset + 5) } & 0x20 != 0 {
  409. true
  410. } else {
  411. false
  412. }
  413. }
  414. /// @brief 串口发送
  415. /// @param uart_port 端口号
  416. /// @param str 发送字符切片
  417. /// @return None
  418. #[allow(dead_code)]
  419. fn uart_send(uart_port: &UartPort, s: &str) {
  420. let port = uart_port.to_u16();
  421. while Self::is_transmit_empty(port) == false {} //TODO:pause
  422. for c in s.bytes() {
  423. unsafe {
  424. io_out8(port, c);
  425. }
  426. }
  427. }
  428. /// @brief 串口接收一个字节
  429. /// @param uart_port 端口号
  430. /// @return 接收的字节
  431. #[allow(dead_code)]
  432. fn uart_read_byte(uart_port: &UartPort) -> char {
  433. let port = uart_port.to_u16();
  434. while Self::serial_received(port) == false {} //TODO:pause
  435. return unsafe { io_in8(port) as char };
  436. }
  437. #[allow(dead_code)]
  438. fn port() -> u16 {
  439. UartPort::COM1.to_u16()
  440. }
  441. }
  442. // @brief 串口驱动结构体
  443. #[repr(C)]
  444. #[derive(Debug)]
  445. pub struct UartDriver {
  446. id_table: IdTable,
  447. sys_info: Option<Arc<dyn IndexNode>>,
  448. }
  449. impl Default for UartDriver {
  450. fn default() -> Self {
  451. Self {
  452. id_table: IdTable::new(
  453. "ttyS".to_string(),
  454. DeviceNumber::new(DeviceNumber::from_major_minor(4, 64)),
  455. ),
  456. sys_info: None,
  457. }
  458. }
  459. }
  460. // @brief 串口驱动结构体(加锁)
  461. #[derive(Debug)]
  462. pub struct LockedUartDriver(SpinLock<UartDriver>);
  463. impl Default for LockedUartDriver {
  464. fn default() -> Self {
  465. Self(SpinLock::new(UartDriver::default()))
  466. }
  467. }
  468. impl KObject for LockedUartDriver {}
  469. impl Driver for LockedUartDriver {
  470. fn as_any_ref(&self) -> &dyn Any {
  471. self
  472. }
  473. fn id_table(&self) -> IdTable {
  474. return IdTable::new("uart_driver".to_string(), DeviceNumber::new(0));
  475. }
  476. fn set_sys_info(&self, sys_info: Option<Arc<dyn IndexNode>>) {
  477. self.0.lock().sys_info = sys_info;
  478. }
  479. fn sys_info(&self) -> Option<Arc<dyn IndexNode>> {
  480. return self.0.lock().sys_info.clone();
  481. }
  482. fn probe(&self, data: &DevicePrivateData) -> Result<(), DriverError> {
  483. let table = data.compatible_table();
  484. if table.matches(&CompatibleTable::new(vec!["uart"])) {
  485. return Ok(());
  486. }
  487. return Err(DriverError::ProbeError);
  488. }
  489. fn load(
  490. &self,
  491. _data: DevicePrivateData,
  492. _resource: Option<DeviceResource>,
  493. ) -> Result<Arc<dyn Device>, DriverError> {
  494. return Err(DriverError::UnsupportedOperation);
  495. }
  496. }
  497. impl LockedUartDriver {
  498. /// @brief 创建串口驱动
  499. /// @param sys_info: sys文件系统inode
  500. /// @return
  501. #[allow(dead_code)]
  502. pub fn new(sys_info: Option<Arc<dyn IndexNode>>) -> Self {
  503. Self(SpinLock::new(UartDriver::new(sys_info)))
  504. }
  505. }
  506. impl PlatformDriver for LockedUartDriver {
  507. fn compatible_table(&self) -> CompatibleTable {
  508. return CompatibleTable::new(vec!["uart"]);
  509. }
  510. }
  511. impl UartDriver {
  512. /// @brief 创建串口驱动
  513. /// @param sys_info: sys文件系统inode
  514. /// @return 返回串口驱动
  515. #[allow(dead_code)]
  516. pub fn new(sys_info: Option<Arc<dyn IndexNode>>) -> Self {
  517. Self {
  518. id_table: IdTable::new(
  519. "ttyS".to_string(),
  520. DeviceNumber::new(DeviceNumber::from_major_minor(4, 64)),
  521. ),
  522. sys_info,
  523. }
  524. }
  525. }
  526. ///@brief 发送数据
  527. ///@param port 端口号
  528. ///@param c 要发送的数据
  529. #[no_mangle]
  530. pub extern "C" fn c_uart_send(port: u16, c: u8) {
  531. while LockedUart::is_transmit_empty(port) == false {} //TODO:pause
  532. unsafe {
  533. io_out8(port, c);
  534. }
  535. }
  536. ///@brief 从uart接收数据
  537. ///@param port 端口号
  538. ///@return u8 接收到的数据
  539. #[no_mangle]
  540. pub extern "C" fn c_uart_read(port: u16) -> u8 {
  541. while LockedUart::serial_received(port) == false {} //TODO:pause
  542. unsafe { io_in8(port) }
  543. }
  544. ///@brief 通过串口发送整个字符串
  545. ///@param port 串口端口
  546. ///@param str 字符串S
  547. #[no_mangle]
  548. pub extern "C" fn c_uart_send_str(port: u16, s: *const u8) {
  549. unsafe {
  550. let mut i = 0isize;
  551. while *offset(s, i) != '\0' as u8 {
  552. c_uart_send(port, *offset(s, i));
  553. i = i + 1;
  554. }
  555. }
  556. }
  557. /// @brief 串口初始化
  558. /// @param u16 端口号
  559. /// @param baud_rate 波特率
  560. /// @return 初始化成功,返回0,失败,返回错误码
  561. #[no_mangle]
  562. pub extern "C" fn c_uart_init(port: u16, baud_rate: u32) -> i32 {
  563. let message: &'static str = "uart init\n";
  564. // 错误的比特率
  565. if baud_rate > UART_MAX_BITS_RATE || UART_MAX_BITS_RATE % baud_rate != 0 {
  566. return -E_UART_BITS_RATE_ERROR;
  567. }
  568. unsafe {
  569. io_out8(port + 1, 0x00); // Disable all interrupts
  570. io_out8(port + 3, 0x80); // Enable DLAB (set baud rate divisor)
  571. let divisor = UART_MAX_BITS_RATE / baud_rate;
  572. io_out8(port + 0, (divisor & 0xff) as u8); // Set divisor (lo byte)
  573. io_out8(port + 1, ((divisor >> 8) & 0xff) as u8); // CompatibleTable(hi byte)
  574. io_out8(port + 3, 0x03); // 8 bits, no parity, one stop bit
  575. io_out8(port + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold
  576. io_out8(port + 4, 0x08); // IRQs enabled, RTS/DSR clear (现代计算机上一般都不需要hardware flow control,因此不需要置位RTS/DSR)
  577. io_out8(port + 4, 0x1E); // Set in loopback mode, test the serial chip
  578. io_out8(port + 0, 0xAE); // Test serial chip (send byte 0xAE and check if serial returns same byte)
  579. // Check if serial is faulty (i.e: not same byte as sent)
  580. if io_in8(port + 0) != 0xAE {
  581. return -E_UART_SERIAL_FAULT;
  582. }
  583. // If serial is not faulty set it in normal operation mode
  584. // (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
  585. io_out8(port + 4, 0x08);
  586. let bytes = message.as_bytes();
  587. for c in bytes {
  588. c_uart_send(port, *c);
  589. }
  590. }
  591. return UART_SUCCESS;
  592. /*
  593. Notice that the initialization code above writes to [PORT + 1]
  594. twice with different values. This is once to write to the Divisor
  595. register along with [PORT + 0] and once to write to the Interrupt
  596. register as detailed in the previous section.
  597. The second write to the Line Control register [PORT + 3]
  598. clears the DLAB again as well as setting various other bits.
  599. */
  600. }
  601. /// @brief 串口初始化,注册串口
  602. /// @param none
  603. /// @return 初始化成功,返回(),失败,返回错误码
  604. pub fn uart_init() -> Result<(), SystemError> {
  605. // 以后设备管理初始化完善后不应该出现这种代码,应该在 Driver load 一个设备,即返回设备实例之前就完成设备的 init ,不应该用 lazy_init 在设备上
  606. let dev = UART_DEV.0.lock();
  607. LockedUart::uart_init(&dev.port, dev.baud_rate).map_err(|_| SystemError::ENODEV)?;
  608. drop(dev);
  609. let device_inode = bus_device_register("platform:0", &UART_DEV.id_table().name())
  610. .expect("uart device register error");
  611. UART_DEV.set_sys_info(Some(device_inode));
  612. let driver_inode = bus_driver_register("platform:0", &UART_DRV.id_table().name())
  613. .expect("uart driver register error");
  614. UART_DRV.set_sys_info(Some(driver_inode));
  615. UART_DEV.set_state(DeviceState::Initialized);
  616. devfs_register(&UART_DEV.id_table().name(), UART_DEV.clone())?;
  617. DEVICE_MANAGER.add_device(UART_DEV.id_table().clone(), UART_DEV.clone());
  618. return Ok(());
  619. }