tiny4412 串口驱动分析八 --- log打印的几个阶段之内核启动阶段(printk tiny4412串口驱动的注册)
作者：彭东林
邮箱：pengdonglin137@163.com
开发板：tiny4412ADK+S700 4GB Flash
主机：Wind7 64位
虚拟机：Vmware+Ubuntu12_04
u-boot：U-Boot 2010.12
Linux内核版本：linux-3.0.31
Android版本：android-4.1.2
作者：彭东林
开发板：tiny4412ADK+S700 4GB Flash
主机：Wind7 64位
虚拟机：Vmware+Ubuntu12_04
u-boot：U-Boot 2010.12
Linux内核版本：linux-3.0.31
Android版本：android-4.1.2
在arch/arm/mach-exynos/mach-tiny4412.c中：
MACHINE_START(TINY4412, "TINY4412")
.boot_params = S5P_PA_SDRAM + 0x100,
.init_irq = exynos4_init_irq,
.map_io = smdk4x12_map_io,
.init_machine = smdk4x12_machine_init,
.timer = &exynos4_timer,
.reserve = &exynos4_reserve,
MACHINE_END
在文件arch/arm/kernel/setup.c中：
static int __init customize_machine(void)
{
if (machine_desc->init_machine)
machine_desc->init_machine();
return 0;
}
arch_initcall(customize_machine);
在文件arch/arm/plat-samsung/init.c中：
static int __init s3c_arch_init(void)
{
int ret;
…
ret = (cpu->init)();
…
ret = platform_add_devices(s3c24xx_uart_devs, nr_uarts);
return ret;
}
arch_initcall(s3c_arch_init);
这几个函数跟uart有关，我们先看一下内核启动的时候是如何调用这个函数：
start_kernel (init/main.c)
--- setup_arch (arch/arm/kernel/setup.c)
--- paging_init (arch/arm/mm/mmu-cma.c)
--- devicemaps_init (arch/arm/mm/mmu-cma.c)
--- mdesc->map_io() ----- smdk4x12_map_io
--- rest_init
---kernel_init
--- do_pre_smp_initcalls (init/main.c)
--- do_basic_setup
--- do_initcalls
static void __init do_pre_smp_initcalls(void)
{
initcall_t *fn;
for (fn = __initcall_start; fn < __early_initcall_end; fn++)
do_one_initcall(*fn);
}
static void __init do_initcalls(void)
{
initcall_t *fn;
for (fn = __early_initcall_end; fn < __initcall_end; fn++)
do_one_initcall(*fn);
// 在这里会调用customize_machine和s3c_arch_init
}
在文件include/linux/init.h中：
#define __define_initcall(level,fn,id) \
static initcall_t __initcall_##fn##id __used \
__attribute__((__section__(".initcall" level ".init"))) = fn
#define arch_initcall(fn) __define_initcall("3",fn,3)
对于arch_initcall(customize_machine)展开后就是：
static initcall_t __initcall_ customize_machine3 __used \
__attribute__((__section__(".initcall3.init"))) = customize_machine
在arch/arm/kernel/vmlinux.lds中：
__initcall_start = .; *(.initcallearly.init) __early_initcall_end = .; *(.initcall0.init) *(.initcall0s.init) *(.initcall1.init) *(.initcall1s.init) *(.initcall2.init) *(.initcall2s.init) *(.initcall3.init) *(.initcall3s.init) *(.initcallbresume.init) *(.initcallresume.init) *(.initcall4.init) *(.initcall4s.init) *(.initcall5.init) *(.initcall5s.init) *(.initcallrootfs.init) *(.initcall6.init) *(.initcall6s.init) *(.initcall7.init) *(.initcall7s.init) __initcall_end = .;
通过上面的分析，大致知道这几个函数的调用过程了。
下面继续分析：
static void __init smdk4x12_map_io(void)
{
clk_xusbxti.rate = 24000000;
// 宏S5P_VA_CHIPID的值是S3C_ADDR(0x02000000)
s5p_init_io(NULL, 0, S5P_VA_CHIPID); // 获取cpu id
s3c24xx_init_clocks(24000000); // 初始化时钟资源
s3c24xx_init_uarts(smdk4x12_uartcfgs, ARRAY_SIZE(smdk4x12_uartcfgs));
/*
初始化uart，此时并没有进行注册，只是填充了一些结构体，提供给注册时用，数组smdk4x12_uartcfgs中是关于每一个uart控制器的寄存器默认参数，如：
static struct s3c2410_uartcfg smdk4x12_uartcfgs[] __initdata = {
[0] = {
.hwport = 0,
.flags = 0,
.ucon = SMDK4X12_UCON_DEFAULT,
.ulcon = SMDK4X12_ULCON_DEFAULT,
.ufcon = SMDK4X12_UFCON_DEFAULT,
},
...
}
*/
exynos4_reserve_mem(); // 预留内存
}
下面我们一一分析上面的每个函数
- s5p_init_io 函数
void __init s5p_init_io(struct map_desc *mach_desc,
int size, void __iomem *cpuid_addr)
{
/* initialize the io descriptors we need for initialization */
/*
数组s5p_iodesc中记录了一些物理地址和虚拟地址的对应关系，如：
static struct map_desc s5p_iodesc[] __initdata = {
{
.virtual = (unsigned long)S5P_VA_CHIPID,
.pfn = __phys_to_pfn(S5P_PA_CHIPID),
.length = SZ_4K,
.type = MT_DEVICE,
},
……
}
*/
iotable_init(s5p_iodesc, ARRAY_SIZE(s5p_iodesc)); // 静态映射内存资源
if (mach_desc)
iotable_init(mach_desc, size);
/* detect cpu id and rev.
这里cpuid_addr的值是S5P_VA_CHIPID，从上面的代码可以知道S5P_VA_CHIPID对应的物理地址是S5P_PA_CHIPID，即0x10000000，这个是exynos4412的PRO_ID寄存器，通过在u-boot读取到寄存器0x10000000的值，注意：由于在u-boot中开启了mmu，需要判断这个物理地址0x10000000对应的虚拟机地址是多少，还好，我们的u-boot中将物理地址0x0000_0000 -- 0x1FFF_FFFF 映射到了0x0000_0000 -- 0x1FFF_FFFF，所以我们直接使用命令 md 0x10000000 即可，我试了一下，结果如下：
TINY4412 # md 0x10000000 0x4
10000000: e4412011 08051008 00000009 00000010 . A............
*/
s5p_init_cpu(cpuid_addr); // 读取cpu_id
/*
下面是函数s5p_init_cpu的实现
void __init s5p_init_cpu(void __iomem *cpuid_addr)
{
samsung_cpu_id = __raw_readl(cpuid_addr);
samsung_cpu_rev = samsung_cpu_id & 0xFF;
}
所以samsung_cpu_id的值是 0xe4412011，samsung_cpu_id的值是0x11
*/
s3c_init_cpu(samsung_cpu_id, cpu_ids, ARRAY_SIZE(cpu_ids));
/*
数组cpu_ids中列出了一些类samsung的soc芯片的信息，关于exynos4412的信息如下：
static struct cpu_table cpu_ids[] __initdata = {
...
{
.idcode = EXYNOS4412_CPU_ID, // 0xE4412200
.idmask = EXYNOS_CPU_MASK, // 0xFFFE0000
.map_io = exynos4_map_io,
.init_clocks = exynos4_init_clocks,
.init_uarts = exynos4_init_uarts,
.init = exynos4_init,
.name = name_exynos4412, // "EXYNOS4412"
},
...
}
*/
}
下面的函数的目的是从cpu_ids中找到与samsung_cpu_id匹配的数组元素
void __init s3c_init_cpu(unsigned long idcode,
struct cpu_table *cputab, unsigned int cputab_size)
{
cpu = s3c_lookup_cpu(idcode, cputab, cputab_size);
/* 下面是函数s3c_lookup_cpu的实现，目的就是从上面的cpu_ids中找到了跟刚才读到的cpu id相等的数组元素
static struct cpu_table * __init s3c_lookup_cpu(unsigned long idcode,
struct cpu_table *tab,
unsigned int count)
{
for (; count != 0; count--, tab++) {
if ((idcode & tab->idmask) == (tab->idcode & tab->idmask))
return tab;
}
return NULL;
}
通过上面的循环就可以找到exynos4412对应的cpu_ids
*/
…
cpu->map_io(); // 调用的是exynos4_map_io
}
- s3c24xx_init_clocks 函数
void __init s3c24xx_init_clocks(int xtal)
{
…
(cpu->init_clocks)(xtal); // 调用的是exynos4_init_clocks，初始化系统时钟资源
}
- s3c24xx_init_uarts
cfg指向了一个数组，no是数组的元素个数，cfg数组中每一项对应了一个uart控制器的寄存器默认配置参数
void __init s3c24xx_init_uarts(struct s3c2410_uartcfg *cfg, int no)
{
…
(cpu->init_uarts)(cfg, no); // 调用函数exynos4_init_uarts
}
在文件arch/arm/plat-s5p/include/plat/exynos4.h中：
#define exynos4_init_uarts exynos_common_init_uarts
void __init exynos_common_init_uarts(struct s3c2410_uartcfg *cfg, int no)
{
struct s3c2410_uartcfg *tcfg = cfg;
u32 ucnt;
// 下面这个循环的目的是为每一个uart指定之中源
for (ucnt = 0; ucnt < no; ucnt++, tcfg++) {
if (!tcfg->clocks) {
tcfg->has_fracval = 1;
tcfg->clocks = exynos_serial_clocks;
tcfg->clocks_size = ARRAY_SIZE(exynos_serial_clocks);
}
tcfg->flags |= NO_NEED_CHECK_CLKSRC;
}
// s5p_uart_resources数组中存放的是每一个uart控制器的使用的寄存器资源、中断资源
s3c24xx_init_uartdevs("s5pv210-uart", s5p_uart_resources, cfg, no);
}
下面这个函数的目的是填充每一个uart控制器对应的platform_device
void __init s3c24xx_init_uartdevs(char *name,
struct s3c24xx_uart_resources *res,
struct s3c2410_uartcfg *cfg, int no)
{
struct platform_device *platdev;
struct s3c2410_uartcfg *cfgptr = uart_cfgs;
struct s3c24xx_uart_resources *resp;
int uart;
memcpy(cfgptr, cfg, sizeof(struct s3c2410_uartcfg) * no);
for (uart = 0; uart < no; uart++, cfg++, cfgptr++) {
platdev = s3c24xx_uart_src[cfgptr->hwport]; // 每一个uart对应一个platform_device
resp = res + cfgptr->hwport; // 找到编号为cfgptr->hwport的uart对应的res资源地址
s3c24xx_uart_devs[uart] = platdev; // 将来会注册其中的每一个platform_device
platdev->name = name; // "s5pv210-uart"，将来会执行同名的platform_driver的probe函数
platdev->resource = resp->resources; // platform_device对应的资源
platdev->num_resources = resp->nr_resources; // platform_device对应的资源格式
platdev->dev.platform_data = cfgptr; // 每个uart控制器的寄存器默认值
}
nr_uarts = no; // uart个数
}
至此，注册uart设备所需要的条件都已准备好，其实就是填充每一个uart对应的platform_device结构体，下面开始注册：
static int __init s3c_arch_init(void)
{
int ret;
…
ret = (cpu->init)(); // 调用函数exynos4_init
…
ret = platform_add_devices(s3c24xx_uart_devs, nr_uarts);
return ret;
}
至此uart对应的platform_device已经注册完成了，下面开始分析uart对应的platform_driver，关于部分代码在drivers/tty/serial/s5pv210.c中：
static struct platform_driver s5p_serial_driver = {
.probe = s5p_serial_probe,
.remove = __devexit_p(s3c24xx_serial_remove),
.driver = {
.name = "s5pv210-uart",
.owner = THIS_MODULE,
},
};
static int __init s5p_serial_init(void)
{
// s5p_uart_inf 数组中每个元素对应一个uart控制器的fifo配置
return s3c24xx_serial_init(&s5p_serial_driver, *s5p_uart_inf);
}
static struct s3c24xx_uart_info *s5p_uart_inf[] = {
[0] = &s5p_port_fifo256,
…
};
static struct s3c24xx_uart_info s5p_port_fifo256 = {
S5PV210_UART_DEFAULT_INFO(256),
};
#define S5PV210_UART_DEFAULT_INFO(fifo_size) \
.name = "Samsung S5PV210 UART0", \
.type = PORT_S3C6400, \
.fifosize = fifo_size, \
.has_divslot = 1, \
.rx_fifomask = S5PV210_UFSTAT_RXMASK, \
.rx_fifoshift = S5PV210_UFSTAT_RXSHIFT, \
.rx_fifofull = S5PV210_UFSTAT_RXFULL, \
.tx_fifofull = S5PV210_UFSTAT_TXFULL, \
.tx_fifomask = S5PV210_UFSTAT_TXMASK, \
.tx_fifoshift = S5PV210_UFSTAT_TXSHIFT, \
.get_clksrc = s5pv210_serial_getsource, \
.set_clksrc = s5pv210_serial_setsource, \
.reset_port = s5pv210_serial_resetport
看来驱动的注册是在s3c24xx_serial_init中完成的：
int s3c24xx_serial_init(struct platform_driver *drv,
struct s3c24xx_uart_info *info)
{
drv->suspend = s3c24xx_serial_suspend; // 休眠函数
drv->resume = s3c24xx_serial_resume; // 唤醒函数
return platform_driver_register(drv);
}
然后s5p_serial_probe就会获得执行，可以知道，由于有4个uart，所以这个函数会执行四次。
static int s5p_serial_probe(struct platform_device *pdev)
{
return s3c24xx_serial_probe(pdev, s5p_uart_inf[pdev->id]);
}
在文件drivers/tty/serial/samsung.c中：
static int probe_index;
int s3c24xx_serial_probe(struct platform_device *dev,
struct s3c24xx_uart_info *info)
{
struct s3c24xx_uart_port *ourport;
int ret;
ourport = &s3c24xx_serial_ports[probe_index];
probe_index++;
ret = s3c24xx_serial_init_port(ourport, info, dev);
…
uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);
platform_set_drvdata(dev, &ourport->port);
ret = device_create_file(&dev->dev, &dev_attr_clock_source);
…
ret = s3c24xx_serial_cpufreq_register(ourport);
…
return 0;
…
}
要继续分析这个函数，就需要先分析drivers/tty/serial/samsung.c，因为uart_add_one_port依赖uart_register_driver。
下面我们分析samsung.c：
static int __init s3c24xx_serial_modinit(void)
{
int ret;
ret = uart_register_driver(&s3c24xx_uart_drv);
…
return 0;
}
结构体s3c24xx_uart_drv定义如下：
static struct uart_driver s3c24xx_uart_drv = {
.owner = THIS_MODULE,
.driver_name = "s3c2410_serial",
.nr = CONFIG_SERIAL_SAMSUNG_UARTS, // 4
.cons = S3C24XX_SERIAL_CONSOLE,
.dev_name = S3C24XX_SERIAL_NAME, // “ttySAC”
.major = S3C24XX_SERIAL_MAJOR, // 204
.minor = S3C24XX_SERIAL_MINOR, // 64
};
#define S3C24XX_SERIAL_CONSOLE &s3c24xx_serial_console
下面这个结构体会在register_console时调用，将来内核中的printk就会调用这个结构体中的write函数向串口终端中输出信息
static struct console s3c24xx_serial_console = {
.name = S3C24XX_SERIAL_NAME, // “ttySAC”
.device = uart_console_device,
.flags = CON_PRINTBUFFER,
.index = -1,
.write = s3c24xx_serial_console_write,
.setup = s3c24xx_serial_console_setup,
.data = &s3c24xx_uart_drv,
};
下面分析uart_register_driver
int uart_register_driver(struct uart_driver *drv)
{
struct tty_driver *normal;
int i, retval;
…
drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL); // 4
…
normal = alloc_tty_driver(drv->nr); // normal->num = 4;
/* 函数alloc_tty_driver的定义如下：
struct tty_driver *alloc_tty_driver(int lines)
{
struct tty_driver *driver;
driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
if (driver) {
kref_init(&driver->kref);
driver->magic = TTY_DRIVER_MAGIC;
driver->num = lines;
/* later we'll move allocation of tables here */
}
return driver;
}
*/
…
drv->tty_driver = normal;
normal->owner = drv->owner;
normal->driver_name = drv->driver_name; // "s3c2410_serial"
normal->name = drv->dev_name; // “ttySAC”
normal->major = drv->major; // 204
normal->minor_start = drv->minor; // 64
normal->type = TTY_DRIVER_TYPE_SERIAL;
normal->subtype = SERIAL_TYPE_NORMAL;
normal->init_termios = tty_std_termios;
normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
normal->driver_state = drv;
tty_set_operations(normal, &uart_ops); // normal->ops = &uart_ops
for (i = 0; i < drv->nr; i++) {
struct uart_state *state = drv->state + i;
struct tty_port *port = &state->port;
tty_port_init(port);
port->ops = &uart_port_ops;
port->close_delay = 500; /* .5 seconds */
port->closing_wait = 30000; /* 30 seconds */
tasklet_init(&state->tlet, uart_tasklet_action,
(unsigned long)state);
}
retval = tty_register_driver(normal);
…
put_tty_driver(normal);
out_kfree:
kfree(drv->state);
out:
return -ENOMEM;
}
下面分析函数tty_register_driver：
int tty_register_driver(struct tty_driver *driver)
{
int error;
int i;
dev_t dev;
void **p = NULL;
struct device *d;
if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
…
}
if (!driver->major) {
...
} else {
/*
这里会申请4个设备号，从204开始，被名为“ttySAC”的设备占有
通过命令 cat /proc/devices 可以看到，但是此时还没有在/dev/下生成ttySAC0~4这些设备号，
这里注意：申请了四个设备号，意思是可以对应四个设备结点，并且这四个设备结点共用这个cdev，操作函数都是tty_fops。
*/
dev = MKDEV(driver->major, driver->minor_start);
error = register_chrdev_region(dev, driver->num, driver->name);
}
…
if (p) {
driver->ttys = (struct tty_struct **)p;
driver->termios = (struct ktermios **)(p + driver->num);
} else {
…
}
cdev_init(&driver->cdev, &tty_fops);
driver->cdev.owner = driver->owner;
error = cdev_add(&driver->cdev, dev, driver->num);
…
list_add(&driver->tty_drivers, &tty_drivers); // tty_drivers 是一个全局双向循环链表
…
proc_tty_register_driver(driver); // 在/proc下生成相关的的文件
driver->flags |= TTY_DRIVER_INSTALLED;
return 0;
…
}
下面分析proc_tty_register_driver
void proc_tty_register_driver(struct tty_driver *driver)
{
struct proc_dir_entry *ent;
…
// driver_name是“s3c2410_serial”
ent = proc_create_data(driver->driver_name, 0, proc_tty_driver,
driver->ops->proc_fops, driver);
driver->proc_entry = ent;
}
其中，proc_tty_driver是其父结点，通过看他的父结点的创建可以知道将来到/proc下的去找名为” s3c2410_serial”的结点
start_kernel
---- proc_root_init （fs/proc/root.c）
---- proc_tty_init （fs/proc/proc_tty.c）
void __init proc_tty_init(void)
{
if (!proc_mkdir("tty", NULL))
return;
proc_tty_ldisc = proc_mkdir("tty/ldisc", NULL);
proc_tty_driver = proc_mkdir_mode("tty/driver", S_IRUSR|S_IXUSR, NULL);
proc_create("tty/ldiscs", 0, NULL, &tty_ldiscs_proc_fops);
proc_create("tty/drivers", 0, NULL, &proc_tty_drivers_operations);
}
从这里可以知道，将来会在/proc/tty/driver下面生成结点s3c2410_serial
shell@android:/ # ls /proc/tty/driver/ -l
-r--r--r-- root root 0 2014-01-01 19:20 s3c2410_serial
-r--r--r-- root root 0 2014-01-01 19:20 serial
-r--r--r-- root root 0 2014-01-01 19:20 usbserial
下面我们还必须分析一下tty线路规程的注册，线路规程在tty驱动架构中的位置如下：
线路规划层的目的是：以协议转换的方式，格式化从一个用户或硬件收到的数据, 如PPP协议或蓝牙协议。
下面我们以我们用到的线路规划层的注册为例分析：
start_kernel
--- console_init （drivers/tty/tty_io.c）
--- tty_ldisc_begin （drivers/tty/tty_ldisc.c）
void tty_ldisc_begin(void)
{
// 在Linux中可以有多中线路规程，N_TTY只是其中一种，是默认的TTY线路规程
// N_TTY是一个宏，为0
(void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
}
struct tty_ldisc_ops tty_ldisc_N_TTY = {
.magic = TTY_LDISC_MAGIC,
.name = "n_tty",
.open = n_tty_open,
.close = n_tty_close,
.flush_buffer = n_tty_flush_buffer,
.chars_in_buffer = n_tty_chars_in_buffer,
.read = n_tty_read,
.write = n_tty_write,
.ioctl = n_tty_ioctl,
.set_termios = n_tty_set_termios,
.poll = n_tty_poll,
.receive_buf = n_tty_receive_buf,
.write_wakeup = n_tty_write_wakeup
};
int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
{
unsigned long flags;
int ret = 0;
…
tty_ldiscs[disc] = new_ldisc;
// tty_ldiscs是一个全局静态变量数组，记录了当前可以的线路规程
// 在tty_open的时候会设置相应的线路规程
new_ldisc->num = disc;
new_ldisc->refcount = 0;
…
return ret;
}
好了，我们继续分析drivers/tty/serial/samsung.c
static int probe_index;
int s3c24xx_serial_probe(struct platform_device *dev,
struct s3c24xx_uart_info *info)
{
struct s3c24xx_uart_port *ourport;
int ret;
ourport = &s3c24xx_serial_ports[probe_index];
probe_index++;
// info 数组中每个元素对应一个uart控制器的的配置方法
ret = s3c24xx_serial_init_port(ourport, info, dev);
…
uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);
platform_set_drvdata(dev, &ourport->port);
ret = device_create_file(&dev->dev, &dev_attr_clock_source);
…
ret = s3c24xx_serial_cpufreq_register(ourport);
…
return 0;
…
}
下面是结构体s3c24xx_serial_ports 的定义：
static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS] = {
[0] = {
.port = {
.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[0].port.lock),
.iotype = UPIO_MEM,
.irq = IRQ_S3CUART_RX0,
.uartclk = 0,
.fifosize = 16,
.ops = &s3c24xx_serial_ops,
.flags = UPF_BOOT_AUTOCONF,
.line = 0,
}
},
…
}
下面分析一下上面的函数：
static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
struct s3c24xx_uart_info *info,
struct platform_device *platdev)
{
struct uart_port *port = &ourport->port;
struct s3c2410_uartcfg *cfg;
struct resource *res;
int ret;
…
cfg = s3c24xx_dev_to_cfg(&platdev->dev); // 存放的是每个uart控制器的寄存器默认配置
…
/* setup info for port */
port->dev = &platdev->dev;
ourport->info = info;
/* copy the info in from provided structure */
ourport->port.fifosize = info->fifosize;
port->uartclk = 1;
…
res = platform_get_resource(platdev, IORESOURCE_MEM, 0);
…
port->mapbase = res->start; // 获得uart控制寄存器的物理基地址
port->membase = S3C_VA_UART + (res->start & 0xfffff);
// 计算虚拟地址，因为之前已经执行了静态映射，就不用ioremap了
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;
}
ret = platform_get_irq(platdev, 1);
if (ret > 0)
ourport->tx_irq = ret;
ourport->clk = clk_get(&platdev->dev, "uart"); // 获取时钟资源
…
/* reset the fifos (and setup the uart) */
//利用默认配置设置uart控制器，但是此时没有设置波特率和每帧的位数
s3c24xx_serial_resetport(port, cfg);
return 0;
}
static inline int s3c24xx_serial_resetport(struct uart_port *port,
struct s3c2410_uartcfg *cfg)
{
struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
return (info->reset_port)(port, cfg); // 调用函数s5pv210_serial_resetport
}
下面的函数的作用是利用默认参数配置uart控制器，这里从cfg的参数中没有看到设置波特率以及每帧的数据位，这个会在register_console中匹配成功时调用。
static int s5pv210_serial_resetport(struct uart_port *port,
struct s3c2410_uartcfg *cfg)
{
unsigned long ucon = rd_regl(port, S3C2410_UCON);
ucon &= S5PV210_UCON_CLKMASK;
wr_regl(port, S3C2410_UCON, ucon | cfg->ucon);
wr_regl(port, S3C2410_ULCON, cfg->ulcon);
/* reset both fifos */
wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
wr_regl(port, S3C2410_UFCON, cfg->ufcon);
wr_regl(port, S3C64XX_UINTM, 0xf);
wr_regl(port, S3C64XX_UINTP, 0xf);
/* It is need to delay when reset FIFO register */
udelay(1);
return 0;
}
wr_regl是如何实现的呢？
#define wr_regl(port, reg, val) __raw_writel(val, portaddr(port, reg))
#define portaddr(port, reg) ((port)->membase + (reg))
下面分析uart_add_one_port
int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
{
struct uart_state *state;
struct tty_port *port;
int ret = 0;
struct device *tty_dev;
…
state = drv->state + uport->line;
// 每一个uart控制器在uart_driver中都有一个state与之对应
port = &state->port;
…
state->uart_port = uport;
state->pm_state = -1;
uport->cons = drv->cons;
uport->state = state;
/*
#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line)
这里的cons就是s3c24xx_serial_console，只有一个，它的index初始值是-1，在register_console中如果跟console_cmdline的参数匹配成功，cons的index会被设置为相应的编号，如果bootargs中console=ttySAC3，那么将来cons的index会被设置为3
*/
if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
spin_lock_init(&uport->lock);
lockdep_set_class(&uport->lock, &port_lock_key);
}
uart_configure_port(drv, state, uport);
tty_dev = tty_register_device(drv->tty_driver, uport->line, uport->dev);
if (likely(!IS_ERR(tty_dev))) {
device_init_wakeup(tty_dev, 1);
device_set_wakeup_enable(tty_dev, 0);
} else
printk(KERN_ERR "Cannot register tty device on line %d\n",
uport->line);
uport->flags &= ~UPF_DEAD;
…
return ret;
}
下面分析uart_configure_port函数的实现
static void
uart_configure_port(struct uart_driver *drv, struct uart_state *state,
struct uart_port *port)
{
unsigned int flags;
…
flags = 0;
if (port->flags & UPF_AUTO_IRQ)
flags |= UART_CONFIG_IRQ;
if (port->flags & UPF_BOOT_AUTOCONF) { // 这里成立
if (!(port->flags & UPF_FIXED_TYPE)) {
port->type = PORT_UNKNOWN;
flags |= UART_CONFIG_TYPE;
}
port->ops->config_port(port, flags); // 调用函数s3c24xx_serial_config_port
/*
static void s3c24xx_serial_config_port(struct uart_port *port, int flags)
{
struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
if (flags & UART_CONFIG_TYPE &&
s3c24xx_serial_request_port(port) == 0) // 给port->mapbase赋值
port->type = info->type; // PORT_S3C6400
}
*/
}
if (port->type != PORT_UNKNOWN) { // 条件成立
unsigned long flags;
uart_report_port(drv, port);
/*
这个函数只是打印的一些信息，没有做什么工作
static inline void
uart_report_port(struct uart_driver *drv, struct uart_port *port)
{
char address[64];
switch (port->iotype) {
…
case UPIO_MEM:
…
snprintf(address, sizeof(address),
"MMIO 0x%llx", (unsigned long long)port->mapbase);
break;
…
}
printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",
port->dev ? dev_name(port->dev) : "",
port->dev ? ": " : "",
drv->dev_name,
drv->tty_driver->name_base + port->line,
address, port->irq, uart_type(port));
}
*/
/* Power up port for set_mctrl() */
uart_change_pm(state, 0);
…
/*
在这里调用了register_console，对于tiny4412有四个串口，如果传入的console参数的是ttySAC0，由于是uart0先注册的，所以第一次就匹配成功了并且cons->flags会置位CON_ENABLED，后面在注册uart1~3的时候这里的条件不成立。因为这里的cons都执行了全局变量s3c24xx_serial_console。如果u-boot传入的console参数是ttySAC3的话，这里register_console就会执行四次，因为uart0~2都没有匹配成功。在上面的分析中有一个疑问，何时设置波特率以及位宽，其实就是在register_console中设置的，但是他只给与传入的console参数匹配的uart设置波特率和位宽，当然这里的波特率和位宽也是u-boot传给内核的。tiny4412的u-boot传给内核的参数是：
set bootargs 'console=ttySAC0,115200n8 androidboot.console=ttySAC0 uhost0=n ctp=2 skipcali=y vmalloc=384m lcd=S70'
在上面分析内核解析console参数的时候，知道对于上面的参数console=ttySAC0,115200n8，会有一个结构体被赋值：
console_cmdline[0].name = “ttySAC”
console_cmdline[0].index = 0
console_cmdline[0].options = “115200n8”
*/
if (port->cons && !(port->cons->flags & CON_ENABLED))
register_console(port->cons);
if (!uart_console(port))
uart_change_pm(state, 3);
}
}
下面看一下，register_console是如何设置波特率和位宽以及disable boot console的，关于这部分请参考前面分析register_console的代码，这里把关键部分列出来：
for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];
i++) {
if (strcmp(console_cmdline[i].name, newcon->name) != 0)
continue;
if (newcon->index >= 0 &&
newcon->index != console_cmdline[i].index)
continue;
if (newcon->index < 0)
newcon->index = console_cmdline[i].index;
if (newcon->setup &&
newcon->setup(newcon, console_cmdline[i].options) != 0)
break;
newcon->flags |= CON_ENABLED;
newcon->index = console_cmdline[i].index;
if (i == selected_console) { // selected_console是从bootargs中解析出来的
newcon->flags |= CON_CONSDEV;
preferred_console = selected_console;
}
break;
}
可以看到，当匹配成功后，会调用函数setup，对于tiny4412就是：s3c24xx_serial_console_setup
static int __init s3c24xx_serial_console_setup(struct console *co, char *options) { struct uart_port *port; int baud = 9600; // 初始波特率 int bits = 8; // 初始帧宽 int parity = 'n'; // 无奇偶校验 int flow = 'n'; // 无流控 … port = &s3c24xx_serial_ports[co->index].port; /* is the port configured? */ // 这里的作用是：如果传入的console=ttySAC3，那么这里可以保证uart0~2在注册时因条件不满足返回，因为每个port在probe时才会给mapbase赋值。 if (port->mapbase == 0x0) return -ENODEV; cons_uart = port; … // 对于tiny4412，这里解析出来的options是”115200n8” // uart_parse_options会解析这个字符串，然后给相应的成员赋值，对于没有指定的参数，使用初始值 // 如果bootargs中没有指定波特率等参数，就会通过函数s3c24xx_serial_get_options动态计算出这些参数，这些参数就不可预知了，所以最好在bootargs中执行用哪个tty设备，同时指定波特率等参数，否则可能会乱码 if (options) uart_parse_options(options, &baud, &parity, &bits, &flow); else s3c24xx_serial_get_options(port, &baud, &parity, &bits); … return uart_set_options(port, co, baud, parity, bits, flow); }
int
uart_set_options(struct uart_port *port, struct console *co,
int baud, int parity, int bits, int flow)
{
struct ktermios termios;
static struct ktermios dummy;
int i;
/*
* Ensure that the serial console lock is initialised
* early.
*/
spin_lock_init(&port->lock);
lockdep_set_class(&port->lock, &port_lock_key);
memset(&termios, 0, sizeof(struct ktermios));
termios.c_cflag = CREAD | HUPCL | CLOCAL;
/*
* Construct a cflag setting.
*/
for (i = 0; baud_rates[i].rate; i++)
if (baud_rates[i].rate <= baud)
break;
termios.c_cflag |= baud_rates[i].cflag;
if (bits == 7)
termios.c_cflag |= CS7;
else
termios.c_cflag |= CS8;
switch (parity) {
case 'o': case 'O':
termios.c_cflag |= PARODD;
/*fall through*/
case 'e': case 'E':
termios.c_cflag |= PARENB;
break;
}
if (flow == 'r')
termios.c_cflag |= CRTSCTS;
port->mctrl |= TIOCM_DTR;
port->ops->set_termios(port, &termios, &dummy);
// 调用函数s3c24xx_serial_set_termios设置
if (co)
co->cflag = termios.c_cflag;
return 0;
}
当register_console执行完成后，通过printk输出的信息就可以通过选定的串口输出了，调用的就是下面这个结构体中的write函数
static struct console s3c24xx_serial_console = {
.name = S3C24XX_SERIAL_NAME,
.device = uart_console_device,
.flags = CON_PRINTBUFFER,
.index = -1,
.write = s3c24xx_serial_console_write,
.setup = s3c24xx_serial_console_setup,
.data = &s3c24xx_uart_drv,
};
static void
s3c24xx_serial_console_write(struct console *co, const char *s,
unsigned int count)
{
uart_console_write(cons_uart, s, count, s3c24xx_serial_console_putchar);
}
void uart_console_write(struct uart_port *port, const char *s,
unsigned int count,
void (*putchar)(struct uart_port *, int))
{
unsigned int i;
for (i = 0; i < count; i++, s++) {
if (*s == '\n')
putchar(port, '\r');
putchar(port, *s);
}
}
static void
s3c24xx_serial_console_putchar(struct uart_port *port, int ch)
{
unsigned int ufcon = rd_regl(cons_uart, S3C2410_UFCON);
while (!s3c24xx_serial_console_txrdy(port, ufcon))
barrier();
wr_regb(cons_uart, S3C2410_UTXH, ch);
}
这样，字符就通过串口输出到终端了。注意这里只是说明了通过printk输出的字符是如何输出到终端的，是在内核空间。
下面分析函数tty_register_device的实现：
在执行tty_register_driver的时候申请了设备号（申请了四个），注册了相应的字符设备，但是还没有在/dev下生成相应的设备结点，这里就是来生成设备结点的。如对于我们的tiny4412就是
/dev/ttySAC0、/dev/ttySAC1、/dev/ttySAC2、/dev/ttySAC3
struct device *tty_register_device(struct tty_driver *driver, unsigned index,
struct device *device)
{
char name[64];
dev_t dev = MKDEV(driver->major, driver->minor_start) + index; // 设备号,(204+64)+index
…
if (driver->type == TTY_DRIVER_TYPE_PTY)
pty_line_name(driver, index, name);
else
tty_line_name(driver, index, name); // ttySACn
return device_create(tty_class, device, dev, NULL, name);
}
static void tty_line_name(struct tty_driver *driver, int index, char *p)
{
sprintf(p, "%s%d", driver->name, index + driver->name_base);
}
至此，/dev/下就有相应的设备结点了。
本文来自博客园，作者：摩斯电码，未经同意，禁止转载
