五 linux 串口驱动

一.串口结构体

1.串口驱动结构体

struct uart_driver {
	struct module	*owner;	//模块所有者
	const char	*driver_name;	//驱动名
	const char	*dev_name;	//设备名
	int	 major;	//主设备号
	int	 minor;	//次设备号
	int	 nr;	//支持串口个数
	struct console	*cons;	//控制台设备
	struct uart_state	*state;	//串口状态
	struct tty_driver	*tty_driver;	//tty设备
};

2.串口端口结构体

struct uart_port {
	spinlock_t	lock;
	unsigned long	iobase;	//io端口基地址
	unsigned char __iomem	*membase;		//内存端口基地址
	unsigned int	(*serial_in)(struct uart_port *, int);
	void	(*serial_out)(struct uart_port *, int, int);
	void	(*set_termios)(struct uart_port *,struct ktermios *new,struct ktermios *old);
	void	(*pm)(struct uart_port *, unsigned int state,unsigned int old);
	unsigned int	irq;	//中断号
	unsigned long	irqflags;	//中断标志
	unsigned int	uartclk;
	unsigned int	fifosize;	//fifo大小	
	unsigned char	x_char;
	unsigned char	regshift;	//寄存器偏移值	
	unsigned char	iotype;	//io访问类型
	unsigned char	unused1;
	unsigned int	read_status_mask;
	unsigned int	ignore_status_mask;
	struct uart_state	*state;	//uart_state结构体	
	struct uart_icount	icount;	//串口使用计数
	struct console	*cons;	//console控制台
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
	unsigned long	sysrq;
#endif
	upf_t	flags;
	unsigned int	mctrl;
	unsigned int	timeout;
	unsigned int	type;
	const struct uart_ops	*ops;	//串口操作函数集
	unsigned int	custom_divisor;
	unsigned int	line;	//端口号
	resource_size_t	mapbase;
	struct device	*dev;	//设备文件
	unsigned char	hub6;
	unsigned char	suspended;
	unsigned char	irq_wake;
	unsigned char	unused[2];
	void	*private_data;
};

3.操作函数集

struct uart_ops {
	unsigned int	(*tx_empty)(struct uart_port *);	//发送缓冲区为空
	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);
	void	(*stop_rx)(struct uart_port *);	//停止接收
	void	(*enable_ms)(struct uart_port *);	//使能modem状态信息
	void	(*break_ctl)(struct uart_port *, int ctl);
	int	(*startup)(struct uart_port *);	//打开串口
	void	(*shutdown)(struct uart_port *);	//关闭串口
	void	(*flush_buffer)(struct uart_port *);
	void	(*set_termios)(struct uart_port *, struct ktermios *new,struct ktermios *old);	//设置串口参数
	void	(*set_ldisc)(struct uart_port *, int new);
	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 *);	//释放端口
	int	(*request_port)(struct uart_port *);	//请求端口
	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);	//控制
#ifdef CONFIG_CONSOLE_POLL
	void	(*poll_put_char)(struct uart_port *, unsigned char);
	int	(*poll_get_char)(struct uart_port *);
#endif
};

4.uart_state

struct uart_state {
	struct tty_port	port;
	int		pm_state;
	struct circ_buf	xmit;
	struct tasklet_struct	tlet;
	struct uart_port	*uart_port;
};

 

二.串口驱动的注册与注销

注册

int uart_register_driver(struct uart_driver *drv)
{
	struct tty_driver *normal;
	int i, retval;
	BUG_ON(drv->state);
	drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);	//分配uart_state内存
	if (!drv->state)
		goto out;
	normal = alloc_tty_driver(drv->nr);	//分配tty_driver
	if (!normal)
		goto out_kfree;
	drv->tty_driver = normal;	//tty_driver和uart_driver捆绑

	normal->owner		= drv->owner;	//模块所有者
	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;	//tty类型
	normal->subtype		= SERIAL_TYPE_NORMAL;	//tty子类型
	normal->init_termios	= tty_std_termios;		//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);	//设置tty操作函数集

	for (i = 0; i < drv->nr; i++) {	//初始化uart_state
		struct uart_state *state = drv->state + i;
		struct tty_port *port = &state->port;
		tty_port_init(port);	//初始化tty端口
		port->ops = &uart_port_ops;	//tty端口操作函数集
		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);	//注册tty驱动
	if (retval >= 0)
		return retval;

	put_tty_driver(normal);	//引用计数
out_kfree:
	kfree(drv->state);
out:
	return -ENOMEM;
}

 注销

void uart_unregister_driver(struct uart_driver *drv)
{
	struct tty_driver *p = drv->tty_driver;
	tty_unregister_driver(p);	//注销tty驱动
	put_tty_driver(p);	//减少引用计数
	kfree(drv->state);
	drv->tty_driver = NULL;
}

三.端口注册与注销

注册

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;	//获取uart_state
	port = &state->port;	//获取tty_port
	mutex_lock(&port_mutex);
	mutex_lock(&port->mutex);
	if (state->uart_port) {
		ret = -EINVAL;
		goto out;
	}
	state->uart_port = uport;	//设置uart_state->uart_port
	state->pm_state = -1;
	uport->cons = drv->cons;	//设置uart_port->cons控制台
	uport->state = state;	//设置uart_port->state
	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);	//生成tty设备文件/dev/ttyXXX
	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;
 out:
	mutex_unlock(&port->mutex);
	mutex_unlock(&port_mutex);

	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;
	if (!port->iobase && !port->mapbase && !port->membase)
		return;
	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);	//调用uart_port的config_port方法
	}

	if (port->type != PORT_UNKNOWN) {
		unsigned long flags;
		uart_report_port(drv, port);
		uart_change_pm(state, 0);
		spin_lock_irqsave(&port->lock, flags);
		port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);	//调用uart_port的set_mctrl方法
		spin_unlock_irqrestore(&port->lock, flags);
		if (port->cons && !(port->cons->flags & CON_ENABLED))	//若console存在且设置了CON_ENABLED标志
			register_console(port->cons);	//注册控制台设备
		if (!uart_console(port))
			uart_change_pm(state, 3);
	}
}

 注销

int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
{
	struct uart_state *state = drv->state + uport->line;
	struct tty_port *port = &state->port;
	BUG_ON(in_interrupt());
	if (state->uart_port != uport)
		printk(KERN_ALERT "Removing wrong port: %p != %p\n",state->uart_port, uport);
	mutex_lock(&port_mutex);
	mutex_lock(&port->mutex);
	uport->flags |= UPF_DEAD;
	mutex_unlock(&port->mutex);
	tty_unregister_device(drv->tty_driver, uport->line);
	if (port->tty)
		tty_vhangup(port->tty);
	if (uport->type != PORT_UNKNOWN)
		uport->ops->release_port(uport);
	uport->type = PORT_UNKNOWN;
	tasklet_kill(&state->tlet);
	state->uart_port = NULL;
	mutex_unlock(&port_mutex);
	return 0;
}

四.串口对应的tty_driver的操作函数集

1.tty的操作函数集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
};

2.open方法

static int uart_open(struct tty_struct *tty, struct file *filp)
{
	struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
	struct uart_state *state;
	struct tty_port *port;
	int retval, line = tty->index;

	BUG_ON(!tty_locked());
	pr_debug("uart_open(%d) called\n", line);
	retval = -ENODEV;
	if (line >= tty->driver->num)
		goto fail;
	state = uart_get(drv, line);	//获取uart_state
	if (IS_ERR(state)) {
		retval = PTR_ERR(state);
		goto fail;
	}
	port = &state->port;	//获取tty_port
	tty->driver_data = state;
	state->uart_port->state = state;
	tty->low_latency = (state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
	tty->alt_speed = 0;
	tty_port_tty_set(port, tty);
	if (tty_hung_up_p(filp)) {
		retval = -EAGAIN;
		port->count--;
		mutex_unlock(&port->mutex);
		goto fail;
	}
	if (port->count == 1)
		uart_change_pm(state, 0);
	retval = uart_startup(tty, state, 0);	//启动串口
	mutex_unlock(&port->mutex);
	if (retval == 0)
		retval = tty_port_block_til_ready(port, tty, filp);
fail:
	return retval;
}

uart_startup

static int uart_startup(struct tty_struct *tty, struct uart_state *state, int init_hw)
{
	struct uart_port *uport = state->uart_port;	//获取uart_port
	struct tty_port *port = &state->port;	//获取tty_port
	unsigned long page;
	int retval = 0;

	if (port->flags & ASYNC_INITIALIZED)
		return 0;
	set_bit(TTY_IO_ERROR, &tty->flags);
	if (uport->type == PORT_UNKNOWN)
		return 0;
	if (!state->xmit.buf) {
		/* This is protected by the per port mutex */
		page = get_zeroed_page(GFP_KERNEL);
		if (!page)
			return -ENOMEM;
		state->xmit.buf = (unsigned char *) page;
		uart_circ_clear(&state->xmit);
	}
	retval = uport->ops->startup(uport);	//调用uart_port的startup方法
	if (retval == 0) {
		if (init_hw) {
			uart_change_speed(tty, state, NULL);
			if (tty->termios->c_cflag & CBAUD)
				uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
		}
		if (port->flags & ASYNC_CTS_FLOW) {
			spin_lock_irq(&uport->lock);
			if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS))
				tty->hw_stopped = 1;
			spin_unlock_irq(&uport->lock);
		}
		set_bit(ASYNCB_INITIALIZED, &port->flags);
		clear_bit(TTY_IO_ERROR, &tty->flags);
	}
	if (retval && capable(CAP_SYS_ADMIN))
		retval = 0;
	return retval;
}

3.写方法

static int uart_write(struct tty_struct *tty,const unsigned char *buf, int count)
{
	struct uart_state *state = tty->driver_data;	//获取uart_state
	struct uart_port *port;
	struct circ_buf *circ;
	unsigned long flags;
	int c, ret = 0;
	if (!state) {
		WARN_ON(1);
		return -EL3HLT;
	}
	port = state->uart_port;	//获取uart_port
	circ = &state->xmit;
	if (!circ->buf)
		return 0;

	spin_lock_irqsave(&port->lock, flags);
	while (1) {
		c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
		if (count < c)
			c = count;
		if (c <= 0)
			break;
		memcpy(circ->buf + circ->head, buf, c);
		circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
		buf += c;
		count -= c;
		ret += c;
	}
	spin_unlock_irqrestore(&port->lock, flags);
	uart_start(tty);	//调用uart_start方法
	return ret;
}

uart_start

static void uart_start(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;	//获取tty_state
	struct uart_port *port = state->uart_port;	//获取uart_port
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	__uart_start(tty);		//调用__uart_start函数
	spin_unlock_irqrestore(&port->lock, flags);
}

uart_start>>>__uart_start

static void __uart_start(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;	//获取uart_state
	struct uart_port *port = state->uart_port;	//获取uart_port
	if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&!tty->stopped && !tty->hw_stopped)
		port->ops->start_tx(port);	//调用uart_port的start_tx方法
}