一、UART初始化
1. kernel-3.18/drivers/misc/mediatek/uart/uart.c
static int __init mtk_uart_init(void)
{
int ret = ; tx_history.buffer = kzalloc(UART_HISTORY_DATA_SIZE, GFP_KERNEL);
rx_history.buffer = kzalloc(UART_HISTORY_DATA_SIZE, GFP_KERNEL);
tx_history.index = -;
rx_history.index = -; if (!tx_history.buffer || !rx_history.buffer)
return -ENOMEM; #ifndef CONFIG_MTK_SERIAL_CONSOLE
mtk_uart_init_ports();
#endif #if defined(ENABLE_SYSFS)
mtk_uart_sysfs();
#endif ret = uart_register_driver(&mtk_uart_drv); if (ret)
return ret; ret = platform_driver_register(&mtk_uart_dev_drv); if (ret) {
uart_unregister_driver(&mtk_uart_drv);
return ret;
}
#ifdef CONFIG_PM
mtk_uart_init_ops();
#endif #ifdef ENABLE_RAW_DATA_DUMP
mtk_uart_init_debug_spinlock();
#endif
spin_lock_init(&mtk_uart_bt_lock);
return ret;
}
第 21 行调用 uart_register_driver 函数注册 mtk_uart_drv。
mtk_uart_drv 结构如下：
static struct uart_driver mtk_uart_drv = {
.owner = THIS_MODULE,
.driver_name = DRV_NAME,
.dev_name = "ttyMT",
.major = UART_MAJOR,
.minor = UART_MINOR,
.nr = UART_NR,
#if defined(CONFIG_MTK_SERIAL_CONSOLE) && !defined(CONFIG_MTK_SERIAL_MODEM_TEST)
.cons = &mtk_uart_console,
#endif
};
static struct console mtk_uart_console = {
.name = "ttyMT",
#if !defined(CONFIG_MTK_SERIAL_MODEM_TEST)
/*don't configure UART4 as console */
.write = mtk_uart_console_write,
.setup = mtk_uart_console_setup,
#endif
.device = uart_console_device,
.flags = CON_PRINTBUFFER,
.index = -,
.data = &mtk_uart_drv,
};
uart_register_driver 函数定义在 kernel-3.18/drivers/tty/serial/serial_core.c 文件中，
/**
* uart_register_driver - register a driver with the uart core layer
* @drv: low level driver structure
*
* Register a uart driver with the core driver. We in turn register
* with the tty layer, and initialise the core driver per-port state.
*
* We have a proc file in /proc/tty/driver which is named after the
* normal driver.
*
* drv->port should be NULL, and the per-port structures should be
* registered using uart_add_one_port after this call has succeeded.
*/
int uart_register_driver(struct uart_driver *drv)
{
struct tty_driver *normal;
int i, retval; BUG_ON(drv->state); /*
* Maybe we should be using a slab cache for this, especially if
* we have a large number of ports to handle.
*/
drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
if (!drv->state)
goto out; normal = alloc_tty_driver(drv->nr);
if (!normal)
goto out_kfree; drv->tty_driver = normal; normal->driver_name = drv->driver_name;
normal->name = drv->dev_name;
normal->major = drv->major;
normal->minor_start = drv->minor;
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); /*
* Initialise the UART state(s).
*/
for (i = ; 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 = HZ / ; /* .5 seconds */
port->closing_wait = * HZ;/* 30 seconds */
} retval = tty_register_driver(normal);
if (retval >= )
return retval; for (i = ; i < drv->nr; i++)
tty_port_destroy(&drv->state[i].port);
put_tty_driver(normal);
out_kfree:
kfree(drv->state);
out:
return -ENOMEM;
}
第 33行，uart驱动与tty_driver关联起来。
第 43 行，设置 uart 的初始波特率。
第 46 行，将 tty_driver 的操作集统一设为了 uart_ops.这样就使得从用户空间下来的操作可以找到正确的 serial_core 的操作函数。Uart_ops 如下：
static const struct tty_operations uart_ops = {
.open = uart_open,
.close = uart_close,
.write = uart_write,
.put_char = uart_put_char,
.flush_chars = uart_flush_chars,
.write_room = uart_write_room,
.chars_in_buffer= uart_chars_in_buffer,
.flush_buffer = uart_flush_buffer,
.ioctl = uart_ioctl,
.throttle = uart_throttle,
.unthrottle = uart_unthrottle,
.send_xchar = uart_send_xchar,
.set_termios = uart_set_termios,
.set_ldisc = uart_set_ldisc,
.stop = uart_stop,
.start = uart_start,
.hangup = uart_hangup,
.break_ctl = uart_break_ctl,
.wait_until_sent= uart_wait_until_sent,
#ifdef CONFIG_PROC_FS
.proc_fops = &uart_proc_fops,
#endif
.tiocmget = uart_tiocmget,
.tiocmset = uart_tiocmset,
.get_icount = uart_get_icount,
#ifdef CONFIG_CONSOLE_POLL
.poll_init = uart_poll_init,
.poll_get_char = uart_poll_get_char,
.poll_put_char = uart_poll_put_char,
#endif
};
第 56 行，uart_port_ops 结构体如下：
static const struct tty_port_operations uart_port_ops = {
.activate = uart_port_activate,
.shutdown = uart_port_shutdown,
.carrier_raised = uart_carrier_raised,
.dtr_rts = uart_dtr_rts,
};
第 61 行，调用 tty_register_driver 函数，其所在文件为 kernel-3.18/drivers/tty/tty_io.c。
/*
* Called by a tty driver to register itself.
*/
int tty_register_driver(struct tty_driver *driver)
{
int error;
int i;
dev_t dev;
struct device *d; if (!driver->major) {
error = alloc_chrdev_region(&dev, driver->minor_start,
driver->num, driver->name);
if (!error) {
driver->major = MAJOR(dev);
driver->minor_start = MINOR(dev);
}
} else {
dev = MKDEV(driver->major, driver->minor_start);
error = register_chrdev_region(dev, driver->num, driver->name);
}
if (error < )
goto err; if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
error = tty_cdev_add(driver, dev, 0, driver->num);
if (error)
goto err_unreg_char;
} mutex_lock(&tty_mutex);
list_add(&driver->tty_drivers, &tty_drivers);
mutex_unlock(&tty_mutex); if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
for (i = ; i < driver->num; i++) {
d = tty_register_device(driver, i, NULL);
if (IS_ERR(d)) {
error = PTR_ERR(d);
goto err_unreg_devs;
}
}
}
proc_tty_register_driver(driver);
driver->flags |= TTY_DRIVER_INSTALLED;
return ; err_unreg_devs:
for (i--; i >= ; i--)
tty_unregister_device(driver, i); mutex_lock(&tty_mutex);
list_del(&driver->tty_drivers);
mutex_unlock(&tty_mutex); err_unreg_char:
unregister_chrdev_region(dev, driver->num);
err:
return error;
}
EXPORT_SYMBOL(tty_register_driver);
MKDEV 宏定义在 include/linux/kdev_t.h 头文件，#define MKDEV(ma,mi) (((ma)<< MINORBITS) | (mi)) 作用是将主设备号和次设备号转换成 dev_t 类型。
register_chrdev_region 为一个字符驱动获取一个或多个设备编号。
调用 cdev_add() 函数，将cdev添加到系统中去。
因normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 故没有调用tty_register_device来创建ttyMT0~ttyMT3设备。
调用proc_tty_register_driver创建/proc/tty/driver/mtk-uart文件。其driver->ops->proc_fops 为uart_ops结构体中的uart_proc_fops函数。
回到 uart_register_driver函数，调用 put_tty_driver 函数，当注册失败时，判断引用计数注销驱动。
二、回到 mtk_uart_init 函数，调用 platform_driver_register 函数注册 mtk_uart_dev_drv。
static struct platform_driver mtk_uart_dev_drv = {
.probe = mtk_uart_probe,
.remove = mtk_uart_remove,
#ifdef CONFIG_PM
.suspend = mtk_uart_suspend,
.resume = mtk_uart_resume,
#endif
.driver = {
.name = DRV_NAME,
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = apuart_of_ids,
#endif
#ifdef CONFIG_PM
.pm = &mtk_uart_pm_ops,
#endif }
};
mtk_uart_probe函数如下：
static int mtk_uart_probe(struct platform_device *pdev)
{
struct mtk_uart *uart;
int err;
#if !defined(CONFIG_FPGA_EARLY_PORTING)
#if !defined(CONFIG_MTK_CLKMGR)
static const char * const clk_uart_name[] = {
"uart0-main",
"uart1-main",
"uart2-main",
"uart3-main",
"uart4-main",
};
struct mtk_uart_setting *uart_setting = NULL;
#endif
#if !defined(CONFIG_MTK_LEGACY)
/* for GPIO pinctrl */
struct pinctrl *ppinctrl = NULL;
#endif
#endif /* !defined(CONFIG_FPGA_EARLY_PORTING) */#ifdef CONFIG_OF
if (pdev->dev.of_node) {
struct device_node *node = pdev->dev.of_node; err = of_property_read_u32(node, "cell-index", &pdev->id);
if (err)
pr_err("[DTS] get uart platform_device id fail!!\n");
}
if (pdev->id >= UART_NR) {
pr_err("DTS cell ID %d > UART nuber %d\n", pdev->id, UART_NR);
return -ENODEV;
}
#endif
uart = &mtk_uarts[pdev->id];
MSG_FUNC_ENTRY();/* For clock setting */
#if !defined(CONFIG_MTK_CLKMGR) && !defined(CONFIG_FPGA_EARLY_PORTING)
uart_setting = get_uart_default_settings(pdev->id);
uart_setting->clk_uart_main = devm_clk_get(&pdev->dev, clk_uart_name[pdev->id]);
if (IS_ERR(uart_setting->clk_uart_main)) {
pr_err("[UART%d][CCF]cannot get %s clock. ptr_err:%ld\n", pdev->id, clk_uart_name[pdev->id]
, PTR_ERR(uart_setting->clk_uart_main));
return PTR_ERR(uart_setting->clk_uart_main);
}
pr_debug("[UART%d][CCF]clk_uart%d_main:%p\n", pdev->id, pdev->id, uart_setting->clk_uart_main); if (pdev->id == ) {
struct clk *clk_uart0_dma = devm_clk_get(&pdev->dev, "uart-apdma"); if (IS_ERR(clk_uart0_dma)) {
pr_err("[UART][CCF]cannot get clk_uart0_dma clock. ptr_err:%ld\n", PTR_ERR(clk_uart0_dma));
return PTR_ERR(clk_uart0_dma);
}
set_uart_dma_clk(pdev->id, clk_uart0_dma);
pr_debug("[UART][CCF]clk_uart0_dma:%p\n", clk_uart0_dma);
}
#else /* !defined(CONFIG_MTK_CLKMGR) && !defined(CONFIG_FPGA_EARLY_PORTING) */
pr_debug("[UART][CCF]mtk_uart_probe CONFIG_MTK_CLKMGR or CONFIG_FPGA_EARLY_PORTING is defined!\n");
#endif /*!defined(CONFIG_MTK_CLKMGR) && !defined(CONFIG_FPGA_EARLY_PORTING) *//* For GPIO setting */
#if !defined(CONFIG_MTK_LEGACY) && !defined(CONFIG_FPGA_EARLY_PORTING)
ppinctrl = devm_pinctrl_get(&pdev->dev);
if (IS_ERR(ppinctrl)) {
err = PTR_ERR(ppinctrl);
pr_err("[UART%d][PinC]cannot find pinctrl. ptr_err:%ld\n", pdev->id, PTR_ERR(ppinctrl));
set_uart_pinctrl(pdev->id, NULL);
} else {
set_uart_pinctrl(pdev->id, ppinctrl);
}
pr_debug("[UART%d][PinC]set idx:%d, ppinctrl:%p\n", pdev->id, pdev->id, ppinctrl);
#else /* !defined(CONFIG_MTK_LEGACY) && !defined(CONFIG_FPGA_EARLY_PORTING) */
pr_debug("[UART][PinC]mtk_uart_probe CONFIG_MTK_LEGACY or CONFIG_FPGA_EARLY_PORTING is defined!\n");
#endif /* !defined(CONFIG_MTK_LEGACY) && !defined(CONFIG_FPGA_EARLY_PORTING) */ if (uart->setting->support_33bits) {
pdev->dev.coherent_dma_mask = DMA_BIT_MASK();
if (dma_set_mask(&pdev->dev, DMA_BIT_MASK())) {
dev_err(&pdev->dev, "dma_set_mask return error.\n");
return -EINVAL;
}
} else {
pdev->dev.coherent_dma_mask = DMA_BIT_MASK();
}
uart->port.dev = &pdev->dev;
err = uart_add_one_port(&mtk_uart_drv, &uart->port);
if (!err)
platform_set_drvdata(pdev, uart);#if defined(ENABLE_VFIFO)
err = mtk_uart_vfifo_create(uart);
if (err) {
mtk_uart_vfifo_delete(uart);
DEV_ERR("create vff buffer fail:%d\n", err);
}
#endif
return err;
}
调用uart_add_one_port向串口驱动添加一个端口。其具体实现在Kernel-3.18/drivers/tty/serial/Serial_core.c
/**
* uart_add_one_port - attach a driver-defined port structure
* @drv: pointer to the uart low level driver structure for this port
* @uport: uart port structure to use for this port.
*
* This allows the driver to register its own uart_port structure
* with the core driver. The main purpose is to allow the low
* level uart drivers to expand uart_port, rather than having yet
* more levels of structures.
*/
int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
{
struct uart_state *state;
struct tty_port *port;
int ret = ;
struct device *tty_dev;
int num_groups; BUG_ON(in_interrupt()); if (uport->line >= drv->nr)
return -EINVAL; state = drv->state + uport->line;
port = &state->port; mutex_lock(&port_mutex);
mutex_lock(&port->mutex);
if (state->uart_port) {
ret = -EINVAL;
goto out;
} state->uart_port = uport;
state->pm_state = UART_PM_STATE_UNDEFINED; uport->cons = drv->cons;
uport->state = state; /*
* If this port is a console, then the spinlock is already
* initialised.
*/
if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
spin_lock_init(&uport->lock);
lockdep_set_class(&uport->lock, &port_lock_key);
}
if (uport->cons && uport->dev)
of_console_check(uport->dev->of_node, uport->cons->name, uport->line); uart_configure_port(drv, state, uport); num_groups = ;
if (uport->attr_group)
num_groups++; uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups),
GFP_KERNEL);
if (!uport->tty_groups) {
ret = -ENOMEM;
goto out;
}
uport->tty_groups[] = &tty_dev_attr_group;
if (uport->attr_group)
uport->tty_groups[] = uport->attr_group; /*
* Register the port whether it's detected or not. This allows
* setserial to be used to alter this port's parameters.
*/
tty_dev = tty_port_register_device_attr(port, drv->tty_driver,
uport->line, uport->dev, port, uport->tty_groups);
if (likely(!IS_ERR(tty_dev))) {
device_set_wakeup_capable(tty_dev, );
} else {
dev_err(uport->dev, "Cannot register tty device on line %d\n",
uport->line);
} /*
* Ensure UPF_DEAD is not set.
*/
uport->flags &= ~UPF_DEAD; out:
mutex_unlock(&port->mutex);
mutex_unlock(&port_mutex); return ret;
}
调用uart_configure_port函数进行端口配置。
调用tty_port_register_device_attr创建ttyMT0~ttyMT3设备。
