Linux内核修改：将2440串口UART2（红外端口）更成普通串口驱动

前言：S3C2440 芯片具有3 个串口：UART0,1,2，我们下载的Linux-2.6.28.7 对他们有很好的支持。默认驱动是：UART0,1 是普通串口，但对UART2 却用作了红外通讯(Irda)，如果想把UART2作为普通串口用，需要修改UART2 驱动代码，重新编译。具体细节不太了解，但一下方法经测试，可行。

1，环境

主机环境：VM+ubuntu11.4。

编译编译环境：arm-linux-gcc v4.3.2。

开发板飞凌OK2440III，2M nor flash，128M nand flash。

linux 版本：linux-2.6.28.7

2, 修改步骤

(1)修改Linux-2.6.28.7/arch/arm/mach-s3c2440/mach-smdk2440.c。

定位到99行附近，找到smdk2440_uartcfgs[]，如下红色代码为修改后的：

static struct s3c2410_uartcfg smdk2440_uartcfgs[] __initdata = {

[0] = {

.hwport = 0,

.flags = 0,

.ucon = 0x3c5,

.ulcon = 0x03,

.ufcon = 0x51,

},

[1] = {

.hwport = 1,

.flags = 0,

.ucon = 0x3c5,

.ulcon = 0x03,

.ufcon = 0x51,

},

/* IR port */

[2] = {

.hwport = 2,

.flags = 0,

.ucon = 0x3c5,

.ulcon = 0x03, //0x43,/* 把UART2 改为普通串口 */

.ufcon = 0x51, } };

（2）修改linux-2.6.28.7/drivers/serial/samsung.c

添加头文件：

#include <linux/gpio.h>

#include <mach/regs-gpio.h>

然后再定位到435 行左右，添加如下红色部分代码：

dbg("s3c24xx_serial_startup ok\n");

/* the port reset code should have done the correct

* register setup for the port controls */

//串口2 对应的端口初始化 if (port->line == 2)

{ s3c2410_gpio_cfgpin(S3C2410_GPH6, S3C2410_GPH6_TXD2);

s3c2410_gpio_pullup(S3C2410_GPH6, 1); s3c2410_gpio_cfgpin(S3C2410_GPH7, S3C2410_GPH7_RXD2); s3c2410_gpio_pullup(S3C2410_GPH7, 1); } return ret; err:

s3c24xx_serial_shutdown(port);

return ret; }

（3）修改配置文件确认相应驱动被被编译进内核

Make menuconfig

Divices Drivers->

Character devices-> Serial Drivers->

<*>Sansung SoC serial support

<*>Samsung s3c2410 serial port support <*>Samsung S3C2440/S3C2442/S3c2416 serial port support

保存退出。

（4）重新编译内核，下载到板子上厕所。 3，说明

（1）代码中使用函数s3c2410_gpio_cfgpin（）、s3c2410_gpio_pullup（）需包含头文件linux/gpio.h。具体实现好像是在arch/arm/plat-s3c24xx/gpio.c, line 103。

（2）S3C2410_GPH6、S3C2410_GPH6_TXD2等宏定义在mach/regs-gpio.h。需要包含该文件。有的内核版本是S3C2410_GPH（6）、S3C2410_GPH（7）。可根据情况修改。

参考文献：

Linux-2.6.32.2内核在mini2440上的移植(十八)--将UART2更成普通串口驱动：

/fyyy4030/article/details/7243998

S3C2440 UART2被配置为CTS问题解决：

/Linux/2011-09/43690.htm

linux在TQ2440上移植6--完善串口驱动：

/view/1b26fc0eba1aa8114431d9f3.html

linux3.18内核移植到GT2440成功---完善串口：

原文地址在本人百度空间：/zhimaguanmen/item/230ced0eeac136de72e67643

 

第二篇：Linux串口驱动编程

Linux串口（serial、uart）驱动程序设计

目录

Linux串口（serial、uart）驱动程序设计 ..................................................................................... 2

一、核心数据结构 ................................................................................................................... 2

二、串口驱动API ................................................................................................................... 6

三、串口驱动例子 ................................................................................................................... 9

linux UART 串口驱动开发文档 ................................................................................................... 27

概念阐述 ................................................................................................................................. 27

一、老版本的串口驱动程序 ................................................................................................. 28

二、目前的串口驱动程序 ..................................................................................................... 29

三、3个数据结构及其串口核心层API .............................................................................. 31

1、uart_driver ................................................................................................................. 31

2、uart_port .................................................................................................................... 32

3、uart_ops ..................................................................................................................... 33

四、uart_ops ........................................................................................................................... 37

五、注册串口终端 ................................................................................................................. 40

六、支持platform_driver ...................................................................................................... 43

七、串口接收数据和发送数据流程 ..................................................................................... 45

1. 相关文件 .................................................................................................................... 45

2. 数据收发 ............................................................................................................................ 47

基于Linux2.6.22和s3c2440的串口驱动简析---(1) 2013-11-21 15:56:32 ................................. 48

基于Linux2.6.22和s3c2440的串口驱动简析---(2) 2013-11-21 15:58:49 ................................. 56

Linux串口（serial、uart）驱动程序设计

分类： LINUX

原文地址：Linux串口（serial、uart）驱动程序设计 作者：lingdxuyan

一、核心数据结构

串口驱动有3个核心数据结构，它们都定义在<#include linux/serial_core.h>

1、uart_driver

uart_driver包含了串口设备名、串口驱动名、主次设备号、串口控制台(可选)等信息，还封装了tty_driver(底层串口驱动无需关心tty_driver)。

struct uart_driver {

struct module *owner; /* 拥有该uart_driver的模块,一般为THIS_MODULE */

const char *driver_name; /* 串口驱动名，串口设备文件名以驱动名为基础 */

const char *dev_name; /* 串口设备名 */

int major; /* 主设备号 */

int minor; /* 次设备号 */

int nr; /* 该uart_driver支持的串口个数(最大) */ struct console *cons; /* 其对应的console.若该uart_driver支持serial console,否则为NULL */

/*

* these are private; the low level driver should not

* touch these; they should be initialised to NULL

*/

struct uart_state *state;

struct tty_driver *tty_driver;

};

2、uart_port

uart_port用于描述串口端口的I/O端口或I/O内存地址、FIFO大小、端口类型、串口时钟等信息。实际上，一个uart_port实例对应一个串口设备

struct uart_port {

spinlock_t lock; /* 串口端口锁 */

unsigned int iobase; /* IO端口基地址 */

unsigned char __iomem *membase; /* IO内存基地址,经映射(如ioremap)后的IO内存虚拟基地址 */

unsigned int irq; /* 中断号 */

unsigned int uartclk; /* 串口时钟 */

unsigned int fifosize; /* 串口FIFO缓冲大小 */ unsigned char x_char; /* xon/xoff字符 */

unsigned char regshift; /* 寄存器位移 */

unsigned char iotype; /* IO访问方式 */

unsigned char unused1;

#define UPIO_PORT (0) /* IO端口 */

#define UPIO_HUB6 (1)

#define UPIO_MEM (2) /* IO内存 */

#define UPIO_MEM32 (3)

#define UPIO_AU (4) /* Au1x00 type IO */ #define UPIO_TSI (5) /* Tsi108/109 type IO */

#define UPIO_DWAPB (6) /* DesignWare APB UART */ #define UPIO_RM9000 (7) /* RM9000 type IO */

unsigned int read_status_mask; /* 关心的Rx error status */ unsigned int ignore_status_mask;/* 忽略的Rx error status */ struct uart_info *info; /* pointer to parent info */ struct uart_icount icount; /* 计数器 */

struct console *cons; /* console结构体 */

#ifdef CONFIG_SERIAL_CORE_CONSOLE

unsigned long sysrq; /* sysrq timeout */

#endif

upf_t flags;

#define UPF_FOURPORT ((__force upf_t) (1 << 1))

#define UPF_SAK ((__force upf_t) (1 << 2))

#define UPF_SPD_MASK ((__force upf_t) (0x1030))

#define UPF_SPD_HI ((__force upf_t) (0x0010))

#define UPF_SPD_VHI ((__force upf_t) (0x0020))

#define UPF_SPD_CUST ((__force upf_t) (0x0030))

#define UPF_SPD_SHI ((__force upf_t) (0x1000))

#define UPF_SPD_WARP ((__force upf_t) (0x1010))

#define UPF_SKIP_TEST ((__force upf_t) (1 << 6))

#define UPF_AUTO_IRQ ((__force upf_t) (1 << 7))

#define UPF_HARDPPS_CD ((__force upf_t) (1 << 11))

#define UPF_LOW_LATENCY ((__force upf_t) (1 << 13))

#define UPF_BUGGY_UART ((__force upf_t) (1 << 14))

#define UPF_MAGIC_MULTIPLIER ((__force upf_t) (1 << 16))

#define UPF_CONS_FLOW ((__force upf_t) (1 << 23))

#define UPF_SHARE_IRQ ((__force upf_t) (1 << 24))

#define UPF_BOOT_AUTOCONF ((__force upf_t) (1 << 28))

#define UPF_FIXED_PORT ((__force upf_t) (1 << 29))

#define UPF_DEAD ((__force upf_t) (1 << 30))

#define UPF_IOREMAP ((__force upf_t) (1 << 31))

#define UPF_CHANGE_MASK ((__force upf_t) (0x17fff))

#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))

unsigned int mctrl; /* 当前的moden设置 */

unsigned int timeout; /* character-based timeout */ unsigned int type; /* 端口类型 */

const struct uart_ops *ops; /* 串口端口操作函数集 */

unsigned int custom_divisor;

unsigned int line; /* 端口索引 */

resource_size_t mapbase; /* IO内存物理基地址，可用于ioremap */ struct device *dev; /* 父设备 */

unsigned char hub6; /* this should be in the 8250 driver */ unsigned char suspended;

unsigned char unused[2];

void *private_data; /* 端口私有数据,一般为platform数据指针 */

};

uart_iconut为串口信息计数器，包含了发送字符计数、接收字符计数等。在串口的发送中断处理函数和接收中断处理函数中，我们需要管理这些计数。

struct uart_icount {

__u32 cts;

__u32 dsr;

__u32 rng;

__u32 dcd;

__u32 rx; /* 发送字符计数 */

__u32 tx; /* 接受字符计数 */

__u32 frame; /* 帧错误计数 */

__u32 overrun; /* Rx FIFO溢出计数 */

__u32 parity; /* 帧校验错误计数 */

__u32 brk; /* break计数 */

__u32 buf_overrun;

};

uart_info有两个成员在底层串口驱动会用到：xmit和tty。用户空间程序通过串口发送数据时，上层驱动将用户数据保存在xmit；而串口发送中断处理函数就是通过xmit获取到用户

数据并将它们发送出去。串口接收中断处理函数需要通过tty将接收到的数据传递给行规则层。

/* uart_info实例仅在串口端口打开时有效，它可能在串口关闭时被串口核心层释放。因此，在使用uart_port的uart_info成员时必须保证串口已打开。底层驱动和核心层驱动都可以修改uart_info实例。

* This is the state information which is only valid when the port

* is open; it may be freed by the core driver once the device has

* been closed. Either the low level driver or the core can modify

* stuff here.

*/

struct uart_info {

struct tty_struct *tty;

struct circ_buf xmit;

uif_t flags;

/*

* Definitions for info->flags. These are _private_ to serial_core, and

* are specific to this structure. They may be queried by low level drivers.

*/

#define UIF_CHECK_CD ((__force uif_t) (1 << 25))

#define UIF_CTS_FLOW ((__force uif_t) (1 << 26))

#define UIF_NORMAL_ACTIVE ((__force uif_t) (1 << 29))

#define UIF_INITIALIZED ((__force uif_t) (1 << 31))

#define UIF_SUSPENDED ((__force uif_t) (1 << 30))

int blocked_open;

struct tasklet_struct tlet;

wait_queue_head_t open_wait;

wait_queue_head_t delta_msr_wait;

};

3、uart_ops

uart_ops涵盖了串口驱动可对串口设备进行的所有操作。

/*

* This structure describes all the operations that can be

* done on the physical hardware.

*/

struct uart_ops {

unsigned int (*tx_empty)(struct uart_port *); /* 串口的Tx FIFO缓存是否为空 */

void (*set_mctrl)(struct uart_port *, unsigned int mctrl); /* 设置串口modem控制 */

unsigned int (*get_mctrl)(struct uart_port *); /* 获取串口modem控制 */

void (*stop_tx)(struct uart_port *); /* 禁止串口发送数据 */

void (*start_tx)(struct uart_port *); /* 使能串口发送数据 */

void (*send_xchar)(struct uart_port *, char ch);/* 发送xChar */

void (*stop_rx)(struct uart_port *); /* 禁止串口接收数据 */

void (*enable_ms)(struct uart_port *); /* 使能modem的状态信号 */ void (*break_ctl)(struct uart_port *, int ctl); /* 设置break信号 */

int (*startup)(struct uart_port *); /* 启动串口,应用程序打开串口设备文件时,该函数会被调用 */

void (*shutdown)(struct uart_port *); /* 关闭串口,应用程序关闭串口设备文件时,该函数会被调用 */

void (*set_termios)(struct uart_port *, struct ktermios *new, struct ktermios *old); /* 设置串口参数 */

void (*pm)(struct uart_port *, unsigned int state,

unsigned int oldstate); /* 串口电源管理 */

int (*set_wake)(struct uart_port *, unsigned int state); /* */

const char *(*type)(struct uart_port *); /* 返回一描述串口类型的字符串 */

void (*release_port)(struct uart_port *); /* 释放串口已申请的IO端口/IO内存资源,必要时还需iounmap */

int (*request_port)(struct uart_port *); /* 申请必要的IO端口/IO内存资源,必要时还可以重新映射串口端口 */

void (*config_port)(struct uart_port *, int); /* 执行串口所需的自动配置 */ int (*verify_port)(struct uart_port *, struct serial_struct *); /* 核实新串口的信息 */

int (*ioctl)(struct uart_port *, unsigned int, unsigned long); /* IO控制 */ };

二、串口驱动API

1、uart_register_driver

/* 功能： uart_register_driver用于将串口驱动uart_driver注册到内核(串口核心层)中，通常在模块初始化函数调用该函数。

* 参数 drv：要注册的uart_driver

* 返回值： 成功，返回0；否则返回错误码

*/

int uart_register_driver(struct uart_driver *drv)

2、uart_unregister_driver

/* 功能： uart_unregister_driver用于注销我们已注册的uart_driver，通常在模块卸载函数调用该函数

* 参数 drv：要注销的uart_driver

* 返回值： 成功，返回0；否则返回错误码

*/

void uart_unregister_driver(struct uart_driver *drv)

3、uart_add_one_port

/* 功能： uart_add_one_port用于为串口驱动添加一个串口端口，通常在探测到设备后(驱动的设备probe方法)调用该函数

* 参数 drv：串口驱动

* port:要添加的串口端口

* 返回值： 成功，返回0；否则返回错误码

*/

int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)

4、uart_remove_one_port

/* 功能： uart_remove_one_port用于删除一个已添加到串口驱动中的串口端口，通常在驱动卸载时调用该函数

* 参数 drv： 串口驱动

* port: 要删除的串口端口

* 返回值： 成功，返回0；否则返回错误码

*/

int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)

5、uart_write_wakeup

/* 功能： uart_write_wakeup唤醒上层因向串口端口写数据而阻塞的进程，通常在串口发送中断处理函数中调用该函数

* 参数 port：需要唤醒写阻塞进程的串口端口

*/

void uart_write_wakeup(struct uart_port *port)

6、uart_suspend_port

/* 功能： uart_suspend_port用于挂起特定的串口端口

* 参数 drv： 要挂起的串口端口所属的串口驱动

* port：要挂起的串口端口

* 返回值： 成功返回0；否则返回错误码

*/

int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)

7、uart_resume_port

/* 功能： uart_resume_port用于恢复某一已挂起的串口

* 参数 drv： 要恢复的串口端口所属的串口驱动

* port：要恢复的串口端口

* 返回值： 成功返回0；否则返回错误码

*/

int uart_resume_port(struct uart_driver *drv, struct uart_port *port)

8、uart_get_baud_rate

/* 功能： uart_get_baud_rate通过解码termios结构体来获取指定串口的波特率 * 参数 port： 要获取波特率的串口端口

* termios：当前期望的termios配置(包含串口波特率)

* old： 以前的termios配置，可以为NULL

* min： 可接受的最小波特率

* max： 可接受的最大波特率

* 返回值： 串口的波特率

*/

unsigned int

uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,

struct ktermios *old, unsigned int min, unsigned int max)

9、uart_get_divisor

/* 功能： uart_get_divisor用于计算某一波特率的串口时钟分频数（串口波特率除数） * 参数 port：要计算时钟分频数的串口端口

* baud：期望的波特率

*返回值： 串口时钟分频数

*/

unsigned int uart_get_divisor(struct uart_port *port, unsigned int baud)

10、uart_update_timeout

/* 功能： uart_update_timeout用于更新（设置）串口FIFO超时时间

* 参数 port： 要更新超时时间的串口端口

* cflag：termios结构体的cflag值

* baud： 串口的波特率

*/

void uart_update_timeout(struct uart_port *port, unsigned int cflag, unsigned int baud)

11、uart_match_port

/* 功能：uart_match_port用于判断两串口端口是否为同一端口

* 参数 port1、port2：要判断的串口端口

* 返回值：不同返回0；否则返回非0

*/

int uart_match_port(struct uart_port *port1, struct uart_port *port2)

12、uart_console_write

/* 功能： uart_console_write用于向串口端口写一控制台信息

* 参数 port: 要写信息的串口端口

* s: 要写的信息

* count: 信息的大小

* putchar: 用于向串口端口写字符的函数，该函数函数有两个参数：串口端口和要写的字符

*/

void uart_console_write(struct uart_port *port, const char *s,

unsigned int count,

void (*putchar)(struct uart_port *, int))

三、串口驱动例子

该串口驱动例子是我针对s3c2410处理器的串口2(uart2)独立开发的。因为我通过博创2410s开发板的GRPS扩展板来测试该驱动（已通过测试），所以我叫该串口为gprs_uart。

该驱动将串口看作平台(platform)设备。platform可以看作一伪总线，用于将集成于片上系统的轻量级设备与Linux设备驱动模型联系到一起，它包含以下两部分（有关platform的声明都在#include <linux/platform_device.h>,具体实现在drivers/base/platform.c）：

1、platform设备。我们需要为每个设备定义一个platform_device实例

struct platform_device {

const char *name; /* 设备名 */

int id; /* 设备的id号 */

struct device dev; /* 其对应的device */

u32 num_resources;/* 该设备用有的资源数 */

struct resource *resource; /* 资源数组 */

};

为我们的设备创建platform_device实例有两种方法：填充一个platform_device结构体后用platform_device_register(一次注册一个)或platform_add_devices（一次可以注册多个platform设备）将platform_device注册到内核；更简单的是使用platform_device_register_simple来建立并注册我们的platform_device。

2、platform驱动。platform设备由platform驱动进行管理。当设备加入到系统中时，platform_driver的probe方法会被调用来见对应的设备添加或者注册到内核；当设备从系统中移除时，platform_driver的remove方法会被调用来做一些清理工作，如移除该设备的一些实例、注销一些已注册到系统中去的东西。

struct platform_driver {

int (*probe)(struct platform_device *);

int (*remove)(struct platform_device *);

void (*shutdown)(struct platform_device *);

int (*suspend)(struct platform_device *, pm_message_t state);

int (*suspend_late)(struct platform_device *, pm_message_t state);

int (*resume_early)(struct platform_device *);

int (*resume)(struct platform_device *);

struct device_driver driver;

};

更详细platform资料可参考网上相关文章。

例子驱动中申请和释放IO内存区的整个过程如下：

insmod gprs_uart.ko→gprs_init_module()→uart_register_driver()→gprs_uart_probe()→ uart_add_one_port()→gprs_uart_config_port()→gprs_uart_request_port()→

request_mem_region()

rmmod gprs_uart.ko→gprs_exit_module()→uart_unregister_driver()→gprs_uart_remove()→uart_remove_one_port()→gprs_uart_release_port()→release_mem_region()

例子驱动中申请和释放IRQ资源的整个过程如下：

open /dev/gprs_uart→gprs_uart_startup()→request_irq()

close /dev/gprs_uart→gprs_uart_shutdown()→free_irq()

想了解更详细的调用过程可以在驱动模块各函数头插入printk(KERN_DEBUG "%s\n", __FUNCTION__);并在函数尾插入printk(KERN_DEBUG "%s done\n", __FUNCTION__);

下面是串口驱动例子和其GPRS测试程序源码下载地址：

/downloads258/sourcecode/unix_linux/detail1192104.html

#include <linux/module.h>

#include <linux/init.h>

#include <linux/kernel.h> /* printk() */

#include <linux/slab.h> /* kmalloc() */

#include <linux/fs.h> /* everything... */

#include <linux/errno.h> /* error codes */

#include <linux/types.h> /* size_t */

#include <linux/fcntl.h> /* O_ACCMODE */

#include <asm/system.h> /* cli(), *_flags */

#include <asm/uaccess.h> /* copy_*_user */

#include <linux/ioctl.h>

#include <linux/device.h>

#include <linux/platform_device.h>

#include <linux/sysrq.h>

#include <linux/tty.h>

#include <linux/tty_flip.h>

#include <linux/serial_core.h>

#include <linux/serial.h>

#include <linux/delay.h>

#include <linux/clk.h>

#include <linux/console.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/hardware.h>

#include <asm/plat-s3c/regs-serial.h>

#include <asm/arch/regs-gpio.h>

#define DEV_NAME "gprs_uart" /* 设备名 */

/* 这里将串口的主设备号设为0,则串口设备编号由内核动态分配;你也可指定串口的设备编号 */

#define GPRS_UART_MAJOR 0 /* 主设备号 */

#define GPRS_UART_MINOR 0 /* 次设备号 */

#define GPRS_UART_FIFO_SIZE 16 /* 串口FIFO的大小 */

#define RXSTAT_DUMMY_READ (0x10000000)

#define MAP_SIZE (0x100) /* 要映射的串口IO内存区大小 */

/* 串口发送中断号 */

#define TX_IRQ(port) ((port)->irq + 1)

/* 串口接收中断号 */

#define RX_IRQ(port) ((port)->irq)

/* 允许串口接收字符的标志 */

#define tx_enabled(port) ((port)->unused[0])

/* 允许串口发送字符的标志 */

#define rx_enabled(port) ((port)->unused[1])

/* 获取寄存器地址 */

#define portaddr(port, reg) ((port)->membase + (reg))

/* 读8位宽的寄存器 */

#define rd_regb(port, reg) (ioread8(portaddr(port, reg)))

/* 读32位宽的寄存器 */

#define rd_regl(port, reg) (ioread32(portaddr(port, reg)))

/* 写8位宽的寄存器 */

#define wr_regb(port, reg, val) \

do { iowrite8(val, portaddr(port, reg)); } while(0)

/* 写32位宽的寄存器 */

#define wr_regl(port, reg, val) \

do { iowrite32(val, portaddr(port, reg)); } while(0)

/* 禁止串口发送数据 */

static void gprs_uart_stop_tx(struct uart_port *port)

{

if (tx_enabled(port)) /* 若串口已启动发送 */

{

disable_irq(TX_IRQ(port)); /* 禁止发送中断 */

tx_enabled(port) = 0; /* 设置串口为未启动发送 */

}

}

/* 使能串口发送数据 */

static void gprs_uart_start_tx(struct uart_port *port)

{

if (!tx_enabled(port)) /* 若串口未启动发送 */

{

enable_irq(TX_IRQ(port)); /* 使能发送中断 */

tx_enabled(port) = 1; /* 设置串口为已启动发送 */

}

}

/* 禁止串口接收数据 */

static void gprs_uart_stop_rx(struct uart_port *port)

{

if (rx_enabled(port)) /* 若串口已启动接收 */

{

disable_irq(RX_IRQ(port)); /* 禁止接收中断 */

rx_enabled(port) = 0; /* 设置串口为未启动接收 */

}

}

/* 使能modem的状态信号 */

static void gprs_uart_enable_ms(struct uart_port *port)

{

}

/* 串口的Tx FIFO缓存是否为空 */

static unsigned int gprs_uart_tx_empty(struct uart_port *port)

{

int ret = 1;

unsigned long ufstat = rd_regl(port, S3C2410_UFSTAT);

unsigned long ufcon = rd_regl(port, S3C2410_UFCON);

if (ufcon & S3C2410_UFCON_FIFOMODE) /* 若使能了FIFO */

{

if ((ufstat & S3C2410_UFSTAT_TXMASK) != 0 || /* 0 <FIFO <=15 */ (ufstat & S3C2410_UFSTAT_TXFULL)) /* FIFO满 */ ret = 0;

}

else /* 若未使能了FIFO,则判断发送缓存和发送移位寄存器是否均为空 */ {

ret = rd_regl(port, S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE;

}

return ret;

}

/* 获取串口modem控制,因为uart2无modem控制,所以CTS、DSR直接返回有效 */ static unsigned int gprs_uart_get_mctrl(struct uart_port *port)

{

return (TIOCM_CTS | TIOCM_DSR | TIOCM_CAR);

}

/* 设置串口modem控制 */

static void gprs_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)

{

}

/* 设置break信号 */

static void gprs_uart_break_ctl(struct uart_port *port, int break_state)

{

unsigned long flags;

unsigned int ucon;

spin_lock_irqsave(&port->lock, flags);

ucon = rd_regl(port, S3C2410_UCON);

if (break_state)

ucon |= S3C2410_UCON_SBREAK;

else

ucon &= ~S3C2410_UCON_SBREAK;

wr_regl(port, S3C2410_UCON, ucon);

spin_unlock_irqrestore(&port->lock, flags);

}

/* 返回Rx FIFO已存多少数据 */

static int gprs_uart_rx_fifocnt(unsigned long ufstat)

{

/* 若Rx FIFO已满,返回FIFO的大小 */

if (ufstat & S3C2410_UFSTAT_RXFULL)

return GPRS_UART_FIFO_SIZE;

/* 若FIFO未满,返回Rx FIFO已存了多少字节数据 */

return (ufstat & S3C2410_UFSTAT_RXMASK) >> S3C2410_UFSTAT_RXSHIFT; }

#define S3C2410_UERSTAT_PARITY (0x1000)

/* 串口接收中断处理函数,获取串口接收到的数据,并将这些数据递交给行规则层 */ static irqreturn_t gprs_uart_rx_chars(int irq, void *dev_id)

{

struct uart_port *port = dev_id;

struct tty_struct *tty = port->info->tty;

unsigned int ufcon, ch, flag, ufstat, uerstat;

int max_count = 64;

/* 循环接收数据,最多一次中断接收64字节数据 */

while (max_count-- > 0)

{

ufcon = rd_regl(port, S3C2410_UFCON);

ufstat = rd_regl(port, S3C2410_UFSTAT);

/* 若Rx FIFO无数据了,跳出循环 */

if (gprs_uart_rx_fifocnt(ufstat) == 0)

break;

/* 读取Rx error状态寄存器 */

uerstat = rd_regl(port, S3C2410_UERSTAT);

/* 读取已接受到的数据 */

ch = rd_regb(port, S3C2410_URXH);

/* insert the character into the buffer */

/* 先将tty标志设为正常 */

flag = TTY_NORMAL;

/* 递增接收字符计数器 */

port->icount.rx++;

/* 判断是否存在Rx error

* if (unlikely(uerstat & S3C2410_UERSTAT_ANY))等同于

* if (uerstat & S3C2410_UERSTAT_ANY)

* 只是unlikely表示uerstat & S3C2410_UERSTAT_ANY的值为假的可能性大一些

* 另外还有一个likely(value)表示value的值为真的可能性更大一些

*/

if (unlikely(uerstat & S3C2410_UERSTAT_ANY))

{

/* 若break错误,递增icount.brk计算器 */

if (uerstat & S3C2410_UERSTAT_BREAK)

{

port->icount.brk++;

if (uart_handle_break(port))

goto ignore_char;

}

/* 若frame错误,递增icount.frame计算器 */

if (uerstat & S3C2410_UERSTAT_FRAME)

port->icount.frame++;

/* 若overrun错误,递增icount.overrun计算器 */

if (uerstat & S3C2410_UERSTAT_OVERRUN)

port->icount.overrun++;

/* 查看我们是否关心该Rx error

* port->read_status_mask保存着我们感兴趣的Rx error status */

uerstat &= port->read_status_mask;

/* 若我们关心该Rx error,则将flag设置为对应的error flag */ if (uerstat & S3C2410_UERSTAT_BREAK)

flag = TTY_BREAK;

else if (uerstat & S3C2410_UERSTAT_PARITY)

flag = TTY_PARITY;

else if (uerstat & ( S3C2410_UERSTAT_FRAME S3C2410_UERSTAT_OVERRUN))

flag = TTY_FRAME;

}

/* 处理sys字符 */

if (uart_handle_sysrq_char(port, ch))

goto ignore_char;

/* 将接收到的字符插入到tty设备的flip缓冲 */

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

ignore_char:

continue;

}

/* 刷新tty设备的flip缓冲,将接受到的数据传给行规则层 */

tty_flip_buffer_push(tty);

|

return IRQ_HANDLED;

}

/* 串口发送中断处理函数,将用户空间的数据(保存在环形缓冲xmit里)发送出去 */ static irqreturn_t gprs_uart_tx_chars(int irq, void *dev_id)

{

struct uart_port *port = dev_id;

struct circ_buf *xmit = &port->info->xmit; /* 获取环线缓冲 */ int count = 256;

/* 若设置了xChar字符 */

if (port->x_char)

{

/* 将该xChar发送出去 */

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

/* 递增发送计数 */

port->icount.tx++;

/* 清除xChar */

port->x_char = 0;

/* 退出中断处理 */

goto out;

}

/* 如果没有更多的字符需要发送(环形缓冲为空)，

* 或者uart Tx已停止，

* 则停止uart并退出中断处理函数

*/

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

{

gprs_uart_stop_tx(port);

goto out;

}

/* 循环发送数据,直到环形缓冲为空,最多一次中断发送256字节数据 */ while (!uart_circ_empty(xmit) && count-- > 0)

{

/* 若Tx FIFO已满,退出循环 */

if (rd_regl(port, S3C2410_UFSTAT) & S3C2410_UFSTAT_TXFULL) break;

/* 将要发送的数据写入Tx FIFO */

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))

gprs_uart_stop_tx(port);

out:

return IRQ_HANDLED;

}

/* 启动串口端口,在打开该驱动的设备文件时会调用该函数来申请串口中断,并设置串口为可接受,也可发送 */

static int gprs_uart_startup(struct uart_port *port)

{

unsigned long flags;

int ret;

const char *portname = to_platform_device(port->dev)->name;

/* 设置串口为不可接受,也不可发送 */

rx_enabled(port) = 0;

tx_enabled(port) = 0;

spin_lock_irqsave(&port->lock, flags);

/* 申请接收中断 */

ret = request_irq(RX_IRQ(port), gprs_uart_rx_chars, 0, portname, port);

if (ret != 0)

{

printk(KERN_ERR "cannot get irq %d\n", RX_IRQ(port));

return ret;

}

/* 设置串口为允许接收 */

rx_enabled(port) = 1;

/* 申请发送中断 */

ret = request_irq(TX_IRQ(port), gprs_uart_tx_chars, 0, portname, port);

if (ret)

{

printk(KERN_ERR "cannot get irq %d\n", TX_IRQ(port));

rx_enabled(port) = 0;

free_irq(RX_IRQ(port), port);

goto err;

}

/* 设置串口为允许发送 */

tx_enabled(port) = 1;

err:

spin_unlock_irqrestore(&port->lock, flags);

return ret;

}

/* 关闭串口,在关闭驱动的设备文件时会调用该函数,释放串口中断 */ static void gprs_uart_shutdown(struct uart_port *port)

{

rx_enabled(port) = 0; /* 设置串口为不允许接收 */ free_irq(RX_IRQ(port), port); /* 释放接收中断 */

tx_enabled(port) = 0; /* 设置串口为不允许发送 */ free_irq(TX_IRQ(port), port); /* 释放发送中断 */

}

/* 设置串口参数 */

static void gprs_uart_set_termios(struct uart_port *port,

struct ktermios *termios,

struct ktermios *old)

{

unsigned long flags;

unsigned int baud, quot;

unsigned int ulcon, ufcon = 0;

/* 不支持moden控制信号线

* HUPCL: 关闭时挂断moden

* CMSPAR: mark or space (stick) parity

* CLOCAL: 忽略任何moden控制线

*/

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

termios->c_cflag |= CLOCAL;

/* 获取用户设置的串口波特率,并计算分频数(串口波特率除数quot) */ baud = uart_get_baud_rate(port, termios, old, 0, 115200*8);

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

else

quot = port->uartclk / baud / 16 - 1;

/* 设置数据字长 */

switch (termios->c_cflag & CSIZE)

{

case CS5:

ulcon = S3C2410_LCON_CS5;

break;

case CS6:

ulcon = S3C2410_LCON_CS6;

break;

case CS7:

ulcon = S3C2410_LCON_CS7;

break;

case CS8:

default:

ulcon = S3C2410_LCON_CS8;

break;

}

/* 是否要求设置两个停止位(CSTOPB) */

if (termios->c_cflag & CSTOPB)

ulcon |= S3C2410_LCON_STOPB;

/* 是否使用奇偶检验 */

if (termios->c_cflag & PARENB)

{

if (termios->c_cflag & PARODD) /* 奇校验 */

ulcon |= S3C2410_LCON_PODD;

else /* 偶校验 */

ulcon |= S3C2410_LCON_PEVEN;

}

else /* 无校验 */

{

ulcon |= S3C2410_LCON_PNONE;

}

if (port->fifosize > 1)

ufcon |= S3C2410_UFCON_FIFOMODE | S3C2410_UFCON_RXTRIG8;

spin_lock_irqsave(&port->lock, flags);

/* 设置FIFO控制寄存器、线控制寄存器和波特率除数寄存器 */

wr_regl(port, S3C2410_UFCON, ufcon);

wr_regl(port, S3C2410_ULCON, ulcon);

wr_regl(port, S3C2410_UBRDIV, quot);

/* 更新串口FIFO的超时时限 */

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

/* 设置我们感兴趣的Rx error */

port->read_status_mask = S3C2410_UERSTAT_OVERRUN;

if (termios->c_iflag & INPCK)

port->read_status_mask |= S3C2410_UERSTAT_FRAME S3C2410_UERSTAT_PARITY;

/* 设置我们忽略的Rx error */

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;

/* 若未设置CREAD(使用接收器),则忽略所有Rx error*/

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

port->ignore_status_mask |= RXSTAT_DUMMY_READ;

spin_unlock_irqrestore(&port->lock, flags);

}

/* 获取串口类型 */

static const char *gprs_uart_type(struct uart_port *port)

{/* 返回描述串口类型的字符串指针 */

return port->type == PORT_S3C2410 ? "gprs_uart:s3c2410_uart2" : NULL;

}

/* 申请串口一些必要的资源,如IO端口/IO内存资源,必要时还可以重新映射串口端口 */ static int gprs_uart_request_port(struct uart_port *port)

{

struct resource *res;

const char *name = to_platform_device(port->dev)->name;

/* request_mem_region请求分配IO内存,从开始port->mapbase,大小MAP_SIZE * port->mapbase保存当前串口的寄存器基地址(物理)

* uart2: 0x50008000

*/

res = request_mem_region(port->mapbase, MAP_SIZE, name); |

if (res == NULL)

{

printk(KERN_ERR"request_mem_region error: %p\n", res);

return -EBUSY;

}

return 0;

}

/* 释放串口已申请的IO端口/IO内存资源,必要时还需iounmap */

static void gprs_uart_release_port(struct uart_port *port)

{

/* 释放已分配IO内存 */

release_mem_region(port->mapbase, MAP_SIZE);

}

/* 执行串口所需的自动配置 */

static void gprs_uart_config_port(struct uart_port *port, int flags)

{

int retval;

/* 请求串口 */

retval = gprs_uart_request_port(port);

/* 设置串口类型 */

if (flags & UART_CONFIG_TYPE && retval == 0)

port->type = PORT_S3C2410;

}

/* The UART operations structure */

static struct uart_ops gprs_uart_ops = {

.start_tx = gprs_uart_start_tx, /* Start transmitting */

.stop_tx = gprs_uart_stop_tx, /* Stop transmission */

.stop_rx = gprs_uart_stop_rx, /* Stop reception */

.enable_ms = gprs_uart_enable_ms, /* Enable modem status signals */ .tx_empty = gprs_uart_tx_empty, /* Transmitter busy? */

.get_mctrl = gprs_uart_get_mctrl, /* Get modem control */

.set_mctrl = gprs_uart_set_mctrl, /* Set modem control */

.break_ctl = gprs_uart_break_ctl, /* Set break signal */

.startup = gprs_uart_startup, /* App opens GPRS_UART */

.shutdown = gprs_uart_shutdown, /* App closes GPRS_UART */ .set_termios = gprs_uart_set_termios, /* Set termios */

.type = gprs_uart_type, /* Get UART type */

.request_port = gprs_uart_request_port, /* Claim resources associated with a GPRS_UART port */

.release_port = gprs_uart_release_port, /* Release resources associated with a GPRS_UART port */

.config_port = gprs_uart_config_port, /* Configure when driver adds a GPRS_UART port */

};

/* Uart driver for GPRS_UART */

static struct uart_driver gprs_uart_driver = {

.owner = THIS_MODULE, /* Owner */

.driver_name = DEV_NAME, /* Driver name */

.dev_name = DEV_NAME, /* Device node name */

.major = GPRS_UART_MAJOR, /* Major number */

.minor = GPRS_UART_MINOR, /* Minor number start */

.nr = 1, /* Number of UART ports */

};

/* Uart port for GPRS_UART port */

static struct uart_port gprs_uart_port = {

.irq = IRQ_S3CUART_RX2, /* IRQ */

.fifosize = GPRS_UART_FIFO_SIZE, /* Size of the FIFO */

.iotype = UPIO_MEM, /* IO memory */

.flags = UPF_BOOT_AUTOCONF, /* UART port flag */ .ops = &gprs_uart_ops, /* UART operations */

.line = 0, /* UART port number */

.lock = __SPIN_LOCK_UNLOCKED(gprs_uart_port.lock),

};

/* 初始化指定串口端口 */

static int gprs_uart_init_port(struct uart_port *port, struct platform_device *platdev)

{

unsigned long flags;

unsigned int gphcon;

if (platdev == NULL)

return -ENODEV;

port->dev = &platdev->dev;

/* 设置串口波特率时钟频率 */

port->uartclk = clk_get_rate(clk_get(&platdev->dev, "pclk"));

/* 设置串口的寄存器基地址(物理): 0x50008000 */

port->mapbase = S3C2410_PA_UART2;

/* 设置当前串口的寄存器基地址(虚拟): 0xF5008000 */

port->membase = S3C24XX_VA_UART + (S3C2410_PA_UART2 S3C24XX_PA_UART);

spin_lock_irqsave(&port->lock, flags);

wr_regl(port, S3C2410_UCON, S3C2410_UCON_DEFAULT);

wr_regl(port, S3C2410_ULCON, S3C2410_LCON_CS8 | S3C2410_LCON_PNONE); wr_regl(port, S3C2410_UFCON, S3C2410_UFCON_FIFOMODE

| S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_RESETBOTH);

/* 将I/O port H的gph6和gph7设置为TXD2和RXD2 */

gphcon = readl(S3C2410_GPHCON);

gphcon &= ~((0x5) << 12);

writel(gphcon, S3C2410_GPHCON);

spin_unlock_irqrestore(&port->lock, flags);

return 0;

}

/* Platform driver probe */

static int __init gprs_uart_probe(struct platform_device *dev)

{

int ret;

/* 初始化串口 */

ret = gprs_uart_init_port(&gprs_uart_port, dev);

if (ret < 0)

{

printk(KERN_ERR"gprs_uart_probe: gprs_uart_init_port error: %d\n", ret); return ret;

}

/* 添加串口 */

ret = uart_add_one_port(&gprs_uart_driver, &gprs_uart_port);

if (ret < 0)

{

printk(KERN_ERR"gprs_uart_probe: uart_add_one_port error: %d\n", ret); return ret;

}

/* 将串口uart_port结构体保存在platform_device->dev->driver_data中 */ platform_set_drvdata(dev, &gprs_uart_port); -

return 0;

}

/* Called when the platform driver is unregistered */

static int gprs_uart_remove(struct platform_device *dev)

{

platform_set_drvdata(dev, NULL);

/* 移除串口 */

uart_remove_one_port(&gprs_uart_driver, &gprs_uart_port);

return 0;

}

/* Suspend power management event */

static int gprs_uart_suspend(struct platform_device *dev, pm_message_t state) {

uart_suspend_port(&gprs_uart_driver, &gprs_uart_port);

return 0;

}

/* Resume after a previous suspend */

static int gprs_uart_resume(struct platform_device *dev)

{

uart_resume_port(&gprs_uart_driver, &gprs_uart_port);

return 0;

}

/* Platform driver for GPRS_UART */

static struct platform_driver gprs_plat_driver = {

.probe = gprs_uart_probe, /* Probe method */ .remove = __exit_p(gprs_uart_remove), /* Detach method */ .suspend = gprs_uart_suspend, /* Power suspend */

.resume = gprs_uart_resume, /* Resume after a suspend */ .driver = {

.owner = THIS_MODULE,

.name = DEV_NAME, /* Driver name */ },

};

/* Platform device for GPRS_UART */

struct platform_device *gprs_plat_device;

static int __init gprs_init_module(void)

{

int retval;

/* Register uart_driver for GPRS_UART */

retval = uart_register_driver(&gprs_uart_driver);

if (0 != retval)

{

printk(KERN_ERR "gprs_init_module: can't register the GPRS_UART driver %d\n", retval);

return retval;

}

/* Register platform device for GPRS_UART. Usually called

during architecture-specific setup */

gprs_plat_device = platform_device_register_simple(DEV_NAME, 0, NULL, 0); if (IS_ERR(gprs_plat_device))

{

retval = PTR_ERR(gprs_plat_device);

printk(KERN_ERR "gprs_init_module: can't register platform device %d\n", retval); goto fail_reg_plat_dev;

}

/* Announce a matching driver for the platform

devices registered above */

retval = platform_driver_register(&gprs_plat_driver);

if (0 != retval)

{

printk(KERN_ERR "gprs_init_module: can't register platform driver %d\n", retval); goto fail_reg_plat_drv;

}

return 0; /* succeed */

fail_reg_plat_drv:

platform_device_unregister(gprs_plat_device);

fail_reg_plat_dev:

uart_unregister_driver(&gprs_uart_driver);

return retval;

}

static void __exit gprs_exit_module(void)

{

/* The order of unregistration is important. Unregistering the

UART driver before the platform driver will crash the system */

/* Unregister the platform driver */

platform_driver_unregister(&gprs_plat_driver);

/* Unregister the platform devices */

platform_device_unregister(gprs_plat_device);

/* Unregister the GPRS_UART driver */

uart_unregister_driver(&gprs_uart_driver);

}

module_init(gprs_init_module);

module_exit(gprs_exit_module);

MODULE_AUTHOR("lingd");

MODULE_LICENSE("Dual BSD/GPL");

linux UART 串口驱动开发文档

概念阐述

tty一词源于Teletypes，或者teletypewriters，原来指的是电传打字机，是通过串行线用打印机键盘通过阅读和发送信息的东西，后来这东西被键盘与显示器取代，所以现在叫终端比较合适。终端是一种字符型设备，它有多种类型，通常使用tty来简称各种类型的终端设备。

在终端或TTY接插的地方，操作系统仍然需要一个程序来监视串行端口。一个getty“Get TTY”的处理过程是:一个程序监视物理的TTY/终端接口。对一个虚拟网络沮丧服务器(VNC)来说，一个伪装的TTY(Pseudo-TTY，即家猫的TTY，也叫做“PTY”)是等价的终端。当你运行一个xterm(终端仿真程序)或GNOME终端程序时，PTY对虚拟的用户或者如xterm一样的伪终端来说，就像是一个TTY在运行。“Pseudo”的意思是“duplicating in a fake way”(用伪造的方法复制)，它相比“virtual”或“emulated”更能真实的说明问题。而在现在的计算中，它却处于被放弃的阶段。

tty 驱动的核心正好位于标准字符驱动级别之下, 并且提供了一些特性集中在为使用终端类型设备提供一个接口. 这个核心负责控制跨越一个 tty 设备的数据流和数据格式. 这允许 tty 驱动以一种一致的方式集中于处理到硬件和出自硬件的数据, 而不必担心如何控制对用户空间的接口. 为控制数据流, 有几个不同的线路规程可以虚拟地"插入"任何一个 tty 设备.

这由不同的 tty 线路规程驱动来完成.

tty 核心从一个用户获取将要发送给一个 tty 设备的数据. 它接着传递它到一个 tty 线路规程驱动, 接着传递它到一个 tty 驱动. 这个 tty 驱动转换数据为可以发送给硬件的格式. 从 tty 硬件收到的数据向上回流通过 tty 驱动, 进入 tty 线路规程驱动, 再进入 tty 核心, 在这里它被一个用户获取. 有时 tty 驱动直接和 tty 核心通讯, 并且 tty 核心直接发送数据到 tty 驱动, 但是常常 tty 线路规程有机会修改在 2 者之间发送的数据.

tty 驱动从未看见 tty 线路规程. 这个驱动不能直接和线路规程通讯, 它甚至也不知道它存在. 驱动的工作是以硬件能够理解的方式格式化发送给它的数据, 并且从硬件接收数据. tty 线路规程的工作是以特殊的方式格式化从一个用户或者硬件收到的数据. 这种格式化常常采用一个协议转换的形式, 例如 PPP 和 Bluetooth.

开发tty设备驱动，主要是注册tty_register_driver() 函数。

比较典型的tty设备：串口、pty。

需要要注意的是按照功能划分可以将串口分为两大类：串口终端和普通串口。串口终端，是将串口作为linux kernel的终端输出（比如通过pc上超级终端就能将这个终端显示出来）。普通串口，就是2跟线，接收数据，发送数据。

当串口作为终端的时候，在/etc/inittab文件中加入下面语句

::respawn:/sbin/getty -L ttyS0 115200 xterm

指定在ttyS0串口打开一个登录会话，这样串口就成控制台了就可以将串口作为终端来使用了。

如果没有使用getty来绑定串口，那么即使是基于tty架构的串口驱动程序也只能收发数据，不能作为终端来使用。

pty指的是伪终端，比如telnet过程中就会使用这种伪终端。telnet跟telnetd通过socket通信，服务器上的telnetd程序会打开这个pty（伪终端）设备文件，然后这个伪终端做的事情跟串口终端做的事情一样，只是串口线变成了网线而已。

一、老版本的串口驱动程序

tty设备分为物理设备和虚拟设备。物理设备，如串口，USB转串口桥，串口MODEM等等，和硬件相对应的设备。虚拟设备，如console，pty等虚拟设备，通常没有硬件与之相对应。

tty的type分为三类，console,serial port和pty。只有serial port是物理设备，因此我们编写的驱动程序类型也都是serial port类型的。而console和pty多是由内核完成。由于tty是一种通用设备，内核提供了高级操作函数。所有的tty设备都不必从底层做起，可以调用tty core（内核提供模块）功能完成操作。

之前的uart驱动程序是基于tty驱动架构的，如下图所示。

层次结构图1

二、目前的串口驱动程序

层次结构图2

目前，uart设备是继tty_driver的又一层封装。实际上uart_driver就是对应tty_driver，在它的操作函数中,将操作转入uart_port。

在写操作的时候,先将数据放入一个叫做circ_buf的环形缓存区.然后uart_port从缓存区中取数据,将其写入到串口设备中。如

串口驱动的数据流图

当uart_port从serial设备接收到数据时,会将设备放入对应line discipline的缓存区中。tty 核心缓冲由 tty 驱动接收到的数据, 在一个称为 struct tty_flip_buffer 的结构中. 一个 flip 缓冲是一个结构包含 2 个主要数据数组. 从 tty 设备接收到的数据被存储于第一个数组. 当这个数组满, 任何等待数据的用户被通知数据可以读. 当用户从这个数组读数据, 任何新到的数据被存储在第 2 个数组. 当那个数组被读空, 数据再次刷新给用户, 并且驱动开始填充第 1 个数组. 本质上, 被接收的数据 "flips" 从一个缓冲到另一个, 期望不会溢出它们 2 个. 为试图阻止数据丢失, 一个 tty 驱动可以监视到来的数组多大, 并且, 如果它添满, 及时告知 tty 驱动在这个时刻刷新缓冲, 而不是等待下一个可用的机会.

这样.用户在编写串口驱动的时候,只先要注册一个uart_driver.它的主要作用是定义设备节点号。然后将对设备的各项操作封装在uart_port。驱动工程师没必要关心上层的流程,只需按硬件规范将uart_port中的接口函数完成就可以了。

三、3个数据结构及其串口核心层API

串口核心层为串口设备驱动提供了如下3个结构体

1、uart_driver

uart_driver包含串口设备的驱动名、设备名、设备号等信息，它封装了tty_driver，使得底层的UART驱动无需关心tty_driver，uart_driver结构体如下：

static struct uart_driver vc088x_uart_driver =

{

.owner = THIS_MODULE,

.driver_name = VC088X_UART_DEV_NAME, //驱动名

.dev_name = "ttyS", //设备名

.major = VC088X_UART_MAJOR, //主设备号

.minor = VC088X_UART_MINOR, //次设备号

.nr = VC088X_UART_NR,

.cons = VC088X_UART_CONSOLE,

};

一个tty驱动必须注册/注销tty_driver，而一个UART驱动则演变为注册/注销uart_driver，使用如下接口：

int uart_register_driver(struct uart_driver *drv);

void uart_unregister_driver(struct uart_driver *drv);

实际上，uart_register_driver()和uart_unregister_driver()中分别包含了tty_register_driver()和tty_unregister_driver()的操作。

2、uart_port

uart_port用于描述一个UART端口（直接对应于一个串口）的I/O端口或I/O内存地址、大小、端口类型等信息，结构体如下：

{

.lock = __SPIN_LOCK_UNLOCKED( vc088x_uart_ports[0].port.lock ), /* 端口锁 */

.membase = (unsigned char *)( IO_ADDRESS( VC088X_REG_BASE_UART0 )), /* IO内存基

地址 */

.mapbase = VC088X_REG_BASE_UART0, /* ioremap后基地址 */

.iotype = UPIO_MEM, /* IO存取类型 */

.irq = IRQ_UART0, /* 中断号 */

.uartclk = UART_LOW_SPEED_CLK_MAX, /* UART时钟 */

.ops = &vc088x_uart_ops, /* UART操作集 */

.flags = ASYNC_BOOT_AUTOCONF,

.line = 0, //串口在次设备数组中的索引号，须注意从0 计起

}

串口核心层提供如下函数来添加1个端口：

int uart_add_one_port(struct uart_driver *drv, struct uart_port *port);

对上述函数的调用应该发生在uart_register_driver()之后，uart_add_one_port()的一个最重要作用是封装了tty_register_device()。

uart_add_one_port()的“反函数”是uart_remove_one_port()，其中会调用tty_unregister_device();

驱动中虽然不需要处理uart_port的uart_info成员，但是在发送时，从用户来的数据被保存在xmit（被定义为circ_buf，即环形缓冲 区）中，因此UART驱动在发送数据时（一般在发送中断处理函数中），需要从这个circ_buf获取上层传递下来的字符。

3、uart_ops

uart_ops 定义了针对UART的一系列操作，包括发送、接收及线路设置等，如果说tty_driver中的tty_operations对于串口还较为抽象，那么 uart_ops则直接面向了串口的UART，其定义如代码清单14.16。Linux驱动的这种层次非常类似于面向对象编程中基类、派生类的关系，派生类针对特定的事物会更加具体，而基类则站在更高的抽象层次上。uart_ops结构体如下：

static struct uart_ops vc088x_uart_ops =

{

.tx_empty = vc088x_uart_tx_empty,

.start_tx = vc088x_uart_start_tx, //开始发送

.break_ctl = vc088x_uart_break_ctl,

.startup = vc088x_uart_startup,

.shutdown = vc088x_uart_shutdown,

.set_termios = vc088x_uart_set_termios, //设置termios

.type = vc088x_uart_type, /* 返回1个描述端口类型的字符串 */

.release_port = vc088x_uart_release_port, /* 释放端口使用的IO和内存资源*/

.request_port = vc088x_uart_request_port,/* 申请端口使用的IO和内存资源 */

.config_port = vc088x_uart_config_port,

.verify_port = vc088x_uart_verify_port,

};

serial_core.c 中定义了tty_operations的实例，包含uart_open()、uart_close()、uart_write()、 uart_send_xchar()等成员函数，这些函数会借助uart_ops结构体中的成员函数来完成具体的操作，代码清单 14.18给出了tty_operations的uart_send_xchar()成员函数利用uart_ops中start_tx()、 send_xchar()成员函数的例子。

代码清单14.17 串口核心层的tty_operations实例

static 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,

.stop = uart_stop,

.start = uart_start,

.hangup = uart_hangup,

.break_ctl = uart_break_ctl,

.wait_until_sent= uart_wait_until_sent,

.tiocmget = uart_tiocmget,

.tiocmset = uart_tiocmset,

};

串口核心层的tty_operations与uart_ops关系

static void uart_send_xchar(struct tty_struct *tty, char ch)

{

struct uart_state *state = tty->driver_data;

struct uart_port *port = state->port;

unsigned long flags;

//如果uart_ops中实现了send_xchar成员函数

if (port->ops->send_xchar)

port->ops->send_xchar(port, ch);

else //uart_ops中未实现send_xchar成员函数

{

port->x_char = ch; //xchar赋值

if (ch)

{

spin_lock_irqsave(&port->lock, flags);

port->ops->start_tx(port); //发送xchar

spin_unlock_irqrestore(&port->lock, flags);

}

}

}

注意: 整个调用流程为: 系统调用write()->uart_write()(tty_driver)->port->ops->start_tx();

在使用串口核心层这个通用串口tty驱动层的接口后，一个串口驱动要完成的主要工作将包括：

? 定义uart_driver、uart_ops、uart_port等结构体的实例并在适当的地方根据具体硬件和驱动的情况初始化它们，当然具体设备 xxx的驱动可以将这些结构套在新定义的xxx_uart_driver、xxx_uart_ops、xxx_uart_port之内。

? 在模块初始化时调用uart_register_driver()和uart_add_one_port()以注册UART驱动并添加端口，在模块卸载时 调用uart_unregister_driver()和uart_remove_one_port()以注销UART驱动并移除端口。

? 根据具体硬件的datasheet实现uart_ops中的成员函数，这些函数的实现成为UART驱动的主体工作。

四、uart_ops

vc088x_uart_tx_empty

该函数将检查参数port所对应的发送队列是否为空。如果为空，该函数应返回TIOCSER_TEMT，否则返回0。如果端口并不支持这一操作，那么他应返回TIOCSER_TEMT。代码如下：

status = __raw_readl(( up->port.membase + UART_LSR ));

return (( status & ULSR_TXRDY ) ? TIOCSER_TEMT : 0 );

vc088x_uart_start_tx

开始传输字符。

将port.info->xmit缓冲区中的字符发送出去

do

{

vc088x_uart_char_tx( up, xmit->buf[xmit->tail] );

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

up->port.icount.tx++;

if( uart_circ_empty( xmit ))

break;

} while( --count > 0 );

vc088x_uart_break_ctl

控制暂停信号的传输。如果ctl不为零，中断信号将被传输。当有凭借为零的ctl产生的其他调用时，该信号应终止。

status = __raw_readl(( up->port.membase + UART_TCR ));

status = ( break_state == 0 ) ? ( status & ~UTCR_BRK ) : ( status | UTCR_BRK );

__raw_writel( status, ( up->port.membase + UART_TCR ));

vc088x_uart_startup

mask串口中断

清串口中断源

通过request_irq注册中断服务程序

开启timer

__raw_writel( UART_INT_ALL, ( up->port.membase + UART_INT_SETMASK ));

pnd = __raw_readl(( up->port.membase + UART_SRC_PND ));

__raw_writel( pnd, ( up->port.membase + UART_SRC_PND ));

ret = request_irq(( up->port.irq ), vc088x_uart_irq_handle, 0, "vc088x_uart",);

up->timer.data = (unsigned long)up;

up->timer.function = vc088x_uart_timeout;

init_timer( &( up->timer ));

mod_timer( &( up->timer ), ( jiffies + VC088X_UART_TIMEOUT_TICKS ));

__raw_writel( UART_INT_NORMAL, ( up->port.membase + UART_INT_UNMASK ));

vc088x_uart_shutdown

del_timer_sync( &( up->timer ));

free_irq(( up->port.irq ), up );

vc088x_uart_set_termios

//设置termios，波特率，停止位，校验位等

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

__raw_writel( val, ( up->port.membase + UART_LCR ));

vc088x_uart_type

/* 返回1个描述端口类型的字符串 */

vc088x_uart_release_port

/* 释放端口使用的IO和内存资源*/

release_mem_region(( up->port.mapbase ), SZ_4K );

vc088x_uart_request_port

/* 申请端口使用的IO和内存资源 */

request_mem_region(( up->port.mapbase ), SZ_4K, VC088X_UART_DEV_NAME ))

vc088x_uart_config_port

执行所有端口所需的自动配置步骤。‘type’包括所需配置的掩码。UART_CONFIG_TYPE指出端口需要探测和识别。port->type用被置位所发现的类型，或者是如果没有端口被发现，则置位为PORT_UNKNOWN。

UART_CONFIG_IRQ指出中断信号的自动配置，而这需使用标准内核自动探测技术来探测。在平台中固件内置有中断的端口是没有必要的（例如，片上系统实现）。

vc088x_uart_verify_port

验证新的串行端口信息，包括serinfo是否适合这种端口类型。

中断服务程序

vc088x_uart_irq_handle( int irq, void *data )

{

u32 pnd = 0, mask = 0;

struct vc088x_uart_port *up = ( struct vc088x_uart_port * )data;

mask = __raw_readl(( up->port.membase + UART_INT_MASK ));

__raw_writel( UART_INT_ALL, ( up->port.membase + UART_INT_SETMASK ));

pnd = __raw_readl(( up->port.membase + UART_SRC_PND ));

__raw_writel( pnd, ( up->port.membase + UART_SRC_PND ));

lsr = __raw_readl(( up->port.membase + UART_LSR ));

if( lsr & ( ULSR_RXRDY | ULSR_BI ))

tty_flip_buffer_push( tty ); //将数据提交到tty核心层

__raw_writel(( UART_INT_ALL & ( ~mask )), ( up->port.membase + UART_INT_UNMASK ));

return IRQ_HANDLED;

}

五、注册串口终端

串口要能够成为终端，必须客外加入终端注册及初始化的代码，这部分很简单，基本上所有

的串口驱动都是固定的模式，并无什么修改，主要包括如下结构:

static struct console vc088x_uart_console =

{

.name = "ttyS",

.write = vc088x_uart_console_write,

.device = uart_console_device,

.setup = vc088x_uart_console_setup,

.flags = CON_PRINTBUFFER,

.index = -1, //-1，表示从console使用那个串口，是从cmdline传递进来的

.data = &vc088x_uart_driver,

};

static int __init vc088x_uart_console_init( void )

{

register_console( &vc088x_uart_console );

}

1. 注册过程：

start_kernel→console_init→vc088x_uart_console_init→register_console

2. 使用过程：

printk→ ?????? →vc088x_uart_console_write

3. printk代码详解：

printk

vprintk

release_console_sem

call_console_drivers

_call_console_drivers

__call_console_drivers

con->write(con, &LOG_BUF(start), end - start);

static struct console v8uart_console =

{

.write = v8uart_console_write,

.setup = v8uart_console_setup,

.index = -1,//表示从cmdline那儿传进来使用哪个串口作为console

};

v8uart_console_write

//使用从内核哪儿传来的串口号，如何从内核获取，见register_console

up = v8uart_ports[co->index];

v8uart_char_tx( up, s[i] );

register_console

//设置cmdline里传进来的串口

newcon->index = console_cmdline[i].index;

newcon->setup(newcon, console_cmdline[i].options) //设置串口属性

//注册console的时候，会将先前buffer中所有的log信息都打印出来

release_console_sem

call_console_drivers

_call_console_drivers

__call_console_drivers

con->write(con, &LOG_BUF(start), end - start);

六、支持platform_driver

1 . platform_add_devices

在MACHINE_START结构体的.init_machine成员函数中，进行platform_add_devices

MACHINE_START( VC088X, "Vimicro VC0882 FPGA Board" )

????

.init_machine = vc0882_fpga_init,

MACHINE_END

static struct platform_device serial_platdev =

{

.name = "vc088x_uart",

.id = 0,

.dev = {

.platform_data = NULL,

}

};

vc0882_fpga_init( void )

{

platform_add_devices(&serial_platdev, 1);

}

2. platform_driver_register

module_init

platform_driver_register( &vc088x_uart_plat_driver );

static struct platform_driver vc088x_uart_plat_driver =

{

.probe = vc088x_uart_probe,

.remove = vc088x_uart_remove,

.suspend = vc088x_uart_suspend,

.resume = vc088x_uart_resume,

.driver = {

.name = VC088X_UART_DEV_NAME,

.owner = THIS_MODULE,

},

};

七、串口接收数据和发送数据流程

1. 相关文件

driver\serial\vc088x_uart.c

driver\serial\serial_core.c

drivers\char\n_tty.c

drivers\char\tty_io.c

driver\serial\vc088x_uart.c

882串口驱动程序

driver\serial\serial_core.c

static const struct tty_operations uart_ops = {

.write = uart_write,

};

该结构体主要提供write函数，供ldisc层来调用

uart_add_one_port()

uart_register_driver()

提供这些函数，供串口驱动使用

serial_core.c主要将tty包装了一下，使用起来更简单了。

开发串口驱动其实可以直接基于tty，只是那么做比较复杂而已。

drivers\char\n_tty.c

struct tty_ldisc_ops tty_ldisc_N_TTY = {

.read = n_tty_read,

.write = n_tty_write,

.receive_buf = n_tty_receive_buf,

};

Line discipline是线路规程的意思。

正如它的名字一样，它表示的是这条终端”线程”的输入与输出规范设置.

主要用来进行输入/输出数据的预处理。

处理之后。就会将数据交给tty_driver。

drivers\char\tty_io.c

static const struct file_operations tty_fops = {

.read = tty_read,

.write = tty_write,

.open = tty_open,

};

该结构体主要提供read、write函数，供应用程序层通过标准的linux系统调用

注： 1. tty设备本质上就是一个普普通通的设备文件。

2. 该设备文件在内核中对应的结构体为file_operations

3. tty的设备名一般为 "/dev/ttyS0"

2. 数据收发

tty_write //对应应用程序里的write()系统调用

do_tty_write(ld->ops->write, tty, file, buf, count); //ld->ops->write //n_tty_write

tty->ops->write(tty, b, nr); //uart_write

uart_start

__uart_start

port->ops->start_tx(port);

v8uart_transmit_chars((struct v8uart_port *)port );

v8uart_char_tx()

tty_read //对应应用程序里的read()系统调用

(ld->ops->read)(tty, file, buf, count); //n_tty_read

add_wait_queue(&tty->read_wait, &wait); //等待

????

copy_from_read_buf

copy_to_user(*b, &tty->read_buf[tty->read_tail], n);

v8uart_irq_handle

uart_insert_char()

tty_insert_flip_char

tty_insert_flip_string_flags

memcpy(tb->char_buf_ptr + tb->used, chars, space); //拷贝到tty_buffer中去

tty_flip_buffer_push()

flush_to_ldisc();

flush_to_ldisc() //刷新到tty层，如果不执行，应用层就read不到数据

disc->ops->receive_buf() //n_tty_receive_buf()

memcpy(tty->read_buf + tty->read_head, cp, i);

n_tty_receive_char

process_echoes(tty); //回显字符

wake_up_interruptible(&tty->read_wait); //唤醒等待

基于Linux2.6.22和s3c2440的串口驱动简析---(1) 2013-11-21 15:56:32

Linux的终端设备这一块，涉及的面还是比较多的。经过几天的分析，有点收获，就写出来和大家分享分享，如果有不对的地方，还希望大家提出来。

s3c2440的串口驱动部分，分为platform/tty/console三部分。

既然是分析s3c2440的uart部分，那么第一个该看的就是drivers\serial\s3c2410.c文件。在此文件中，可以找到下面的代码：

1.module_init(s3c24xx_serial_modinit);

2. module_exit(s3c24xx_serial_modexit);

通过上面的两句代码，就很明确的告诉我们，首先需要关注的函数就是：s3c24xx_serial_modinit

1.static int __init s3c24xx_serial_modinit(void)

2.{

3. int ret;

4.

5. ret = uart_register_driver(&s3c24xx_uart_drv);

6. if (ret < 0) {

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

8. return -1;

9. }

10.

11. s3c2400_serial_init(); //不需要关注

12. s3c2410_serial_init(); //不需要关注

13. s3c2412_serial_init(); //不需要关注

14. s3c2440_serial_init();

15.

16. return 0;

17.}

既然分为三部分，那么这次就只说一部分，那就是platform这一部分，通过前面博文中对platform的分析，可知，会有platform_driver和platform_device两个结构体会被定义。那么就让我们把他们找出来：

platform_driver部分：

通过分析s3c24xx_serial_modinit函数，会发现如下的调用关系：

1.s3c2410_serial_init

2. s3c24xx_serial_init(&s3c2410_serial_drv, &s3c2410_uart_inf);

3. platform_driver_register(drv);

4. driver_register(&drv->driver);

5. bus_add_driver(drv);

6. driver_attach(drv);

7. bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);

8. fn(dev, data); ---> __driver_attach(dev, data);

9.

driver_probe_device(drv, dev);

10. drv->bus->match(dev, drv) ---> platform_match

11. (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0)

12. really_probe(dev, drv);

也就是说，s3c24xx_serial_modinit将s3c2410_serial_drv这个实例化的platform_driver结构体注册到了platform总线上。

1.static struct platform_driver s3c2440_serial_drv = {

2. .probe = s3c2440_serial_probe,

3. .remove = s3c24xx_serial_remove,

4. .suspend = s3c24xx_serial_suspend,

5. .resume = s3c24xx_serial_resume,

6. .driver = {

7. .name = "s3c2440-uart",

8. .owner = THIS_MODULE,

9. },

10.};

platform_driver部分：

有platform_driver,自然就有platform_device。我们可以在arch\arm\plat-s3c24xx\Cpu.c文件中，找到如下函数：

1.

2. static int __init s3c_arch_init(void)

3. {

4. int ret;

5.

6. // do the correct init for cpu

7.

8. if (cpu == NULL)

9. panic("s3c_arch_init: NULL cpu\n");

10.

11. ret = (cpu->init)();

12. if (ret != 0)

13. return ret;

14.

15. ret = platform_add_devices(s3c24xx_uart_devs, nr_uarts);

16. return ret;

17. }

18.

19. arch_initcall(s3c_arch_init);

在查找s3c24xx_uart_devs这个东东时，发现arch\arm\plat-s3c24xx\Devs.c中有如下定义

1.struct platform_device *s3c24xx_uart_devs[3] = {

2.};

也就是它默认定义为指向platform_device的指针数组，那细想，自然会有地方会对其进行赋值。s3c24xx_uart_devs赋值的地方又在什么地方呢？？在源码中搜索，会发下函数：

1. void __init s3c24xx_init_uartdevs(char *name,

2. struct s3c24xx_uart_resources *res,

3. struct s3c2410_uartcfg *cfg, int no)

4. {

5. struct platform_device *platdev;

6. struct s3c2410_uartcfg *cfgptr = uart_cfgs;

7. struct s3c24xx_uart_resources *resp;

8. int uart;

9.

10. memcpy(cfgptr, cfg, sizeof(struct s3c2410_uartcfg) * no);

11.

12. for (uart = 0; uart < no; uart++, cfg++, cfgptr++) {

13. platdev = s3c24xx_uart_src[cfgptr->hwport];

14.

15. resp = res + cfgptr->hwport;

16.

17. s3c24xx_uart_devs[uart] = platdev; //给s3c24xx_uart_devs进行赋值

18.

19. platdev->name = name;

20. platdev->resource = resp->resources;

21. platdev->num_resources = resp->nr_resources;

22.

23. platdev->dev.platform_data = cfgptr;

24. }

25.

26. nr_uarts = no; //给nr_uarts进行赋值

27. }

那么s3c24xx_init_uartdevs又是在什么地方被调用的呢？其调用关系如下:

1. smdk2440_map_io

2. s3c24xx_init_io(smdk2440_iodesc, ARRAY_SIZE(smdk2440_iodesc));

3. cpu = s3c_lookup_cpu(idcode);

4. tab = cpu_ids;

5. for (count = 0; count < ARRAY_SIZE(cpu_ids); count++, tab++) {

6. if ((idcode & tab->idmask) == tab->idcode)

7. return tab;

8. }

9. (cpu->map_io)(mach_desc, size); ---> s3c244x_map_io

10. s3c24xx_init_clocks(12000000);

11. s3c24xx_init_uarts(smdk2440_uartcfgs, ARRAY_SIZE(smdk2440_uartcfgs));

12. (cpu->init_uarts)(cfg, no); ---> s3c244x_init_uarts

13. s3c24xx_init_uartdevs("s3c2440-uart", s3c2410_uart_resources, cfg, no); //初始化struct platform_device *s3c24xx_uart_devs[3]

smdk2440_map_io则是在内核启动的第二阶段被调用的：

1. start_kernel

2. setup_arch(&command_line);

3. mdesc = setup_machine(machine_arch_type);

4. lookup_machine_type(nr);

5. machine_name = mdesc->name;

6. paging_init(&meminfo, mdesc);

7. devicemaps_init(mdesc);

8. mdesc->map_io();

9. init_arch_irq = mdesc->init_irq;

10. system_timer = mdesc->timer;

11. init_machine = mdesc->init_machine;

12.

13.

14. MACHINE_START(S3C2440, "SMDK2440")

15. /* Maintainer: Ben Dooks <ben@fluff.org> */

16. .phys_io = S3C2410_PA_UART,

17. .io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,

18. .boot_params = S3C2410_SDRAM_PA + 0x100,

19.

20. .init_irq = s3c24xx_init_irq,

21. .map_io = smdk2440_map_io,

22. .init_machine = smdk2440_machine_init,

23. .timer = &s3c24xx_timer,

24. MACHINE_END

到此，s3c2440的串口的platform部分就说完了，系统在注册s3c24xx_init_uartdevs后，又注册了s3c2410_serial_drv，之后就会自动调用s3c2440_serial_probe，其作用将在 基于Linux2.6.22和s3c2440的串口驱动简析---(2）中进行分析。

基于Linux2.6.22和s3c2440的串口驱动简析---(2) 2013-11-21 15:58:49

上文说的是串口的platform部分，自然这次说的就是串口的tty部分。

现在就要追溯到上文s3c24xx_serial_modinit函数中的uart_register_driver(&s3c24xx_uart_drv)函数：

1.static struct uart_driver s3c24xx_uart_drv = {

2. .owner = THIS_MODULE,

3. .dev_name = "s3c2410_serial",

4. .nr = 3,

5. .cons = S3C24XX_SERIAL_CONSOLE,

6. .driver_name = S3C24XX_SERIAL_NAME, //#define S3C24XX_SERIAL_NAME "ttySAC"

7. .major = S3C24XX_SERIAL_MAJOR, //#define S3C24XX_SERIAL_MAJOR 204

8. .minor = S3C24XX_SERIAL_MINOR, //#define S3C24XX_SERIAL_MINOR 64

9.};

1.int uart_register_driver(struct uart_driver *drv)

2.{

3. struct tty_driver *normal = NULL;

4. int i, retval;

5.

6. BUG_ON(drv->state);

7.

8. /*

9. * Maybe we should be using a slab cache for this, especially if

10. * we have a large number of ports to handle.

11. */

12. drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);

13. retval = -ENOMEM;

14. if (!drv->state)

15. goto out;

16.

17. normal = alloc_tty_driver(drv->nr); //分配tty_driver

18. if (!normal)

19. goto out;

20.

21. drv->tty_driver = normal;

22.

23. normal->owner = drv->owner; //将uart_driver中的相关信息赋值给

tty_driver

24. normal->driver_name = drv->driver_name;

25. normal->name = drv->dev_name;

26. normal->major = drv->major;

27. normal->minor_start = drv->minor;

28. normal->type = TTY_DRIVER_TYPE_SERIAL;

29. normal->subtype = SERIAL_TYPE_NORMAL;

30. normal->init_termios = tty_std_termios; //给tty_driver设置默认的线路设置 tty_std_termios，并在后续进行赋值修改

31. normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;

32. normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;

33. normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

34. normal->driver_state = drv;

35. tty_set_operations(normal, &uart_ops); //给tty_driver设置默认的操作函数uart_ops,这是由内核为我们实现的一个tty_operations结构体实例。

36.

37. /*

38. * Initialise the UART state(s).

39. */

40. for (i = 0; i < drv->nr; i++) {

41. struct uart_state *state = drv->state + i;

42.

43. state->close_delay = 500; /* .5 seconds */

44. state->closing_wait = 30000; /* 30 seconds */

45.

46. mutex_init(&state->mutex);

47. }

48.

49. retval = tty_register_driver(normal); //调用tty_register_driver

50. out:

51. if (retval < 0) {

52. put_tty_driver(normal);

53. kfree(drv->state);

54. }

55. return retval;

56.}

那么我们就继续分析下tty_register_driver，整个函数的作用是分配字符设备，并进行初始化和注册。

1.int tty_register_driver(struct tty_driver *driver)

2.{

3. ?? ?? ??

4. /*driver->minor_start=*/

5. if (!driver->major) {

6.

7. error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,

8. driver->name);

9. if (!error) {

10. driver->major = MAJOR(dev);

11. driver->minor_start = MINOR(dev);

12. }

13. } else {

14. dev = MKDEV(driver->major, driver->minor_start);

15. error = register_chrdev_region(dev, driver->num, driver->name);

16. }

17. ?? ?? ??

18. cdev_init(&driver->cdev, &tty_fops); //设备绑定了tty_fops这个file_operations结构体实例

19. driver->cdev.owner = driver->owner;

20. error = cdev_add(&driver->cdev, dev, driver->num);

21. ?? ?? ??

22.}

这样，以后在用户层对串口设备进行读写等操作时，就会执行tty_fops中的相关函数，即：

1.static const struct file_operations tty_fops = {

2. .llseek = no_llseek,

3. .read = tty_read,

4. .write = tty_write,

5. .poll = tty_poll,

6. .ioctl = tty_ioctl,

7. .compat_ioctl = tty_compat_ioctl,

8. .open = tty_open,

9. .release = tty_release,

10. .fasync = tty_fasync,

11.};

例如其中的tty_open函数：

1.static int tty_open(struct inode * inode, struct file * filp)

2.{

3. ???? ???? ????

4. retval = tty->driver->open(tty, filp); //这个就是在调用tty_driver中的open函数，即uart_ops实例中的uart_open

5. ???? ???? ????

6.}

uart_ops实例的定义如下：

1.static const struct tty_operations uart_ops = {

2. .open = uart_open,

3. .close = uart_close,

4. .write = uart_write,

5. .put_char = uart_put_char,

6. .flush_chars = uart_flush_chars,

7. .write_room = uart_write_room,

8. .chars_in_buffer= uart_chars_in_buffer,

9. .flush_buffer = uart_flush_buffer,

10. .ioctl = uart_ioctl,

11. .throttle = uart_throttle,

12. .unthrottle = uart_unthrottle,

13. .send_xchar = uart_send_xchar,

14. .set_termios = uart_set_termios,

15. .stop = uart_stop,

16. .start = uart_start,

17. .hangup = uart_hangup,

18. .break_ctl = uart_break_ctl,

19. .wait_until_sent= uart_wait_until_sent,

20. #ifdef CONFIG_PROC_FS

21. .read_proc = uart_read_proc,

22. #endif

23. .tiocmget = uart_tiocmget,

24. .tiocmset = uart_tiocmset,

25.};

对uart_ops中的uart_oepn进行分析，发现如下调用关系：

1.uart_open

2. uart_startup(state, 0);

3. port->ops->startup(port); //uart_ops结构体中的startup函数 (通tty_operations的uart_ops实例不同)

而s3c2440的uart_ops结构体定义如下：

1.static struct uart_ops s3c24xx_serial_ops = {

2. .pm = s3c24xx_serial_pm,

3. .tx_empty = s3c24xx_serial_tx_empty,

4. .get_mctrl = s3c24xx_serial_get_mctrl,

5. .set_mctrl = s3c24xx_serial_set_mctrl,

6. .stop_tx = s3c24xx_serial_stop_tx,

7. .start_tx = s3c24xx_serial_start_tx,

8. .stop_rx = s3c24xx_serial_stop_rx,

9. .enable_ms = s3c24xx_serial_enable_ms,

10. .break_ctl = s3c24xx_serial_break_ctl,

11. .startup = s3c24xx_serial_startup,

12. .shutdown = s3c24xx_serial_shutdown,

13. .set_termios = s3c24xx_serial_set_termios,

14. .type = s3c24xx_serial_type,

15. .release_port = s3c24xx_serial_release_port,

16. .request_port = s3c24xx_serial_request_port,

17. .config_port = s3c24xx_serial_config_port,

18. .verify_port = s3c24xx_serial_verify_port,

19.};

其被赋值于：

1.static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] = {

2. [0] = {

3. .port = {

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

5. .iotype = UPIO_MEM,

6. .irq = IRQ_S3CUART_RX0,

7. .uartclk = 0,

8. .fifosize = 16,

9. .ops = &s3c24xx_serial_ops, //见这里

10. .flags = UPF_BOOT_AUTOCONF,

11. .line = 0,

12. }

13. },

14. [1] = {

15. .port = {

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

17. .iotype = UPIO_MEM,

18. .irq = IRQ_S3CUART_RX1,

19. .uartclk = 0,

20. .fifosize = 16,

21. .ops = &s3c24xx_serial_ops,

22. .flags = UPF_BOOT_AUTOCONF,

23. .line = 1,

24. } = =

25. },

26. #if NR_PORTS > 2

27.

28. [2] = {

29. .port = {

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

31. .iotype = UPIO_MEM,

32. .irq = IRQ_S3CUART_RX2,

33. .uartclk = 0,

34. .fifosize = 16,

35. .ops = &s3c24xx_serial_ops,

36. .flags = UPF_BOOT_AUTOCONF,

37. .line = 2,

38. }

39. }

40. #endif

41.};

到这个时候，我们就需要分析下，在上文 基于Linux2.6.22和s3c2440的串口驱动简析---(1) 最后说到 s3c2440_serial_probe，那么这个函数的功能是什么呢？对其分析会发现如下的调用关系：

1.s3c2410_serial_probe

2. s3c24xx_serial_probe(dev, &s3c2410_uart_inf);

3. ourport = &s3c24xx_serial_ports[probe_index]; //此处引用了上面的s3c24xx_serial_ports

4. s3c24xx_serial_init_port(ourport, info, dev); //完成硬件寄存器初始化

5. s3c24xx_serial_resetport(port, cfg);

6. (info->reset_port)(port, cfg); ---> s3c2410_serial_resetport

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

8. state = drv->state + port->line; //将s3c24xx_serial_ports中的uart_port赋给了uart_driver中的uart_state->port

9. state->port = port;

10. uart_configure_port(drv, state, port);

11. port->ops->config_port(port, flags); //port->flags & UPF_BOOT_AUTOCONF

12. tty_register_device(drv->tty_driver, port->line, port->dev); //这个是关键， tty_register_device

13. device_create(tty_class, device, dev, name);

14. device_register(dev);

15. device_add(dev);

16.

tty部分总结：

当用户对tty驱动所分配的设备节点进行系统调用时，tty_driver所拥有的tty_operations中的成员函数会被tty核心调用，之后串口核心层的uart_ops中的成员函数会被tty_operations中的成员函数再次调用。

这样，由于内核已经将tty核心层和tty驱动层实现了，那么我们需要做的就是对具体的设备，实现串口核心层的uart_ops、uart_ports、uart_driver等结构体实例。

至此，tty_register_driver和tty_register_device都被调用了。整个过程还是比较繁琐的