/************************************************************
* am335x uart分析
* 本文记录am335x uart驱动的注册过程。
* 参考：
* http://www.cnblogs.com/helloworldtoyou/p/5385595.html
* 涉及文件：
* arch/arm/mach-omap2/board-am335xevm.c
* drivers/tty/serial/omap-serial.c
*
* Tony Liu, 2016-5-2, Shenzhen
***********************************************************/
MACHINE_START(AM335XEVM, "am335xevm")
/* Maintainer: Texas Instruments */
.atag_offset = 0x100,
.map_io = am335x_evm_map_io,
.init_early = am33xx_init_early,
.init_irq = ti81xx_init_irq,
.handle_irq = omap3_intc_handle_irq,
.timer = &omap3_am33xx_timer,
.init_machine = am335x_evm_init, ---+
MACHINE_END |
|
static void __init am335x_evm_init(void) <--+
{
am33xx_cpuidle_init();
am33xx_mux_init(board_mux);
omap_serial_init();
am335x_evm_i2c_init();
omap_sdrc_init(NULL, NULL);
usb_musb_init(&musb_board_data);
omap_board_config = am335x_evm_config;
omap_board_config_size = ARRAY_SIZE(am335x_evm_config);
daughter_brd_detected = false;
setup_xxx_xxxx(); --+
...... |
} |
|
V
static void setup_xxx_xxxx(void)
{
/*which doesn't have Write Protect pin LAN8710A_PHY_ID */
am335x_mmc[].gpio_wp = -EINVAL;
int ret;
//配置引脚复用
_configure_device(EVM_SK, xxx_xxxx_dev_cfg, PROFILE_NONE); -----+
| |
} | |
V |
static void _configure_device(int evm_id, struct evm_dev_cfg *dev_cfg, |
int profile) |
{ |
int i; |
|
am335x_evm_set_id(evm_id); |
|
if (profile == PROFILE_NONE) { |
for (i = ; dev_cfg->device_init != NULL; dev_cfg++) { |
if (dev_cfg->device_on == DEV_ON_BASEBOARD) |
dev_cfg->device_init(evm_id, profile); |
else if (daughter_brd_detected == true) |
dev_cfg->device_init(evm_id, profile); |
} |
} else { |
for (i = ; dev_cfg->device_init != NULL; dev_cfg++) { |
if (dev_cfg->profile & profile) { |
if (dev_cfg->device_on == DEV_ON_BASEBOARD) |
dev_cfg->device_init(evm_id, profile); |
else if (daughter_brd_detected == true) |
dev_cfg->device_init(evm_id, profile); |
} |
} |
} |
} |
|
static struct evm_dev_cfg xxx_xxxx_dev_cfg[] = { <--------+
......
{uart0_init, DEV_ON_BASEBOARD, PROFILE_ALL},//fixed ---+
{uart1_init, DEV_ON_BASEBOARD, PROFILE_ALL},//fixed |
{uart4_init, DEV_ON_BASEBOARD, PROFILE_ALL},//fixed |
...... |
{NULL, , }, |
}; |
|
static void uart0_init(int evm_id, int profile) <---+
{
setup_pin_mux(uart0_pin_mux); ------+
return; | |
} | |
V |
static void setup_pin_mux(struct pinmux_config *pin_mux) |
{ |
int i; |
|
for (i = ; pin_mux->string_name != NULL; pin_mux++) |
omap_mux_init_signal(pin_mux->string_name, pin_mux->val); |
} |
|
static struct pinmux_config uart0_pin_mux[] = { <-----+
{"uart0_rxd.uart0_rxd", OMAP_MUX_MODE0 | AM33XX_PIN_INPUT_PULLUP},
{"uart0_txd.uart0_txd", OMAP_MUX_MODE0 | AM33XX_PULL_ENBL},
{"uart0_ctsn.uart0_ctsn", OMAP_MUX_MODE0 | AM33XX_PULL_ENBL},
{NULL, },
};
drivers/tty/serial/omap-serial.c
static int __init serial_omap_init(void)
{
int ret;
ret = uart_register_driver(&serial_omap_reg); -------+
if (ret != ) |
return ret; |
ret = platform_driver_register(&serial_omap_driver); --+ |
if (ret != ) | |
uart_unregister_driver(&serial_omap_reg); | |
return ret; | |
} | |
| |
static struct uart_driver serial_omap_reg = { | |
.owner = THIS_MODULE, | |
.driver_name = "OMAP-SERIAL", | |
.dev_name = OMAP_SERIAL_NAME, | |
.nr = OMAP_MAX_HSUART_PORTS, | |
.cons = OMAP_CONSOLE, | |
}; | |
| |
#define OMAP_SERIAL_NAME "ttyO" | |
#define OMAP_MAX_HSUART_PORTS 6 | |
| |
#define OMAP_CONSOLE (&serial_omap_console) | |
| |
static struct console serial_omap_console = { | <------+
.name = OMAP_SERIAL_NAME, |
.write = serial_omap_console_write, |
.device = uart_console_device, |
.setup = serial_omap_console_setup, |
.flags = CON_PRINTBUFFER, |
.index = -, |
.data = &serial_omap_reg, |
}; |
|
static struct platform_driver serial_omap_driver = { <--+
.probe = serial_omap_probe,
.remove = serial_omap_remove,
.driver = {
.name = DRIVER_NAME,
.pm = &serial_omap_dev_pm_ops,
.of_match_table = of_match_ptr(omap_serial_of_match),
},
};
static int serial_omap_probe(struct platform_device *pdev)
{
struct uart_omap_port *up;
struct resource *mem, *irq, *dma_tx, *dma_rx;
struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data;
int ret = -ENOSPC;
if (pdev->dev.of_node)
omap_up_info = of_get_uart_port_info(&pdev->dev);
......
up->pdev = pdev;
up->port.dev = &pdev->dev;
up->port.type = PORT_OMAP;
up->port.iotype = UPIO_MEM;
up->port.irq = irq->start;
up->port.regshift = ;
up->port.fifosize = ;
up->port.ops = &serial_omap_pops; --------+
|
if (pdev->dev.of_node) |
up->port.line = of_alias_get_id(pdev->dev.of_node, "serial"); |
else |
up->port.line = pdev->id; |
|
if (up->port.line < ) { |
dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n", |
up->port.line); |
ret = -ENODEV; |
goto err; |
} |
|
sprintf(up->name, "OMAP UART%d", up->port.line); |
up->port.mapbase = mem->start; |
up->port.membase = ioremap(mem->start, resource_size(mem)); |
if (!up->port.membase) { |
dev_err(&pdev->dev, "can't ioremap UART\n"); |
ret = -ENOMEM; |
goto err; |
} |
|
up->port.flags = omap_up_info->flags; |
up->port.uartclk = omap_up_info->uartclk; |
if (!up->port.uartclk) { |
up->port.uartclk = DEFAULT_CLK_SPEED; |
dev_warn(&pdev->dev, "No clock speed specified: using default:" |
"%d\n", DEFAULT_CLK_SPEED); |
} |
up->uart_dma.uart_base = mem->start; |
up->errata = omap_up_info->errata; |
|
if (omap_up_info->dma_enabled) { |
up->uart_dma.uart_dma_tx = dma_tx->start; |
up->uart_dma.uart_dma_rx = dma_rx->start; |
up->use_dma = ; |
up->uart_dma.rx_buf_size = omap_up_info->dma_rx_buf_size; |
up->uart_dma.rx_timeout = omap_up_info->dma_rx_timeout; |
up->uart_dma.rx_poll_rate = omap_up_info->dma_rx_poll_rate; |
spin_lock_init(&(up->uart_dma.tx_lock)); |
spin_lock_init(&(up->uart_dma.rx_lock)); |
up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE; |
up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE; |
} |
|
up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; |
up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; |
pm_qos_add_request(&up->pm_qos_request, |
PM_QOS_CPU_DMA_LATENCY, up->latency); |
serial_omap_uart_wq = create_singlethread_workqueue(up->name); |
INIT_WORK(&up->qos_work, serial_omap_uart_qos_work); |
|
pm_runtime_use_autosuspend(&pdev->dev); |
pm_runtime_set_autosuspend_delay(&pdev->dev, |
omap_up_info->autosuspend_timeout); |
|
pm_runtime_irq_safe(&pdev->dev); |
pm_runtime_enable(&pdev->dev); |
pm_runtime_get_sync(&pdev->dev); |
|
ui[up->port.line] = up; |
serial_omap_add_console_port(up); |
|
ret = uart_add_one_port(&serial_omap_reg, &up->port); --------------+ |
if (ret != ) | |
goto do_release_region; | |
| |
pm_runtime_put(&pdev->dev); | |
platform_set_drvdata(pdev, up); | |
return ; | |
err: | |
dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", | |
pdev->id, __func__, ret); | |
do_release_region: | |
release_mem_region(mem->start, resource_size(mem)); | |
return ret; | |
} | |
| |
static struct uart_ops serial_omap_pops = { <--------|--+
.tx_empty = serial_omap_tx_empty, |
.set_mctrl = serial_omap_set_mctrl, |
.get_mctrl = serial_omap_get_mctrl, |
.stop_tx = serial_omap_stop_tx, |
.start_tx = serial_omap_start_tx, |
.stop_rx = serial_omap_stop_rx, |
.enable_ms = serial_omap_enable_ms, |
.break_ctl = serial_omap_break_ctl, |
.startup = serial_omap_startup, |
.shutdown = serial_omap_shutdown, |
.set_termios = serial_omap_set_termios, |
.pm = serial_omap_pm, |
.type = serial_omap_type, |
.release_port = serial_omap_release_port, |
.request_port = serial_omap_request_port, |
.config_port = serial_omap_config_port, |
.verify_port = serial_omap_verify_port, |
#ifdef CONFIG_CONSOLE_POLL |
.poll_put_char = serial_omap_poll_put_char, |
.poll_get_char = serial_omap_poll_get_char, |
#endif |
}; |
|
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;
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 = -;
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);
}
uart_configure_port(drv, state, uport);
/*
* Register the port whether it's detected or not. This allows
* setserial to be used to alter this ports parameters.
*/
tty_dev = tty_register_device(drv->tty_driver, uport->line, uport->dev); -----+
if (likely(!IS_ERR(tty_dev))) { |
device_init_wakeup(tty_dev, ); |
device_set_wakeup_enable(tty_dev, ); |
} 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 device *tty_register_device(struct tty_driver *driver, unsigned index, <---+
struct device *device)
{
char name[];
dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
if (index >= driver->num) {
printk(KERN_ERR "Attempt to register invalid tty line number "
" (%d).\n", index);
return ERR_PTR(-EINVAL);
}
if (driver->type == TTY_DRIVER_TYPE_PTY)
pty_line_name(driver, index, name);
else
tty_line_name(driver, index, name); ---+
|
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);
}