基于S3C2440的Linux-3.6.6移植——UART驱动

最新推荐文章于 2023-03-10 23:09:00 发布

zhaocj

最新推荐文章于 2023-03-10 23:09:00 发布

阅读量4.8k

点赞数

分类专栏： arm-linux驱动

本文链接：https://blog.csdn.net/zhaocj/article/details/9086601

版权

arm-linux驱动专栏收录该内容

24 篇文章 5 订阅

订阅专栏

s3c2440串口驱动是在drivers/tty/serial/Samsung.c下定义的。

static int __init s3c24xx_serial_modinit(void)

{

int ret;

//注册uart驱动

ret = uart_register_driver(&s3c24xx_uart_drv);

if (ret < 0) {

printk(KERN_ERR"failed to register UART driver\n");

return -1;

}

//注册平台驱动

returnplatform_driver_register(&samsung_serial_driver);

}

uart驱动的结构为：

static struct uart_driver s3c24xx_uart_drv = {

.owner = THIS_MODULE,

.driver_name = "s3c2410_serial", //驱动名，在/proc/tty/driver/目录下显示的名字

.nr = CONFIG_SERIAL_SAMSUNG_UARTS, //uart的端口数

.cons = S3C24XX_SERIAL_CONSOLE,

.dev_name = S3C24XX_SERIAL_NAME, //设备名——ttySAC

.major = S3C24XX_SERIAL_MAJOR, //主设备号——204

.minor = S3C24XX_SERIAL_MINOR, //次设备号——64

};

平台驱动的结构为：

static struct platform_drivers amsung_serial_driver = {

.probe = s3c24xx_serial_probe,

.remove = __devexit_p(s3c24xx_serial_remove),

.id_table = s3c24xx_serial_driver_ids,

.driver = {

.name = "samsung-uart",

.owner = THIS_MODULE,

.pm = SERIAL_SAMSUNG_PM_OPS,

.of_match_table = s3c24xx_uart_dt_match,

};

知道了平台驱动，那它所对应的平台设备是什么呢？在平台驱动结构中，如果定义了id_table，则需要匹配与id_table列表中一致的设备，如果没有定义id_table，则需要匹配与name一致的设备名。因为在这里定义了.id_table = s3c24xx_serial_driver_ids,，所以系统要匹配与串口驱动列表s3c24xx_serial_driver_ids中定义的驱动名一致的设备名。

static struct platform_device_id s3c24xx_serial_driver_ids[] = {

……

{

.name = "s3c2440-uart",

.driver_data = S3C2440_SERIAL_DRV_DATA,

……

{},

};

由于本开发板是s3c2440，因此设备名一定是s3c2440-uart。另外.driver_data成员主要定义了一些配置s3c2440串口寄存器的数据。

下面介绍一下linux是如何定义串口平台设备的。

在Mach-zhaocj2440.c（在arch/arm/mach-s3c24xx目录下）文件中定义了zhaocj2440_uartcfgs数组（即s3c2440中的三个uart端口寄存器），并且在zhaocj2440_map_io函数内调用s3c24xx_init_uarts函数对其进行初始化，而zhaocj2440_map_io是在MACHINE_START中被赋予.map_io，因此系统一旦启动，开发板上的串口就会被初始化。

我们再来看看uart是如何初始化的。在s3c24xx_init_uarts函数内通过cpu->init_uarts调用s3c244x_init_uarts函数（在arch/arm/mach-s3c24xx/S3c244x.c文件内），而在该函数内又调用s3c24xx_init_uartdevs函数，如：

void __init s3c244x_init_uarts(struct s3c2410_uartcfg *cfg, int no)

{

s3c24xx_init_uartdevs("s3c2440-uart", s3c2410_uart_resources, cfg, no);

}

我们发现传递给s3c24xx_init_uartdevs函数的第一个参数正是"s3c2440-uart"，与上文我们分析的uart平台驱动名是一致的。而第二个参数是串口资源，主要定义了串口寄存器的地址及中断矢量。s3c24xx_init_uartdevs函数（在arch/arm/plat-samsung/Init.c文件内）具体负责uart平台设备的赋值，即定义uart的设备名和端口资源，其中通过platdev->name =name;语句使平台设备的名字为"s3c2440-uart"，这样平台设备和平台驱动就匹配了。并且系统又通过s3c_arch_init函数（仍然在Init.c文件内）调用platform_add_devices函数，使刚刚定义的串口平台设备s3c24xx_uart_devs添加到系统平台设备表中，从而最终完成串口平台设备的定义。

我们再回过头来继续介绍uart的平台驱动。

当设备和驱动匹配上了后，系统会调用s3c24xx_serial_probe函数。

static int s3c24xx_serial_probe(struct platform_device *pdev)

{

structs3c24xx_uart_port *ourport;

intret;

dbg("s3c24xx_serial_probe(%p) %d\n", pdev,probe_index);

//逐一得到s3c2440的uart端口结构——s3c24xx_serial_ports，即s3c2440有几个uart端口，s3c24xx_serial_probe就会被调用几次

ourport= &s3c24xx_serial_ports[probe_index];

//得到驱动数据

ourport->drv_data= s3c24xx_get_driver_data(pdev);

if(!ourport->drv_data) {

dev_err(&pdev->dev,"could not find driver data\n");

return-ENODEV;

}

//得到s3c2440的串口驱动数据信息，即s3c2440_serial_drv_data结构中的info成员信息

ourport->info= ourport->drv_data->info;

//得到uart的相关寄存器

ourport->cfg= (pdev->dev.platform_data) ?

(structs3c2410_uartcfg*)pdev->dev.platform_data :

ourport->drv_data->def_cfg;

//得到uart端口的fifo大小

ourport->port.fifosize= (ourport->info->fifosize) ?

ourport->info->fifosize:

ourport->drv_data->fifosize[probe_index];

probe_index++;

dbg("%s:initialising port %p...\n", __func__, ourport);

//初始化uart的端口

ret= s3c24xx_serial_init_port(ourport,pdev);

if(ret < 0)

gotoprobe_err;

dbg("%s:adding port\n", __func__);

//添加定义好驱动数据的串行端口

uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);

//设置平台驱动数据

platform_set_drvdata(pdev,&ourport->port);

//创建系统文件及属性

ret= device_create_file(&pdev->dev, &dev_attr_clock_source);

if(ret < 0)

dev_err(&pdev->dev,"failed to add clock source attr.\n");

ret= s3c24xx_serial_cpufreq_register(ourport);

if(ret < 0)

dev_err(&pdev->dev,"failed to add cpufreq notifier\n");

return0;

probe_err:

returnret;

}

在s3c24xx_serial_probe函数内，涉及到了两个重要的结构：s3c24xx_serial_ports和s3c2440_serial_drv_data：

static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS]= {

[0]= { //端口0

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[0].port.lock),

.iotype = UPIO_MEM,

.uartclk = 0, //时钟值

.fifosize = 16, //FIFO缓存区大小

.ops = &s3c24xx_serial_ops, //串口相关操作

.flags = UPF_BOOT_AUTOCONF,

.line = 0, //线路

}

[1]= { //端口1

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[1].port.lock),

.iotype = UPIO_MEM,

.uartclk = 0,

.fifosize = 16,

.ops = &s3c24xx_serial_ops,

.flags = UPF_BOOT_AUTOCONF,

.line = 1,

}

#if CONFIG_SERIAL_SAMSUNG_UARTS > 2

[2]= { //端口2

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[2].port.lock),

.iotype = UPIO_MEM,

.uartclk = 0,

.fifosize = 16,

.ops = &s3c24xx_serial_ops,

.flags = UPF_BOOT_AUTOCONF,

.line = 2,

}

#endif

#if CONFIG_SERIAL_SAMSUNG_UARTS > 3

[3]= {

.port= {

.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[3].port.lock),

.iotype = UPIO_MEM,

.uartclk = 0,

.fifosize = 16,

.ops = &s3c24xx_serial_ops,

.flags = UPF_BOOT_AUTOCONF,

.line = 3,

}

#endif

};

static struct s3c24xx_serial_drv_data s3c2440_serial_drv_data= {

.info= &(struct s3c24xx_uart_info){ //uart信息

.name = "Samsung S3C2440 UART",

.type = PORT_S3C2440,

.fifosize = 64,

.has_divslot = 1,

.rx_fifomask = S3C2440_UFSTAT_RXMASK,

.rx_fifoshift = S3C2440_UFSTAT_RXSHIFT,

.rx_fifofull = S3C2440_UFSTAT_RXFULL,

.tx_fifofull = S3C2440_UFSTAT_TXFULL,

.tx_fifomask = S3C2440_UFSTAT_TXMASK,

.tx_fifoshift = S3C2440_UFSTAT_TXSHIFT,

.def_clk_sel = S3C2410_UCON_CLKSEL2,

.num_clks = 4,

.clksel_mask = S3C2412_UCON_CLKMASK,

.clksel_shift = S3C2412_UCON_CLKSHIFT,

.def_cfg= &(struct s3c2410_uartcfg){ //定义缺省的uart寄存器值

.ucon = S3C2410_UCON_DEFAULT,

.ufcon = S3C2410_UFCON_DEFAULT,

};

在s3c24xx_serial_ports中，定义了串口相关操作——s3c24xx_serial_ops：

static struct uart_ops s3c24xx_serial_ops = {

.pm = s3c24xx_serial_pm, //电源管理

.tx_empty = s3c24xx_serial_tx_empty, //发送缓存区空

.get_mctrl = s3c24xx_serial_get_mctrl, //得到modem控制设置

.set_mctrl = s3c24xx_serial_set_mctrl, //设置modem控制

.stop_tx = s3c24xx_serial_stop_tx, //停止发送

.start_tx = s3c24xx_serial_start_tx, //开始发送

.stop_rx = s3c24xx_serial_stop_rx, //停止接受

.enable_ms = s3c24xx_serial_enable_ms, //modem状态中断使能

.break_ctl = s3c24xx_serial_break_ctl, //控制break信号的传输

.startup = s3c24xx_serial_startup, //启动端口

.shutdown = s3c24xx_serial_shutdown, //禁止端口

.set_termios = s3c24xx_serial_set_termios, //设置端口参数

.type = s3c24xx_serial_type, //返回描述特定端口的常量字符串指针

.release_port = s3c24xx_serial_release_port, //释放端口所占的内存和资源

.request_port = s3c24xx_serial_request_port, //申请端口所需的内存和资源

.config_port = s3c24xx_serial_config_port, //配置端口

.verify_port = s3c24xx_serial_verify_port, //验证端口

};

在这里，我们只分析s3c24xx_serial_startup函数和s3c24xx_serial_set_termios函数。

static int s3c24xx_serial_startup(struct uart_port *port)

{

structs3c24xx_uart_port *ourport= to_ourport(port);

intret;

dbg("s3c24xx_serial_startup: port=%p(%08lx,%p)\n",

port->mapbase, port->membase);

rx_enabled(port) = 1; //接收数据使能

//申请接收数据中断，s3c24xx_serial_rx_chars为中断处理函数

ret =request_irq(ourport->rx_irq, s3c24xx_serial_rx_chars,0,

s3c24xx_serial_portname(port),ourport);

if(ret != 0) {

printk(KERN_ERR"cannot get irq %d\n", ourport->rx_irq);

returnret;

}

ourport->rx_claimed= 1; //标志

dbg("requestingtx irq...\n");

tx_enabled(port)= 1; //发送数据使能

//申请发送数据中断，s3c24xx_serial_tx_chars为中断处理函数

ret= request_irq(ourport->tx_irq, s3c24xx_serial_tx_chars,0,

s3c24xx_serial_portname(port),ourport);

if(ret) {

printk(KERN_ERR"cannot get irq %d\n", ourport->tx_irq);

gotoerr;

}

ourport->tx_claimed= 1; //标志

dbg("s3c24xx_serial_startup ok\n");

/*the port reset code should have done the correct

* register setup for the port controls */

returnret;

err:

s3c24xx_serial_shutdown(port);

returnret;

}

static void s3c24xx_serial_set_termios(struct uart_port *port,

struct ktermios *termios,

struct ktermios *old)

{

structs3c2410_uartcfg *cfg = s3c24xx_port_to_cfg(port);

structs3c24xx_uart_port *ourport =to_ourport(port);

structclk *clk = NULL;

unsignedlong flags;

unsignedint baud, quot, clk_sel = 0;

unsignedint ulcon;

unsignedint umcon;

unsignedint udivslot = 0;

* We don't support modem control lines.

//不支持modem控制线

termios->c_cflag&= ~(HUPCL | CMSPAR);

termios->c_cflag|= CLOCAL;

* Ask the core to calculate the divisor forus.

//请求内核计算分频以便产生对应的波特率

baud= uart_get_baud_rate(port, termios, old, 0, 115200*8);

quot= s3c24xx_serial_getclk(ourport,baud, &clk, &clk_sel);

if(baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)

quot= port->custom_divisor;

if(!clk)

return;

/*check to see if we need to change clocksource */

//检查是否需要改变时钟源

if(ourport->baudclk != clk) {

s3c24xx_serial_setsource(port, clk_sel);

if(ourport->baudclk != NULL && !IS_ERR(ourport->baudclk)) {

clk_disable(ourport->baudclk);

ourport->baudclk = NULL;

}

clk_enable(clk);

ourport->baudclk= clk;

ourport->baudclk_rate= clk ? clk_get_rate(clk) : 0;

}

if(ourport->info->has_divslot) {

unsignedint div = ourport->baudclk_rate / baud;

if(cfg->has_fracval) {

udivslot= (div & 15);

dbg("fracval= %04x\n", udivslot);

}else {

udivslot= udivslot_table[div & 15];

dbg("udivslot= %04x (div %d)\n", udivslot, div & 15);

}

//设置字长

switch(termios->c_cflag & CSIZE) {

caseCS5:

dbg("config:5bits/char\n");

ulcon= S3C2410_LCON_CS5;

break;

caseCS6:

dbg("config:6bits/char\n");

ulcon= S3C2410_LCON_CS6;

break;

caseCS7:

dbg("config:7bits/char\n");

ulcon= S3C2410_LCON_CS7;

break;

caseCS8:

default:

dbg("config:8bits/char\n");

ulcon= S3C2410_LCON_CS8;

break;

}

/*preserve original lcon IR settings */

//保留以前的lcon的IR设置

ulcon|= (cfg->ulcon & S3C2410_LCON_IRM);

//设置停止位

if(termios->c_cflag & CSTOPB)

ulcon|= S3C2410_LCON_STOPB;

//设置是否采用RTS、CTS自动流控制

umcon= (termios->c_cflag & CRTSCTS) ? S3C2410_UMCOM_AFC : 0;

//设置奇偶校验位

if(termios->c_cflag & PARENB) {

if(termios->c_cflag & PARODD)

ulcon|= S3C2410_LCON_PODD; //奇校验

else

ulcon|= S3C2410_LCON_PEVEN; //偶校验

}else {

ulcon|= S3C2410_LCON_PNONE; //不校验

}

spin_lock_irqsave(&port->lock,flags);

dbg("settingulcon to %08x, brddiv to %d, udivslot %08x\n",

ulcon, quot, udivslot);

//写入寄存器

wr_regl(port,S3C2410_ULCON, ulcon);

wr_regl(port,S3C2410_UBRDIV, quot);

wr_regl(port,S3C2410_UMCON, umcon);

if(ourport->info->has_divslot)

wr_regl(port,S3C2443_DIVSLOT, udivslot);

dbg("uart:ulcon = 0x%08x, ucon = 0x%08x, ufcon = 0x%08x\n",

rd_regl(port, S3C2410_ULCON),

rd_regl(port, S3C2410_UCON),

rd_regl(port, S3C2410_UFCON));

* Update the per-port timeout.

//更新端口超时

uart_update_timeout(port,termios->c_cflag, baud);

* Which character status flags are weinterested in?

//对哪些字符状态标志感兴趣

port->read_status_mask= S3C2410_UERSTAT_OVERRUN;

if(termios->c_iflag & INPCK)

port->read_status_mask|= S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_PARITY;

* Which character status flags should weignore?

//可以忽略哪些字符状态标志

port->ignore_status_mask= 0;

if(termios->c_iflag & IGNPAR)

port->ignore_status_mask|= S3C2410_UERSTAT_OVERRUN;

if(termios->c_iflag & IGNBRK && termios->c_iflag & IGNPAR)

port->ignore_status_mask|= S3C2410_UERSTAT_FRAME;

* Ignore all characters if CREAD is not set.

//如果CREAD未设置，忽略所有字符

if((termios->c_cflag & CREAD) == 0)

port->ignore_status_mask|= RXSTAT_DUMMY_READ;

spin_unlock_irqrestore(&port->lock,flags);

}

下面再来介绍串口接收和发送中断处理函数。

static irqreturn_t s3c24xx_serial_rx_chars(intirq, void *dev_id)

{

structs3c24xx_uart_port *ourport= dev_id;

struct uart_port *port =&ourport->port;

struct tty_struct*tty = port->state->port.tty;

unsignedint ufcon, ch, flag, ufstat, uerstat;

intmax_count = 64;

while(max_count-- > 0) {

ufcon= rd_regl(port, S3C2410_UFCON);

ufstat= rd_regl(port, S3C2410_UFSTAT);

//如果接收到0个字符，则退出

if(s3c24xx_serial_rx_fifocnt(ourport,ufstat) == 0)

break;

uerstat= rd_regl(port, S3C2410_UERSTAT); //读取错误状态信息

ch= rd_regb(port, S3C2410_URXH); //，读取字符，接收数据

if(port->flags & UPF_CONS_FLOW) {

inttxe = s3c24xx_serial_txempty_nofifo(port);

if(rx_enabled(port)) { //如果接收端口为使能状态

if(!txe) { //如果发送缓存为空

rx_enabled(port)= 0; //设置接收端口为无效状态

continue;

}

}else { //接收端口为无效状态

if(txe) { //如果发送缓存不为空

ufcon|= S3C2410_UFCON_RESETRX;

wr_regl(port,S3C2410_UFCON, ufcon); //发送缓存复位，即清空

rx_enabled(port)= 1; //设置接收端口为使能状态

gotoout;

}

continue;

}

/*insert the character into the buffer */

//将接收到的字符写入进buffer中

flag = TTY_NORMAL;

port->icount.rx++;

//如果接收字符时，发生了任何一种错误

if(unlikely(uerstat & S3C2410_UERSTAT_ANY)){

dbg("rxerr: port ch=0x%02x,rxs=0x%08x\n",

ch, uerstat);

/*check for break */

//发生了break错误

if(uerstat & S3C2410_UERSTAT_BREAK){

dbg("break!\n");

port->icount.brk++;

if(uart_handle_break(port))

goto ignore_char;

}

if(uerstat & S3C2410_UERSTAT_FRAME) //发生了帧错误

port->icount.frame++;

if(uerstat & S3C2410_UERSTAT_OVERRUN) //发生了溢出错误

port->icount.overrun++;

uerstat&= port->read_status_mask;

if(uerstat & S3C2410_UERSTAT_BREAK)

flag= TTY_BREAK;

elseif (uerstat & S3C2410_UERSTAT_PARITY)

flag= TTY_PARITY;

elseif (uerstat & (S3C2410_UERSTAT_FRAME|

S3C2410_UERSTAT_OVERRUN))

flag = TTY_FRAME;

}

if(uart_handle_sysrq_char(port, ch))

gotoignore_char;

//把字符插入到tty设备的flip缓存

uart_insert_char(port,uerstat, S3C2410_UERSTAT_OVERRUN,

ch, flag);

ignore_char:

continue;

}

tty_flip_buffer_push(tty); //刷新tty设备的flip设备

out:

returnIRQ_HANDLED;

}

static irqreturn_t s3c24xx_serial_tx_chars(intirq, void *id)

{

structs3c24xx_uart_port *ourport= id;

struct uart_port *port =&ourport->port;

struct circ_buf*xmit = &port->state->xmit;

intcount = 256; //一次最多发送256个字符

if(port->x_char) { //如果有待发送的字符，则发送

wr_regb(port, S3C2410_UTXH, port->x_char);

port->icount.tx++;

port->x_char = 0;

goto out;

}

/*if there isn't anything more to transmit, or the uart is now

* stopped, disable the uart and exit

//如果没有更多的字符需要发送，或者uart的tx停止，则停止uart并退出

if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {

s3c24xx_serial_stop_tx(port);

gotoout;

}

/*try and drain the buffer... */

//尝试把环形buffer中的数据发空

while(!uart_circ_empty(xmit) && count-- > 0) {

if(rd_regl(port, S3C2410_UFSTAT)& ourport->info->tx_fifofull)

break;

wr_regb(port,S3C2410_UTXH,xmit->buf[xmit->tail]);

xmit->tail = (xmit->tail + 1) &(UART_XMIT_SIZE - 1);

port->icount.tx++;

}

//如果环形缓存中剩余的字符少于WAKEUP_CHARS，唤醒上层

if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)

uart_write_wakeup(port);

if(uart_circ_empty(xmit)) //如果发送环形buffer为空

s3c24xx_serial_stop_tx(port); //停止发送

out:

returnIRQ_HANDLED;

}

最后，我们再来看串口驱动的核心层文件——Serial_core.c（在drivers/tty/serial目录下）。前面介绍的在Samsung.c中调用的许多与底层打交道的函数都是在Serial_core.c内定义的，如

uart_register_driver函数，uart_add_one_port函数，uart_insert_char函数。

在uart_register_driver函数中，设置了uart_ops，它负责对uart镜像一系列操作。

static const struct tty_operations uart_ops= {

.open = uart_open, //打开串口

.close = uart_close, //关闭串口

.write = uart_write, //发送串口数据

.put_char = uart_put_char,

.flush_chars = uart_flush_chars,

.write_room = uart_write_room,

.chars_in_buffer=uart_chars_in_buffer,

.flush_buffer = uart_flush_buffer,

.ioctl = uart_ioctl,

.throttle = uart_throttle,

.unthrottle = uart_unthrottle,

.send_xchar = uart_send_xchar,

.set_termios = uart_set_termios,

.set_ldisc = uart_set_ldisc,

.stop = uart_stop,

.start = uart_start,

.hangup = uart_hangup,

.break_ctl = uart_break_ctl,

.wait_until_sent=uart_wait_until_sent,

#ifdef CONFIG_PROC_FS

.proc_fops = &uart_proc_fops,

#endif

.tiocmget = uart_tiocmget,

.tiocmset = uart_tiocmset,

.get_icount = uart_get_icount,

#ifdef CONFIG_CONSOLE_POLL

.poll_init = uart_poll_init,

.poll_get_char = uart_poll_get_char,

.poll_put_char = uart_poll_put_char,

#endif

};

打开串口的函数调用过程为：uart_openÞ uart_startup Þ uart_port_startupÞ uport->ops->startup，最终调用了Samsung.c文件中的s3c24xx_serial_startup函数。

关闭串口的函数调用过程为：uart_closeÞ uart_shutdown Þ uart_port_shutdownÞ uport->ops->shutdown，最终调用了Samsung.c文件中的s3c24xx_serial_shutdown函数。

发送串口数据的函数调用过程为：uart_write Þ uart_startÞ __uart_start Þ port->ops->start_tx，最终调用了Samsung.c文件中的s3c24xx_serial_start_tx函数。

串口驱动就介绍到这里，在系统启动过程中，会打印一些关于串口的信息，如：

s3c2440-uart.0: ttySAC0 at MMIO 0x50000000(irq = 70) is a S3C2440

console[ttySAC0] enabled

s3c2440-uart.1: ttySAC1 at MMIO 0x50004000(irq = 73) is a S3C2440

s3c2440-uart.2: ttySAC2 at MMIO 0x50008000(irq = 76) is a S3C2440

从上面的信息可以看出，uart0被用做了控制台，另外还有uart1和uart2可以使用。另外，系统启动后，通过下面指令，也可以查看一下串口信息：

[root@zhaocj/]#cat /proc/tty/driver/s3c2410_serial

serinfo:1.0driver revision:

0:uart:S3C2440mmio:0x50000000 irq:70 tx:2987 rx:134 RTS|CTS|DTR|DSR|CD

1:uart:S3C2440mmio:0x50004000 irq:73 tx:0 rx:0 DSR|CD

2:uart:S3C2440mmio:0x50008000 irq:76 tx:0 rx:0 DSR|CD

zhaocj

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
3
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录