NVIDIA Tegra-TK1串口驱动代码初探
今天大家都在抢iphoen X,我也来强行装一波X，讲讲最近读的TK1串口驱动serial-tegra.c
照旧从驱动的init函数看起。（千万别从头看起）
static int __init tegra_uart_init(void)
{
int ret;
ret = uart_register_driver(&tegra_uart_driver);
if (ret < 0) {
pr_err("Could not register %s driver\n",
tegra_uart_driver.driver_name);
return ret;
}
ret = platform_driver_register(&tegra_uart_platform_driver);
if (ret < 0) {
pr_err("Uart platfrom driver register failed, e = %d\n", ret);
uart_unregister_driver(&tegra_uart_driver);
return ret;
}
return 0;
}uart_register_driver注册tegra_uart_driver，tegra_uart_driver结构如下：
static struct uart_driver tegra_uart_driver = {
.owner = THIS_MODULE,
.driver_name = "serial-hs-tegra",
.dev_name = "ttyTHS",
.cons = NULL,
.nr = TEGRA_UART_MAXIMUM,
};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 = 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 = HZ / 2; /* .5 seconds */
//port->closing_wait = 30 * HZ;/* 30 seconds */
port->closing_wait = 10 * HZ;
}
retval = tty_register_driver(normal);
if (retval >= 0)
return retval;
for (i = 0; i < drv->nr; i++)
tty_port_destroy(&drv->state[i].port);
put_tty_driver(normal);
out_kfree:
kfree(drv->state);
out:
return -ENOMEM;
}1.drv->tty_driver = normal;将tegra_usrt_driver中的tty_driver 与tty_driver normal同步
2.normal->driver_state = drv;
这样一来只要将serial8250_ops结构体成员的值赋给我们uart_dirver就可以了，那么这个过程在哪呢？就是在uart_add_one_port()函数中，这个函数是从serial8250_init->serial8250_register_ports()->uart_add_one_port()逐步调用过来的，这一步就将port和uart_driver联系起来了。(uart_ops<=>uart_driver:8250.c)摘自：http://developer.51cto.com/art/201209/357501_all.htm
这一段描述我也不太能理解，希望有大神指导指导。我认为这一句作用与1差不多，都是将tegra_usrt_driver中的tty_driver 与tty_driver normal同步，这样子tty_drivers调用ops操作函数的时候自然会调用到tegra_uart_ops
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;
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;
}
/* 重要一句 */ driver->state->uart_port与 uport划上等号
state->uart_port = uport;
state->pm_state = -1;
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);
}
/* 实际调用 port->ops->config_port(port, flags) 稍后再看 */
uart_configure_port(drv, state, uport);
/*
* 上一篇文章中，我们提到tty注册了一个字符设备 “ttySAC ”
* 那么，我们平时看到的 “ttySAC0”“ttySAC1”等就是在这里注册的
*/
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);
/*
* Ensure UPF_DEAD is not set.
*/
uport->flags &= ~UPF_DEAD;
out:
mutex_unlock(&port->mutex);
mutex_unlock(&port_mutex);
return ret;
}
struct uart_state {
struct tty_port port;
enum uart_pm_state pm_state;
struct circ_buf xmit;
struct uart_port *uart_port;
};
struct uart_port的定义如下（节选）：
..
unsigned int read_status_mask; /* driver specific */
unsigned int ignore_status_mask; /* driver specific */
struct uart_state *state; /* pointer to parent state */
struct uart_icount icount; /* statistics */
..
3.tty_set_operations(normal, &uart_ops);
此句之所以值得关注是因为.在这里将tty_driver的操作集统一设为了uart_ops.这样就使得从用户空间下来的操作可以找到正确的serial_core的操作函数，uart_ops是在serial_core.c中的：所以结合
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
.read_proc = uart_read_proc,
#endif
.tiocmget = uart_tiocmget,
.tiocmset = uart_tiocmset,
#ifdef CONFIG_CONSOLE_POLL
.poll_init = uart_poll_init,
.poll_get_char = uart_poll_get_char,
.poll_put_char = uart_poll_put_char,
#endif
};直接分析tegra_uart_ops部分代码：
static struct uart_ops tegra_uart_ops = {
.tx_empty = tegra_uart_tx_empty,
.set_mctrl = tegra_uart_set_mctrl,
.get_mctrl = tegra_uart_get_mctrl,
.stop_tx = tegra_uart_stop_tx,
.start_tx = tegra_uart_start_tx,
.stop_rx = tegra_uart_stop_rx,
.flush_buffer = tegra_uart_flush_buffer,
.enable_ms = tegra_uart_enable_ms,
.break_ctl = tegra_uart_break_ctl,
.startup = tegra_uart_startup,
.shutdown = tegra_uart_shutdown,
.set_termios = tegra_uart_set_termios,
.type = tegra_uart_type,
.request_port = tegra_uart_request_port,
.release_port = tegra_uart_release_port,
};先看start_up操作，
static int tegra_uart_startup(struct uart_port *u)
{
struct tegra_uart_port *tup = to_tegra_uport(u);
int ret;
ret = tegra_uart_dma_channel_allocate(tup, false);
if (ret < 0) {
dev_err(u->dev, "Tx Dma allocation failed, err = %d\n", ret);
return ret;
}
if (!tup->use_rx_pio) {
ret = tegra_uart_dma_channel_allocate(tup, true);
if (ret < 0) {
dev_err(u->dev, "Rx Dma allocation failed, err = %d\n",
ret);
goto fail_rx_dma;
}
}
ret = tegra_uart_hw_init(tup);
if (ret < 0) {
dev_err(u->dev, "Uart HW init failed, err = %d\n", ret);
goto fail_hw_init;
}
ret = request_irq(u->irq, tegra_uart_isr, IRQF_DISABLED,
dev_name(u->dev), tup);//fast interrupt IQRF_DISABLED
if (ret < 0) {
dev_err(u->dev, "Failed to register ISR for IRQ %d\n", u->irq);
goto fail_hw_init;
}
return 0;
fail_hw_init:
if (!tup->use_rx_pio)
tegra_uart_dma_channel_free(tup, true);
fail_rx_dma:
tegra_uart_dma_channel_free(tup, false);
return ret;
}request_irq(u->irq, tegra_uart_isr, IRQF_DISABLED,
dev_name(u->dev), tup);进入中断处理函数：
static irqreturn_t tegra_uart_isr(int irq, void *data)
{
struct tegra_uart_port *tup = data;
struct uart_port *u = &tup->uport;
unsigned long iir;
unsigned long ier;
bool is_rx_int = false;
unsigned long flags;
int ret;
//struct timeval tstart,tend;
spin_lock_irqsave(&u->lock, flags);
while (1) {
iir = tegra_uart_read(tup, UART_IIR);
if (iir & UART_IIR_NO_INT) {
if (!tup->use_rx_pio && is_rx_int) {
ret = tegra_uart_handle_rx_dma(tup);
if (ret) {
spin_unlock_irqrestore(&u->lock, flags);
return IRQ_HANDLED;
}
if (tup->rx_in_progress) {
ier = tup->ier_shadow;
ier |= (UART_IER_RLSI | UART_IER_RTOIE |
TEGRA_UART_IER_EORD);
tup->ier_shadow = ier;
tegra_uart_write(tup, ier, UART_IER);
}
}
spin_unlock_irqrestore(&u->lock, flags);
return IRQ_HANDLED;
}
switch ((iir >> 1) & 0x7) {
case 0: /* Modem signal change interrupt */
tegra_uart_handle_modem_signal_change(u);
break;
case 1: /* Transmit interrupt only triggered when using PIO */
tup->ier_shadow &= ~UART_IER_THRI;
tegra_uart_write(tup, tup->ier_shadow, UART_IER);
tegra_uart_handle_tx_pio(tup);
break;
case 4: /* End of data */
case 6: /* Rx timeout */
//printk(KERN_ALERT"rx timeout \n");
case 2: /* Receive */
if (!tup->use_rx_pio && !is_rx_int) {
is_rx_int = true;
/* Disable Rx interrupts */
ier = tup->ier_shadow;
ier |= UART_IER_RDI;
tegra_uart_write(tup, ier, UART_IER);
ier &= ~(UART_IER_RDI | UART_IER_RLSI |
UART_IER_RTOIE |
TEGRA_UART_IER_EORD);
tup->ier_shadow = ier;
tegra_uart_write(tup, ier, UART_IER);
} else
do_handle_rx_pio(tup);
break;
case 3: /* Receive error */
tegra_uart_decode_rx_error(tup,
tegra_uart_read(tup, UART_LSR));
break;
case 5: /* break nothing to handle */
case 7: /* break nothing to handle */
break;
}
}
}is_rx_int = true;ret = tegra_uart_handle_rx_dma(tup);static int tegra_uart_handle_rx_dma(struct tegra_uart_port *tup)
{
struct timeval tstart,tend;
struct dma_tx_state state;
struct tty_struct *tty = tty_port_tty_get(&tup->uport.state->port);
struct tty_port *port = &tup->uport.state->port;
int count;
int rx_level = 0;
struct dma_async_tx_descriptor *prev_rx_dma_desc;
int ret;
/* Deactivate flow control to stop sender */
if (tup->rts_active)
set_rts(tup, false);
dmaengine_terminate_all(tup->rx_dma_chan);
dmaengine_tx_status(tup->rx_dma_chan, tup->rx_cookie, &state);
prev_rx_dma_desc = tup->rx_dma_desc;
count = tup->rx_bytes_requested - state.residue;
/* If we are here, DMA is stopped */
if (count) {
do_gettimeofday(&tstart);
ret = tegra_uart_copy_rx_to_tty(tup, port, count);//copy rx_dma_data to tty_buffer
do_gettimeofday(&tend);
printk("tegra_uart_copy_rx_to_tty taken: %ld us\n",1000000* (tend.tv_sec - tstart.tv_sec) +(tend.tv_usec - tstart.tv_usec) );
if (ret)
goto skip_pio;
}
do_gettimeofday(&tstart);
ret = tegra_uart_handle_rx_pio(tup, port);
do_gettimeofday(&tend);
printk("tegra_uart_handle_rx_pio taken: %ld us\n",1000000* (tend.tv_sec - tstart.tv_sec) +(tend.tv_usec - tstart.tv_usec) );
skip_pio:
if (tup->enable_rx_buffer_throttle) {
rx_level = tty_buffer_get_level(port);
if (rx_level > 70)
mod_timer(&tup->timer,
jiffies + tup->timer_timeout_jiffies);
}
if (tty) {
do_gettimeofday(&tstart);
tty_flip_buffer_push(port);//flip data of tty_buffer to read_buffer(user space and operated by read())
do_gettimeofday(&tend);
printk("tty_flip_buffer_push taken: %ld us\n",1000000* (tend.tv_sec - tstart.tv_sec) +(tend.tv_usec - tstart.tv_usec) );
tty_kref_put(tty);
}
tegra_uart_start_rx_dma(tup);
async_tx_ack(prev_rx_dma_desc);
if (tup->enable_rx_buffer_throttle) {
if ((rx_level <= 70) && tup->rts_active)
set_rts(tup, true);
} else if (tup->rts_active)
set_rts(tup, true);
return ret;
}然后触发中断的条件是什么呢？这是关键点
查看TegraK1_TRM_DP06905001_public_v03p.pdf（Technical Reference Manual）,关于uart_fifo 寄存器的说明
与上边代码中所有的case对应，case 6:rx_timeout_intr表示fifo 中有数据当没有达到trigger level,经过4 bytes的传输时间仍未有数据到达，触发rx_timeout
case 4:eord_timeout_intr(eord即 end of data),表示当fifo中无数据，经过4bytes的传输时间仍未有数据到达。触发eord中断。两种情况加以区分，如有纰漏敬请指出。
接下来进入tegra_uart_handle_rx_dma，代码如下：
static int tegra_uart_handle_rx_dma(struct tegra_uart_port *tup)
{
struct dma_tx_state state;
struct tty_struct *tty = tty_port_tty_get(&tup->uport.state->port);
struct tty_port *port = &tup->uport.state->port;
int count;
int rx_level = 0;
struct dma_async_tx_descriptor *prev_rx_dma_desc;
int ret;
/* Deactivate flow control to stop sender */
if (tup->rts_active)
set_rts(tup, false);
dmaengine_terminate_all(tup->rx_dma_chan);//停止dma传输,这一句花费较多时间，实机测试可能花费30us左右
dmaengine_tx_status(tup->rx_dma_chan, tup->rx_cookie, &state);//获得dma状态
prev_rx_dma_desc = tup->rx_dma_desc;
count = tup->rx_bytes_requested - state.residue;//获得dma中数据大小
/* If we are here, DMA is stopped */
if (count) {
ret = tegra_uart_copy_rx_to_tty(tup, port, count);//将数据从dma的buffer拷贝到tty_buffer，实机测试可能花费16us
if (ret) //ret只有两种状态，0或者负数（即出现错误），所以正常情况下会继续执行tegra_uart_handle_rx_pio
goto skip_pio;
}
ret = tegra_uart_handle_rx_pio(tup, port);
skip_pio:
if (tup->enable_rx_buffer_throttle) {
rx_level = tty_buffer_get_level(port);
if (rx_level > 70)
mod_timer(&tup->timer,
jiffies + tup->timer_timeout_jiffies);
}
if (tty) {
tty_flip_buffer_push(port);//将tty_buffer的数据push 到更上层的read_buf
tty_kref_put(tty);
}
tegra_uart_start_rx_dma(tup);//启动dma
async_tx_ack(prev_rx_dma_desc);
if (tup->enable_rx_buffer_throttle) {
if ((rx_level <= 70) && tup->rts_active)
set_rts(tup, true);
} else if (tup->rts_active)
set_rts(tup, true);
return ret;
}tegra_uart_handle_rx_pio的作用：检查fifo中是否有残余数据或是新数据，并用pio mode读取数据。这样做虽然可以防止数据丢失，但是如果有新数据在此时到来，相比dma模式读取数据的效率大大降低。
如果把这一句注释掉 ，那么如果有新数据在此时到来，dma又已经关闭，fifo中数据触发了trigger level 要往哪里去？关于最后这个问题欢迎大家留言指导一下