Linux uart底层设备驱动详解

本文是基于mini2440开发板Linux版本号是linux-2.6.32.2的学习笔记

一. uart 基本信息

S3C2440A提供了3个独立的串口。
串口的操作使用中断或DMA模式。
串口的接受和发送缓存为 64-byte。

二. uart硬件初始化

uart初始化调用的函数是：s3c24xx_init_uarts，这个函数被mini2440_map_io调用，mini2440_map_io函数赋值给了machine_desc.map_io函数。machine_desc.map_io函数在start_kernel函数里面调用。
s3c24xx_init_uarts函数传参（mini2440_uartcfgs，3），如下所示：

static struct s3c2410_uartcfg mini2440_uartcfgs[] __initdata =
{[0] = {.hwport         = 0,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,},[1] = {.hwport       = 1,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,},[2] = {.hwport       = 2,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,}
};

.hwport是硬件端口号，其他的结构体成员暂时往后看。

s3c24xx_init_uarts函数调用cpu->init_uarts函数。

void __init s3c24xx_init_uarts(struct s3c2410_uartcfg *cfg, int no)
{if (cpu == NULL)return;if (cpu->init_uarts == NULL){printk(KERN_ERR "s3c24xx_init_uarts: cpu has no uart init\n");}else(cpu->init_uarts)(cfg, no);}

.init_uarts  = s3c244x_init_uarts,

最终调用的是s3c244x_init_uarts函数。

s3c244x_init_uarts函数，传入了参数s3c2410_uart_resources

void __init s3c244x_init_uarts(struct s3c2410_uartcfg *cfg, int no)
{s3c24xx_init_uartdevs("s3c2440-uart", s3c2410_uart_resources, cfg, no);
}

static struct resource s3c2410_uart0_resource[] =
{[0] = {.start = S3C2410_PA_UART0,.end   = S3C2410_PA_UART0 + 0x3fff,.flags = IORESOURCE_MEM,},[1] = {.start = IRQ_S3CUART_RX0,.end   = IRQ_S3CUART_ERR0,.flags = IORESOURCE_IRQ,}
};static struct resource s3c2410_uart1_resource[] =
{[0] = {.start = S3C2410_PA_UART1,.end   = S3C2410_PA_UART1 + 0x3fff,.flags = IORESOURCE_MEM,},[1] = {.start = IRQ_S3CUART_RX1,.end   = IRQ_S3CUART_ERR1,.flags = IORESOURCE_IRQ,}
};static struct resource s3c2410_uart2_resource[] =
{[0] = {.start = S3C2410_PA_UART2,.end   = S3C2410_PA_UART2 + 0x3fff,.flags = IORESOURCE_MEM,},[1] = {.start = IRQ_S3CUART_RX2,.end   = IRQ_S3CUART_ERR2,.flags = IORESOURCE_IRQ,}
};static struct resource s3c2410_uart3_resource[] =
{[0] = {.start = S3C2443_PA_UART3,.end   = S3C2443_PA_UART3 + 0x3fff,.flags = IORESOURCE_MEM,},[1] = {.start = IRQ_S3CUART_RX3,.end   = IRQ_S3CUART_ERR3,.flags = IORESOURCE_IRQ,},
};struct s3c24xx_uart_resources s3c2410_uart_resources[] __initdata =
{[0] = {.resources = s3c2410_uart0_resource,.nr_resources = ARRAY_SIZE(s3c2410_uart0_resource),},[1] = {.resources  = s3c2410_uart1_resource,.nr_resources = ARRAY_SIZE(s3c2410_uart1_resource),},[2] = {.resources  = s3c2410_uart2_resource,.nr_resources = ARRAY_SIZE(s3c2410_uart2_resource),},[3] = {.resources  = s3c2410_uart3_resource,.nr_resources = ARRAY_SIZE(s3c2410_uart3_resource),},
};

nr_resources = 2

s3c24xx_init_uartdevs函数分析
对platdev填充name,resource,num_resources,dev.platform_data等结构体成员，然后把platdev赋值给了s3c24xx_uart_devs全局变量，最终结果如下：

s3c24xx_uart_devs[0] =
{.name = "s3c2440-uart",.id = 0,.resource ={[0] = {.start = S3C2410_PA_UART0,.end   = S3C2410_PA_UART0 + 0x3fff,.flags = IORESOURCE_MEM,},[1] = {.start = IRQ_S3CUART_RX0,.end   = IRQ_S3CUART_ERR0,.flags = IORESOURCE_IRQ,}},.num_resources = 2,.dev.platform_data = {[0] = {.hwport      = 0,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,},[1] = {.hwport       = 1,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,},[2] = {.hwport       = 2,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,}},
}；

三. uart device注册

从上一步看，uart device 设备为s3c24xx_uart_devs，device个数为3.
uart设备在哪里注册呢，可以看到在s3c_arch_init函数中注册了uart设备。

static int __init s3c_arch_init(void)
{int ret;// do the correct init for cpuif (cpu == NULL)panic("s3c_arch_init: NULL cpu\n");ret = (cpu->init)();if (ret != 0)return ret;ret = platform_add_devices(s3c24xx_uart_devs, nr_uarts);return ret;
}

s3c_arch_init函数又是什么时候调用呢？通过arch_initcall(s3c_arch_init)可知，s3c_arch_init函数在内核启动时被调用。

platform_add_devicesplatform_device_add(pdev);if (pdev->id != -1)dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);elsedev_set_name(&pdev->dev, "%s", pdev->name);

pdev->id = 0,1,2, 最终注册的设备为s3c2440-uart.0，s3c2440-uart.1，s3c2440-uart.2
设备路径：/sys/devices/platform/s3c2440-uart.0
/sys/devices/platform/s3c2440-uart.1
/sys/devices/platform/s3c2440-uart.2

四. uart driver的注册

搜索设备名s3c2440-uart,找到uart driver的注册文件/drivers/serial/s3c2440.c文件
在s3c2440.c文件中platform_driver的定义如下：

static struct platform_driver s3c2440_serial_driver =
{.probe     = s3c2440_serial_probe,.remove     = __devexit_p(s3c24xx_serial_remove),.driver       = {.name   = "s3c2440-uart",.owner  = THIS_MODULE,},
};

最后通过调用platform_driver_register函数注册uart driver。

driver在/sys/bus/platform/drivers/s3c2440-uart目录下。

五. uart driver的probe函数

uart driver的probe函数为s3c2440_serial_probe，但是s3c2440_serial_probe函数又调用了s3c24xx_serial_probe函数，s3c24xx_serial_probe函数传参s3c2440_uart_inf，如下所示：

#define S3C2440_UFSTAT_TXFULL      (1<<14)
#define S3C2440_UFSTAT_RXFULL     (1<<6)
#define S3C2440_UFSTAT_TXSHIFT    (8)
#define S3C2440_UFSTAT_RXSHIFT    (0)
#define S3C2440_UFSTAT_TXMASK     (63<<8)
#define S3C2440_UFSTAT_RXMASK     (63)static struct s3c24xx_uart_info s3c2440_uart_inf =
{.name      = "Samsung S3C2440 UART",.type       = PORT_S3C2440,.fifosize   = 64,.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,.get_clksrc   = s3c2440_serial_getsource,.set_clksrc = s3c2440_serial_setsource,.reset_port = s3c2440_serial_resetport,
};

.fifosize = 64：表示缓冲buffer为64byte。
.rx_fifomask = 63：读缓冲buffer count正常取值为0 ~ 63，否则就是读缓冲buffer满了。
.rx_fifoshift = 0：因为 Rx FIFO Count为【5:0】，不需要移动
rx_fifofull = (1<<6)：表示读缓冲buffer满了
.tx_fifofull = (1<<14)：写缓冲buffer满了
.tx_fifomask = (63<<8)：写缓冲buffer count正常取值为0 ~ 63，但是要右移8位
.tx_fifoshift = (8)：写缓冲buffer count需要右移8位

s3c2440_serial_getsource，，s3c2440_serial_resetport几个函数放在后面看。

s3c2440_serial_setsource
设置时钟源，总共有3种类型时钟给串口使用： PCLK, UEXTCLK or FCLK/n。
当选择FCLK/n时钟时，要通过 UCON寄存器的[15:12]设置n值。
uart clock = FCLK / (divider+6)
n = divider+6
当设置UCON0时， 7<= n <= 21; UCON1,UCON2要设置为0
当设置UCON1时， 22 <= n <= 36 UCON0，UCON2要设置为0
当设置UCON2时， 37 <= n <= 43 UCON0，UCON1要设置为0

设置PCLK, UCON的[11:10]设置为0,2
设置UCLK, UCON的[11:10]设置为1
设置FCLK/n, UCON的[11:10]设置为3

static int s3c2440_serial_setsource(struct uart_port *port, struct s3c24xx_uart_clksrc *clk)
{unsigned long ucon = rd_regl(port, S3C2410_UCON);/* todo - proper fclk<>nonfclk switch. */ucon &= ~S3C2440_UCON_CLKMASK;if (strcmp(clk->name, "uclk") == 0)ucon |= S3C2440_UCON_UCLK;else if (strcmp(clk->name, "pclk") == 0)ucon |= S3C2440_UCON_PCLK;else if (strcmp(clk->name, "fclk") == 0)ucon |= S3C2440_UCON_FCLK;else {printk(KERN_ERR "unknown clock source %s\n", clk->name);return -EINVAL;}wr_regl(port, S3C2410_UCON, ucon);return 0;
}

s3c2440_serial_getsource
读UCON寄存器的[11:10]，判断时钟源是PCLK, UEXTCLK or FCLK/n。
如果是PCLK，UEXTCLK时钟源，clk->divisor = 1，如果是FCLK/n时钟，clk->divisor需要根据UCON寄存器的[15:12]获得。

现在看s3c24xx_serial_probe函数。

端口初始化，端口是全局变量s3c24xx_serial_ports。调用函数s3c24xx_serial_init_port。s3c24xx_serial_ports变量里面有个uart_port类型的变量，主要是给该变量赋值。
①保存info结构体

ourport->info = info;

②ourport->port.fifosize = info->fifosize = 64，之前给的默认值是16
③获取mem资源，保存在port->mapbase和port->membase变量中

res = platform_get_resource(platdev, IORESOURCE_MEM, 0);
if (res == NULL) {printk(KERN_ERR "failed to find memory resource for uart\n");return -EINVAL;
}
dbg("resource %p (%lx..%lx)\n", res, res->start, res->end);port->mapbase = res->start;
port->membase = S3C_VA_UART + res->start - (S3C_PA_UART & 0xfff00000);

④获取终端号，保存在ourport->rx_irq和ourport->tx_irq变量中

ret = platform_get_irq(platdev, 0);
if (ret < 0)port->irq = 0;
else {port->irq = ret;ourport->rx_irq = ret;ourport->tx_irq = ret + 1;

⑤获取uart时钟，保存在ourport->clk中

ourport->clk  = clk_get(&platdev->dev, "uart");

⑥reset fifo，设置串口，调用函数s3c24xx_serial_resetport，实际是调用s3c2440_uart_inf的reset_port函数。
就是s3c2440_serial_resetport函数。s3c2440_serial_resetport函数设置了下面的几步的寄存器。

static struct s3c2410_uartcfg mini2440_uartcfgs[] __initdata = {[0] = {.hwport      = 0,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,},
};

⑦给UCON0寄存器追加写入0x3c5（1111000101）
1：发送时产生电平中断（而不是脉冲中断）
1：接收时产生电平中断
1：允许接收时产生超时中断
1：允许接收时产生错误中断
0：一般模式，不用回环模式，就是一个串口的RX接TX
0：不发送break信号
01：中断或者轮询方式发送数据
01：中断或者轮询方式接收数据

⑧给 ULCON0寄存器写入0x03（00000011）
0：普通模式（而不是红外模式）
000：无校验位
0： 1个停止位
11： 8个数据位

⑨给 UFCON0寄存器写入0x51（1010001）
01： Tx FIFO Trigger Level = 16-byte
01： Rx FIFO Trigger Level = 8-byte
0：Reserved
0：
0：
1：使能FIFO

调用uart_add_one_port函数，uart_add_one_port函数里面主要是注册tty设备。
注册后的设备为s3c2410_serial0，在目录：/sys/devices/platform/s3c2440-uart.0/tty下面。

六. ktermios结构体

ktermios结构体结构体定义如下：

struct ktermios
{tcflag_t c_iflag;      /* input mode flags */tcflag_t c_oflag;     /* output mode flags */tcflag_t c_cflag;        /* control mode flags */tcflag_t c_lflag;       /* local mode flags */cc_t c_line;          /* line discipline */cc_t c_cc[NCCS];       /* control characters */speed_t c_ispeed;       /* input speed */speed_t c_ospeed;      /* output speed */
};

下面参考大牛的博客
c_iflag常用的如下：
IGNBRK：忽略输入中的 BREAK 状态
BRKINT
IGNPAR：忽略桢错误和奇偶校验错
PARMRK：如果没有设置 IGNPAR，在有奇偶校验错或桢错误的字符前插入 /377 /0。如果既没有设置 IGNPAR 也没有设置PARMRK，将有奇偶校验错或桢错误的字符视为 /0
INPCK：启用输入奇偶检测
ISTRIP：去掉第八位
INLCR：将输入中的 NL 翻译为 CR
IGNCR：忽略输入中的回车
ICRNL：将输入中的回车翻译为新行 (除非设置了 IGNCR)
IUCLC：将输入中的大写字母映射为小写字母
IXON：启用输入的XON流控制
IXANY：允许任何字符来重新开始输出
IXOFF：启用输入的XFF流控制

c_oflag常用的如下：
OPOST:启用具体实现自行定义的输出处理。
OLCUC:将输出中的小写字母映射为大写字母。
ONLCR:将输出中的新行符映射为回车-换行。
OCRNL:将输出中的回车映射为新行符
ONOCR:不在第 0 列输出回车。
ONLRET:不输出回车。
OFILL:发送填充字符作为延时，而不是使用定时来延时。
OFDEL:填充字符是 ASCII DEL (0177)。如果不设置，填充字符则是 ASCII NUL。
NLDLY:新行延时掩码。取值为 NL0 和 NL1。
CRDLY:回车延时掩码。取值为 CR0, CR1, CR2, 或 CR3。
TABDLY:水平跳格延时掩码。取值为 TAB0, TAB1, TAB2, TAB3 (或 XTABS)。取值为 TAB3，即 XTABS，将扩展跳格为空格 (每个跳格符填充 8 个空格)。
BSDLY:回退延时掩码。取值为 BS0 或 BS1。(从来没有被实现过)
VTDLY:竖直跳格延时掩码。取值为 VT0 或 VT1。
FFDLY:进表延时掩码。取值为 FF0 或 FF1。

c_cflag 标志常量：
CBAUD:波特率掩码 (4+1 位)。
CBAUDEX:扩展的波特率掩码 (1 位)，包含在 CBAUD 中。
CSIZE:字符长度掩码。取值为 CS5, CS6, CS7, 或 CS8。
CSTOPB:设置两个停止位，而不是一个。
CREAD:打开接受者。
PARENB:允许输出产生奇偶信息以及输入的奇偶校验。
PARODD:输入和输出是奇校验。
HUPCL:在最后一个进程关闭设备后，降低 modem 控制线 (挂断)。
CLOCAL:忽略 modem 控制线。
LOBLK:从非当前 shell 层阻塞输出(用于 shl )。(?)
CIBAUD:输入速度的掩码。CIBAUD 各位的值与 CBAUD 各位相同，左移了 IBSHIFT 位。
CRTSCTS:启用 RTS/CTS (硬件) 流控制。

七. uart_ops结构体

在上面的probe函数中，有个重要的结构体uart_ops，这个结构体定义了uart驱动层的操作。

static struct uart_ops s3c24xx_serial_ops =
{.pm        = s3c24xx_serial_pm,                            //电源管理.tx_empty    = s3c24xx_serial_tx_empty,              //检测发送缓冲区是否为空.get_mctrl    = s3c24xx_serial_get_mctrl,              //获取串口是否流控.set_mctrl  = s3c24xx_serial_set_mctrl,               //设置串口流控.stop_tx = s3c24xx_serial_stop_tx,                  //停止发送.start_tx = s3c24xx_serial_start_tx,                  //启动发送.stop_rx = s3c24xx_serial_stop_rx,                 //停止接收.enable_ms = s3c24xx_serial_enable_ms,.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_tx_empty函数分析
该函数是判断发送端是否为空
①读 UFCON0寄存器，判断第0位是否为1，为1表示FIFO模式，为0表示非FIFO模式
②FIFO模式下，判断 UFSTAT0寄存器的 Tx FIFO Count是否为0，或者判断 Tx FIFO Full标志位，为空返回1，否则返回0.

if (ufcon & S3C2410_UFCON_FIFOMODE)
{if ((ufstat & info->tx_fifomask) != 0 ||(ufstat & info->tx_fifofull))return 0;return 1;
}

③非FIFO模式下，判断 UTRSTAT0寄存器的第2位，为1表示空了。

static int s3c24xx_serial_txempty_nofifo(struct uart_port *port)
{return (rd_regl(port, S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE);
}

s3c24xx_serial_get_mctrl和s3c24xx_serial_set_mctrl
硬件流控函数
s3c24xx_serial_stop_tx
TX disable，就是把port->unused[0]设置为0，如果是流控的话，还要调用s3c24xx_serial_rx_enable函数打开串口的流控制接收。
s3c24xx_serial_start_tx
TX enable,就是把port->unused[0]设置为1，如果是流控的话，还要调用s3c24xx_serial_rx_disable函数停止串口的流控制接收。
s3c24xx_serial_stop_rx
RX disable, 就是把port->unused[1]设置为0
s3c24xx_serial_break_ctl
设置 UCON寄存器的第4位，写1表示发送break信号

#define S3C2410_UCON_SBREAK    (1<<4)
ucon = rd_regl(port, S3C2410_UCON);
ucon |= S3C2410_UCON_SBREAK;
wr_regl(port, S3C2410_UCON, ucon);

s3c24xx_serial_startup
RX enable， TX enable, 申请串口接收和发送中断

rx_enabled(port) = 1;
ret = request_irq(ourport->rx_irq, s3c24xx_serial_rx_chars, 0, s3c24xx_serial_portname(port), ourport);tx_enabled(port) = 1;
ret = request_irq(ourport->tx_irq, s3c24xx_serial_tx_chars, 0, s3c24xx_serial_portname(port), ourport);

s3c24xx_serial_shutdown
TX disable，释放TX中断
RX disable，释放RX中断

free_irq(ourport->tx_irq, ourport);
tx_enabled(port) = 0;free_irq(ourport->rx_irq, ourport);
rx_enabled(port) = 0;

s3c24xx_serial_set_termios
在注册uart driver时，init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;串口core层调用uart_ops的set_termios函数时，会传入这个init_termios.c_cflag。
①不支持流控制

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

HUPCL:在最后一个进程关闭设备后，降低 modem 控制线 (挂断)。
CLOCAL:忽略 modem 控制线。
②根据termios找到对用的波特率，init_termios.c_cflag |= B9600，返回波特率baud = 9600

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

③计算分频系数，分频系数的计算公式为： UBRDIVn = (int)( UART clock / ( buad rate x 16) ) –1

quot = s3c24xx_serial_getclk(port, &clksrc, &clk, baud);

最后将分频系数写入 UBRDIV寄存器

wr_regl(port, S3C2410_UBRDIV, quot);

④获取到时钟源clksrc，clk

⑤刚开始的时候ourport->clksrc = NULL, ourport->baudclk = NULL
需要将时钟源写入 UCON[11:10]

s3c24xx_serial_setsource(port, clksrc);

使能时钟

clk_enable(clk);

将时钟源保存起来，下次时钟源没有更新的时候不用重新设置上面的步骤

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

⑥ULCON寄存器的设置
设置数据位数，init_termios.c_cflag |= CS8，数据是8位

#define S3C2410_LCON_CS8   (0x3)
ulcon = S3C2410_LCON_CS8;

是否设置2个停止位，我们这里不用设置

#define S3C2410_LCON_STOPB     (1<<2)
if (termios->c_cflag & CSTOPB)ulcon |= S3C2410_LCON_STOPB;

是否设置奇偶校验位，我们这里没有奇偶校验

if (termios->c_cflag & PARENB)
{if (termios->c_cflag & PARODD)ulcon |= S3C2410_LCON_PODD;elseulcon |= S3C2410_LCON_PEVEN;
}
else
{ulcon |= S3C2410_LCON_PNONE;
}

⑦UMCON寄存器的设置，主要是设置流控制，我们这里不用流控制

#define  S3C2410_UMCOM_AFC     (1<<4)
umcon = (termios->c_cflag & CRTSCTS) ? S3C2410_UMCOM_AFC : 0;
wr_regl(port, S3C2410_UMCON, umcon);

⑧给port->read_status_mask赋值
接收溢出错误中断：port->read_status_mask = S3C2410_UERSTAT_OVERRUN;
如果启用检验：
port->read_status_mask |= S3C2410_UERSTAT_FRAME | S3C2410_UERSTAT_PARITY;
我们这里是没有启用校验的。
⑨给port->ignore_status_mask赋值

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;

一定要init_termios.c_cflag |= CREAD，不然会忽略所有的输入字符

if ((termios->c_cflag & CREAD) == 0)port->ignore_status_mask |= RXSTAT_DUMMY_READ;

八. 串口中断模式下接收数据

Rx FIFO Trigger Level = 8-byte，即缓存中超过了8个字节数据，就会产生中断。

读 UFSTAT寄存器，获取缓存中有多少个数据。如果没有数据，退出。

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

从URXH寄存器中读取一个字符，并且port->icount.rx计数加1。

ch = rd_regb(port, S3C2410_URXH);
port->icount.rx++;

读错误状态寄存器 UERSTAT
如果收到break信号，port->icount.brk加1；
如果产生 Frame Error，port->icount.frame加1；

if (uerstat & S3C2410_UERSTAT_FRAME)port->icount.frame++;

如果产生溢出，port->icount.overrun加1

if (uerstat & S3C2410_UERSTAT_OVERRUN)port->icount.overrun++;

将读到的字符放入tty->buffer中。调用函数uart_insert_char。

uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN, ch, flag);

缓存中的数据读完了，退出while循环，调用tty_flip_buffer_push函数，将数据push到上层。

tty_flip_buffer_push(tty);

九. 串口中断模式下发送数据

如果是软件流控字符（xon/xoff char），将字符写入UTXH寄存器后退出。

if (port->x_char)
{wr_regb(port, S3C2410_UTXH, port->x_char);port->icount.tx++;port->x_char = 0;goto out;
}

如果xmit这个环形buffer是空的，或者串口被停止了，TX disable

if (uart_circ_empty(xmit) || uart_tx_stopped(port))
{s3c24xx_serial_stop_tx(port);goto out;
}

把xmit这个环形buffer的数据一个一个写入到UTXH寄存器，直到TX缓存满了，或者xmit buffer空了，
同时port->icount.tx加1.

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++;
}

退出上面的写这个步骤，判断一下xmit buffer剩余的字符，如果小于一半,唤醒tty，请求注入更多的数据。

if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)uart_write_wakeup(port);tasklet_schedule(&state->tlet);tasklet_init(&state->tlet, uart_tasklet_action, (unsigned long)state);tty_wakeup(state->port.tty);

如果xmit buffer空了，TX disable掉。

if (uart_circ_empty(xmit))s3c24xx_serial_stop_tx(port);

十. 串口计算分频系数

计算分频系数调用的函数是：

static int s3c24xx_serial_calcbaud(struct baud_calc *calc, struct uart_port *port,struct s3c24xx_uart_clksrc *clksrc, unsigned int baud)
{struct s3c24xx_uart_port *ourport = to_ourport(port);unsigned long rate;calc->src = clk_get(port->dev, clksrc->name);if (calc->src == NULL || IS_ERR(calc->src))return 0;rate = clk_get_rate(calc->src);rate /= clksrc->divisor;calc->clksrc = clksrc;if (ourport->info->has_divslot){unsigned long div = rate / baud;/* The UDIVSLOT register on the newer UARTs allows us to* get a divisor adjustment of 1/16th on the baud clock.** We don't keep the UDIVSLOT value (the 16ths we calculated* by not multiplying the baud by 16) as it is easy enough* to recalculate.*/calc->quot = div / 16;calc->calc = rate / div;} else {calc->quot = (rate + (8 * baud)) / (16 * baud);calc->calc = (rate / (calc->quot * 16));}calc->quot--;return 1;
}

分频系数的计算公式为： UBRDIVn = (int)( UART clock / ( buad rate x 16) ) –1
获取时钟源，这里的时钟源应该是PCLK，假设为100M
rate = 100000000Hz。
因为是PCLK，clksrc->divisor = 1，因此rate还是100000000Hz
ourport->info->has_divslot这个变量没有定义，因此：
calc->quot = (rate + (8 * baud)) / (16 * baud);
calc->calc = (rate / (calc->quot * 16));
按照计算公式，calc->quot = (rate ) / (16 * baud)，可是为什么这里
calc->quot = (rate + (8 * baud)) / (16 * baud)？
原因是：calc->quot值要进行四舍五入。
最后，calc->quot要减1才是实际的值。

十一. s3c24xx_serial_getclk函数

获取s3c2410_uartcfg时钟的个数，s3c2410_uartcfg在mach-mini2440.c定义如下：

static struct s3c2410_uartcfg mini2440_uartcfgs[] __initdata =
{[0] = {.hwport         = 0,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,},[1] = {.hwport       = 1,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,},[2] = {.hwport       = 2,.flags         = 0,.ucon      = 0x3c5,.ulcon         = 0x03,.ufcon      = 0x51,}
};

没有定义cfg->clocks_size，那么cfg->clocks_size = 0
当cfg->clocks_size = 0时，采用默认的时钟pclk

static struct s3c24xx_uart_clksrc tmp_clksrc =
{.name      = "pclk",.min_baud   = 0,.max_baud  = 0,.divisor   = 1,
};

最终函数输出：*clksrc = tmp_clksrc
*clk = pclk

但是如果有多个时钟呢，最终采用哪一个时钟？
每个时钟都计算出一个波特率的值，这几个值都比较接近传入的baud的值。并且让resptr指针指向所有时钟源的数组的末尾。

for (i = 0; i < cfg->clocks_size; i++, clkp++)
{if (s3c24xx_serial_calcbaud(resptr, port, clkp, baud))resptr++;
}

把每一个时钟源计算出来的波特率值sptr->calc与原来的baud比较，哪一个值最接近baud，就把哪一个作为uart的时钟源。

for (sptr = res; sptr < resptr; sptr++)
{calc_deviation = baud - sptr->calc;if (calc_deviation < 0)calc_deviation = -calc_deviation;if (calc_deviation < deviation) {best = sptr;deviation = calc_deviation;}
}

参考：

https://www.cnblogs.com/colife/p/5531093.html